supports imports of langchain tools

Author: chrishayuk

examples/demo_langchain_tool.py

@@ -0,0 +1,54 @@
+# examples/demo_langchain_tool.py
+"""
+Demo: register a LangChain `BaseTool` with chuk-tool-processor and invoke it.
+"""
+
+from __future__ import annotations
+import asyncio
+from typing import ClassVar, Any
+
+from langchain.tools.base import BaseTool
+from chuk_tool_processor.registry.auto_register import register_langchain_tool
+from chuk_tool_processor.core.processor import ToolProcessor
+from chuk_tool_processor.models.tool_call import ToolCall
+
+
+# ── LangChain tool definition ───────────────────────────────────────────────
+class PalindromeTool(BaseTool):
+    # pydantic requires concrete type annotations here
+    name: ClassVar[str] = "palindrome_tool"
+    description: ClassVar[str] = (
+        "Return whether the given text is a palindrome."
+    )
+
+    # synchronous implementation (BaseTool will call this from .run/.arun)
+    def _run(self, tool_input: str, *args: Any, **kwargs: Any) -> dict:
+        is_pal = tool_input.lower() == tool_input[::-1].lower()
+        return {"text": tool_input, "palindrome": is_pal}
+
+    # asynchronous implementation (optional but nice to have)
+    async def _arun(
+        self, tool_input: str, run_manager: Any | None = None, **kwargs: Any
+    ) -> dict:  # noqa: D401
+        # Just delegate to the sync version for this demo
+        return self._run(tool_input)
+
+
+# ── register with the global registry ───────────────────────────────────────
+register_langchain_tool(PalindromeTool())
+
+
+# ── quick test run ──────────────────────────────────────────────────────────
+async def main() -> None:
+    proc = ToolProcessor(enable_caching=False)
+
+    # Pretend the LLM called the tool with {"tool_input": "Madam"}
+    call = ToolCall(tool="palindrome_tool", arguments={"tool_input": "Madam"})
+    [result] = await proc.executor.execute([call])
+
+    print("Tool results:")
+    print("·", result.tool, result.result)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

pyproject.toml

@@ -12,6 +12,7 @@ dependencies = [
     "dotenv>=0.9.9",
     "openai>=1.76.0",
     "pydantic>=2.11.3",
+    "uuid>=1.30",
 ]
 
 # Tell setuptools to look in src/ for your a2a package
@@ -31,4 +32,7 @@ asyncio_mode = "strict"
 dev = [
     "pytest-asyncio>=0.26.0",
     "pytest>=8.3.5",
+    "langchain>=0.3.24",
+    "langchain-community>=0.3.22",
+    "langchain-openai>=0.3.14",
 ]

src/chuk_tool_processor/plugins/exporters/langchain/__init__.py

@@ -0,0 +1,31 @@
+# chuk_tool_processor/plugins/exporters/langchain/__init__.py
+"""
+Exporter plugin: expose every registry tool as a LangChain `BaseTool`.
+Category = "exporter", Name = "langchain"
+"""
+from __future__ import annotations
+
+from chuk_tool_processor.plugins.discovery import plugin_registry
+from .bridge import registry_as_langchain_tools   # lazy import happens inside
+
+# --------------------------------------------------------------------------- #
+# build the exporter instance *once* ---------------------------------------- #
+# --------------------------------------------------------------------------- #
+class _LCExporter:
+    """Callable wrapper – behaves like any other exporter plugin."""
+
+    def __call__(self, *, filter_names: list[str] | None = None):
+        return registry_as_langchain_tools(filter_names)
+
+    # keep the `.run()` synonym that LangChain likes to use
+    run = __call__
+
+
+# --------------------------------------------------------------------------- #
+# register **the instance** (not the factory) ------------------------------- #
+# --------------------------------------------------------------------------- #
+plugin_registry.register_plugin(      # type: ignore[attr-defined]
+    "exporter",
+    "langchain",
+    _LCExporter(),                    # ← note the *call* – we store the object
+)

src/chuk_tool_processor/registry/auto_register.py

@@ -0,0 +1,125 @@
+# chuk_tool_processor/registry/auto_register.py
+"""
+Tiny “auto-register” helpers so you can do
+
+    register_fn_tool(my_function)
+    register_langchain_tool(my_langchain_tool)
+
+and they immediately show up in the global registry.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+import types
+from typing import Callable, ForwardRef, Type, get_type_hints
+
+import anyio
+from pydantic import BaseModel, create_model
+
+try:  # optional dependency
+    from langchain.tools.base import BaseTool  # type: ignore
+except ModuleNotFoundError:  # pragma: no cover
+    BaseTool = None  # noqa: N816  – keep the name for isinstance() checks
+
+from chuk_tool_processor.registry.decorators import register_tool
+
+
+# ────────────────────────────────────────────────────────────────────────────
+# internals – build a Pydantic schema from an arbitrary callable
+# ────────────────────────────────────────────────────────────────────────────
+
+
+def _auto_schema(func: Callable) -> Type[BaseModel]:
+    """
+    Turn a function signature into a `pydantic.BaseModel` subclass.
+
+    *Unknown* or *un-imported* annotations (common with third-party libs that
+    use forward-refs without importing the target – e.g. ``uuid.UUID`` in
+    LangChain’s `CallbackManagerForToolRun`) default to ``str`` instead of
+    crashing `get_type_hints()`.
+    """
+    try:
+        hints = get_type_hints(func)
+    except Exception:
+        hints = {}
+
+    fields: dict[str, tuple[type, object]] = {}
+    for param in inspect.signature(func).parameters.values():
+        raw_hint = hints.get(param.name, param.annotation)
+        # Default to ``str`` for ForwardRef / string annotations or if we
+        # couldn’t resolve the type.
+        hint: type = (
+            raw_hint
+            if raw_hint not in (inspect._empty, None, str)
+            and not isinstance(raw_hint, (str, ForwardRef))
+            else str
+        )
+        fields[param.name] = (hint, ...)  # “...”  → required
+
+    return create_model(f"{func.__name__.title()}Args", **fields)  # type: ignore
+
+
+# ────────────────────────────────────────────────────────────────────────────
+# 1️⃣  plain Python function  (sync **or** async)
+# ────────────────────────────────────────────────────────────────────────────
+
+
+def register_fn_tool(
+    func: Callable,
+    *,
+    name: str | None = None,
+    description: str | None = None,
+) -> None:
+    """Register a plain function as a tool – one line is all you need."""
+
+    schema = _auto_schema(func)
+    name = name or func.__name__
+    description = (description or func.__doc__ or "").strip()
+
+    @register_tool(name=name, description=description, arg_schema=schema)
+    class _Tool:  # noqa: D401, N801 – internal auto-wrapper
+        async def _execute(self, **kwargs):
+            if inspect.iscoroutinefunction(func):
+                return await func(**kwargs)
+            # off-load blocking sync work
+            return await anyio.to_thread.run_sync(func, **kwargs)
+
+
+# ────────────────────────────────────────────────────────────────────────────
+# 2️⃣  LangChain BaseTool (or anything that quacks like it)
+# ────────────────────────────────────────────────────────────────────────────
+
+
+def register_langchain_tool(
+    tool,
+    *,
+    name: str | None = None,
+    description: str | None = None,
+) -> None:
+    """
+    Register a **LangChain** `BaseTool` instance (or anything exposing
+    ``.run`` / ``.arun``).
+
+    If LangChain isn’t installed you’ll get a clear error instead of an import
+    failure deep in the stack.
+    """
+    if BaseTool is None:
+        raise RuntimeError(
+            "register_langchain_tool() requires LangChain - "
+            "install with `pip install langchain`"
+        )
+
+    if not isinstance(tool, BaseTool):  # pragma: no cover
+        raise TypeError(
+            "Expected a langchain.tools.base.BaseTool instance – got "
+            f"{type(tool).__name__}"
+        )
+
+    fn = tool.arun if hasattr(tool, "arun") else tool.run  # prefer async
+    register_fn_tool(
+        fn,
+        name=name or tool.name or tool.__class__.__name__,
+        description=description or tool.description or (tool.__doc__ or ""),
+    )

src/chuk_tool_processor/registry/provider.py

@@ -1,44 +1,44 @@
 # chuk_tool_processor/registry/provider.py
 """
-Registry provider that maintains a global tool registry.
+Global access to *the* tool-registry instance.
 """
+from __future__ import annotations
+
 from typing import Optional
 
-# imports
-from chuk_tool_processor.registry.interface import ToolRegistryInterface
-from chuk_tool_processor.registry.providers import get_registry
-
-
-class ToolRegistryProvider:
-    """
-    Global provider for a ToolRegistryInterface implementation.
-    Use `set_registry` to override (e.g., for testing).
-    
-    This class provides a singleton-like access to a registry implementation,
-    allowing components throughout the application to access the same registry
-    without having to pass it explicitly.
-    """
-    # Initialize with default registry
-    _registry: Optional[ToolRegistryInterface] = None
-
-    @classmethod
-    def get_registry(cls) -> ToolRegistryInterface:
-        """
-        Get the current registry instance.
-        
-        Returns:
-            The current registry instance.
-        """
-        if cls._registry is None:
-            cls._registry = get_registry()
-        return cls._registry
-
-    @classmethod
-    def set_registry(cls, registry: ToolRegistryInterface) -> None:
-        """
-        Set the global registry instance.
-        
-        Args:
-            registry: The registry instance to use.
-        """
-        cls._registry = registry
+from .interface import ToolRegistryInterface
+from .providers.memory import InMemoryToolRegistry   # default impl
+
+# ───────────────────────────────────────────────────────────────────────────
+_REGISTRY: Optional[ToolRegistryInterface] = None
+# ───────────────────────────────────────────────────────────────────────────
+
+
+def get_registry() -> ToolRegistryInterface:
+    """Return the single, process-wide registry instance."""
+    global _REGISTRY
+    if _REGISTRY is None:
+        _REGISTRY = InMemoryToolRegistry()
+    return _REGISTRY
+
+
+def set_registry(registry: ToolRegistryInterface) -> None:
+    """Swap in another implementation (tests, multi-process, …)."""
+    global _REGISTRY
+    _REGISTRY = registry
+
+
+# ------------------------------------------------------------------------- #
+# 🔌 backward-compat shim – lets old `from … import ToolRegistryProvider`
+#    statements keep working without changes.
+# ------------------------------------------------------------------------- #
+class ToolRegistryProvider:                          # noqa: D401
+    """Compatibility wrapper around the new helpers."""
+
+    @staticmethod
+    def get_registry() -> ToolRegistryInterface:     # same signature
+        return get_registry()
+
+    @staticmethod
+    def set_registry(registry: ToolRegistryInterface) -> None:
+        set_registry(registry)