glean-agent-toolkit 0.2.0__py3-none-any.whl

glean/agent_toolkit/__init__.py

@@ -0,0 +1,30 @@
+"""
+Glean Agent Toolkit.
+
+Universal Tool/Action Toolkit for Glean agent frameworks.
+"""
+
+import logging
+from importlib.metadata import PackageNotFoundError, version
+
+from glean.agent_toolkit.decorators import tool_spec
+from glean.agent_toolkit.registry import get_registry
+from glean.agent_toolkit.spec import ToolSpec
+
+from . import adapters
+
+__all__ = [
+    "tool_spec",
+    "get_registry",
+    "ToolSpec",
+    "adapters",
+    "__version__",
+]
+
+try:
+    __version__ = version("glean-agent-toolkit")
+except PackageNotFoundError:  # pragma: no cover – package not installed
+    __version__ = "0.0.0"
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())

glean/agent_toolkit/adapters/__init__.py

@@ -0,0 +1,24 @@
+"""Adapters for converting tool specifications to framework-specific formats."""
+
+from pydantic import BaseModel
+
+from glean.agent_toolkit.adapters.adk import ADKAdapter
+from glean.agent_toolkit.adapters.base import BaseAdapter
+from glean.agent_toolkit.adapters.crewai import CrewAIAdapter
+from glean.agent_toolkit.adapters.langchain import LangChainAdapter
+from glean.agent_toolkit.adapters.openai import (
+    OpenAIAdapter,
+    OpenAIFunctionDef,
+    OpenAIToolDef,
+)
+
+__all__ = [
+    "BaseAdapter",
+    "ADKAdapter",
+    "CrewAIAdapter",
+    "LangChainAdapter",
+    "OpenAIAdapter",
+    "OpenAIToolDef",
+    "OpenAIFunctionDef",
+    "BaseModel",
+]

glean/agent_toolkit/adapters/adk.py

@@ -0,0 +1,81 @@
+"""Google ADK adapter for converting tool specifications."""
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, TypeAlias
+
+from glean.agent_toolkit.adapters.base import BaseAdapter
+from glean.agent_toolkit.spec import ToolSpec
+
+if TYPE_CHECKING:
+    from google.adk.tools import FunctionTool as _RealAdkFunctionTool
+else:
+    _RealAdkFunctionTool = Any  # type: ignore
+
+HAS_ADK: bool
+
+
+class _FallbackAdkFunctionTool:
+    """Fallback for google.adk.tools.FunctionTool.
+
+    This lightweight stand-in mimics the public attributes accessed by tests
+    (``name``, ``description``, ``schema`` and ``func``). It purposefully keeps
+    the same runtime surface as the real ADK ``FunctionTool`` so that unit
+    tests exercising the adapter behave consistently even when the dependency
+    is missing.
+    """
+
+    name: str
+    description: str | None
+    func: Callable[..., Any]
+    schema: dict[str, Any] | None
+
+    def __init__(self, func: Callable[..., Any]) -> None:  # noqa: D401 – keep signature minimal
+        self.func = func
+        self.name = func.__name__
+        self.description = func.__doc__
+        self.schema = None  # Set later by the adapter
+
+
+try:
+    from google.adk.tools import FunctionTool as _RuntimeAdkFunctionTool
+
+    HAS_ADK = True
+except ImportError:  # pragma: no cover
+    _RuntimeAdkFunctionTool = _FallbackAdkFunctionTool  # type: ignore
+    HAS_ADK = False
+
+# Single alias used for typing and at runtime
+AdkFunctionTool: TypeAlias = _RealAdkFunctionTool | _FallbackAdkFunctionTool
+
+
+class ADKAdapter(BaseAdapter["AdkFunctionTool"]):
+    """Adapter for Google ADK tools."""
+
+    def __init__(self, tool_spec: ToolSpec) -> None:
+        """Initialize the adapter.
+
+        Args:
+            tool_spec: The tool specification
+        """
+        super().__init__(tool_spec)
+        if not HAS_ADK:
+            raise ImportError(
+                "Google Agent Development Kit (ADK) is required for ADK adapter. "
+                "Install it with `pip install agent_toolkit[adk]` or `pip install google-adk`."
+            )
+
+    def to_tool(self) -> "AdkFunctionTool":
+        """Convert to Google ADK FunctionTool format.
+
+        Returns:
+            An ADK FunctionTool instance
+        """
+        func = self.tool_spec.function
+        if not func.__doc__:
+            func.__doc__ = self.tool_spec.description
+
+        tool = _RuntimeAdkFunctionTool(func=func)  # type: ignore[arg-type]
+
+        setattr(tool, "schema", self.tool_spec.input_schema)
+
+        return tool

glean/agent_toolkit/adapters/base.py

@@ -0,0 +1,29 @@
+"""Base adapter class for converting tool specifications to framework-specific formats."""
+
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+
+from glean.agent_toolkit.spec import ToolSpec
+
+T = TypeVar("T")
+
+
+class BaseAdapter(Generic[T], ABC):
+    """Base adapter for converting ToolSpec to framework-specific formats."""
+
+    def __init__(self, tool_spec: ToolSpec) -> None:
+        """Initialize the adapter.
+
+        Args:
+            tool_spec: The tool specification
+        """
+        self.tool_spec = tool_spec
+
+    @abstractmethod
+    def to_tool(self) -> T:
+        """Convert to framework-specific tool format.
+
+        Returns:
+            The framework-specific representation of the tool
+        """
+        pass

glean/agent_toolkit/adapters/crewai.py

@@ -0,0 +1,208 @@
+"""CrewAI adapter for converting tool specifications."""
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Union, cast
+
+from pydantic import BaseModel
+
+from glean.agent_toolkit.adapters.base import BaseAdapter
+from glean.agent_toolkit.spec import ToolSpec
+
+if TYPE_CHECKING:
+    from crewai.tools import BaseTool as CrewBaseTool
+else:
+    CrewBaseTool = Any  # type: ignore  # noqa: N816
+
+from pydantic import Field as PydanticField  # type: ignore
+from pydantic import create_model as pydantic_create_model
+
+HAS_CREWAI: bool
+
+
+class _FallbackCrewBaseTool:
+    """Fallback for crewai.tools.BaseTool."""
+
+    name: str
+    description: str
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # noqa: D107
+        pass
+
+    def _run(self, *args: Any, **kwargs: Any) -> Any:  # noqa: D401
+        ...
+
+
+def _fallback_field(*args: Any, **kwargs: Any) -> Any:  # noqa: N802
+    """Fallback for pydantic.Field."""
+    return None
+
+
+def _fallback_create_model(*args: Any, **kwargs: Any) -> Any:
+    """Fallback for pydantic.create_model."""
+    return None
+
+
+try:
+    from crewai.tools import BaseTool as _ActualCrewBaseTool  # type: ignore
+    from pydantic import Field as _ActualField  # type: ignore
+    from pydantic import create_model as _actual_create_model
+
+    BaseTool = _ActualCrewBaseTool
+    Field = _ActualField
+    create_model = _actual_create_model
+    HAS_CREWAI = True
+except ImportError:  # pragma: no cover
+    BaseTool = _FallbackCrewBaseTool  # type: ignore[assignment]
+    Field = _fallback_field  # type: ignore[assignment]
+    create_model = _fallback_create_model  # type: ignore[assignment]
+    HAS_CREWAI = False
+
+
+class GleanCrewAITool(BaseTool):  # type: ignore[misc]
+    """CrewAI tool implementation for Glean tools."""
+
+    name: str  # CrewAI BaseTool requires name and description
+    description: str  # CrewAI BaseTool requires name and description
+    # Reuse BaseTool's built-in placeholder default for ``args_schema`` so that
+    # CrewAI can lazily infer a schema when one isn't supplied. We intentionally
+    # *do not* override the attribute here to avoid accidentally setting it to
+    # ``None`` and breaking CrewAI's internal description generation logic.
+
+    _function: Callable[..., Any]
+
+    def __init__(
+        self,
+        name: str,
+        description: str,
+        function: Callable[..., Any],
+        args_schema: type[BaseModel] | None = None,
+    ) -> None:
+        """Initialize the tool.
+
+        Args:
+            name: The name of the tool
+            description: A description of the tool
+            function: The function to call when the tool is invoked
+            args_schema: Optional schema for the arguments
+        """
+        super().__init__(name=name, description=description)
+
+        self._function = function
+
+        # Only override ``args_schema`` when we actually created one; otherwise
+        # leave the placeholder so CrewAI can lazily generate a schema.
+        if args_schema is not None:
+            self.args_schema = args_schema
+
+        object.__setattr__(self, "_tool_spec_ref", None)
+
+    def _run(self, **kwargs: Any) -> Any:
+        """Run the tool with the given arguments.
+
+        Args:
+            **kwargs: The arguments to pass to the function
+
+        Returns:
+            The result of calling the function
+        """
+        return self._function(**kwargs)
+
+
+CrewAIToolType = CrewBaseTool | BaseTool  # type: ignore[valid-type]
+
+
+class CrewAIAdapter(BaseAdapter[CrewAIToolType]):
+    """Adapter for CrewAI tools."""
+
+    def __init__(self, tool_spec: ToolSpec) -> None:
+        """Initialize the adapter.
+
+        Args:
+            tool_spec: The tool specification
+        """
+        super().__init__(tool_spec)
+        if not HAS_CREWAI:
+            raise ImportError(
+                "CrewAI package is required for CrewAI adapter. "
+                "Install it with `pip install agent_toolkit[crewai]`. "
+                "Note: CrewAI requires Python 3.10 or higher."
+            )
+
+    def to_tool(self) -> CrewAIToolType:
+        """Convert to CrewAI tool format.
+
+        Returns:
+            A CrewAI BaseTool instance
+        """
+        # Create and configure the tool
+        created_args_schema = self._create_args_schema()
+
+        tool = GleanCrewAITool(
+            name=self.tool_spec.name,
+            description=self.tool_spec.description,
+            function=self.tool_spec.function,
+            args_schema=created_args_schema,
+        )
+
+        # Store the tool_spec reference for testing
+        object.__setattr__(tool, "_tool_spec_ref", self.tool_spec)
+
+        return tool
+
+    def _create_args_schema(self) -> type[BaseModel] | None:
+        """Create a Pydantic model for the arguments schema.
+
+        Returns:
+            A Pydantic model class or None if no properties
+        """
+        json_schema = self.tool_spec.input_schema
+
+        props = json_schema.get("properties", {})
+        required = json_schema.get("required", [])
+
+        if not props:
+            return None
+
+        field_defs: dict[str, tuple[type, Any]] = {}
+        for name, schema in props.items():
+            field_type = self._get_field_type(schema)
+            is_required = name in required
+            description = schema.get("description", "")
+            if is_required:
+                field_defs[name] = (field_type, PydanticField(..., description=description))
+            else:
+                field_defs[name] = (field_type, PydanticField(None, description=description))
+
+        model_name = f"{self.tool_spec.name}ArgsSchema"
+        model = pydantic_create_model(model_name, **field_defs)  # type: ignore
+
+        return cast(type[BaseModel], model)
+
+    def _get_field_type(self, schema: dict[str, Any]) -> type:
+        """Determine the Python type from JSON schema property.
+
+        Args:
+            schema: JSON schema property definition
+
+        Returns:
+            Appropriate Python type
+        """
+        if "enum" in schema:
+            return str
+
+        schema_type = schema.get("type", "string")
+
+        if schema_type == "string":
+            return str
+        elif schema_type == "integer":
+            return int
+        elif schema_type == "number":
+            return float
+        elif schema_type == "boolean":
+            return bool
+        elif schema_type == "array":
+            return list
+        elif schema_type == "object":
+            return dict
+        else:
+            return str

glean/agent_toolkit/adapters/langchain.py

@@ -0,0 +1,159 @@
+"""LangChain adapter for converting tool specifications."""
+
+from datetime import date, datetime
+from typing import TYPE_CHECKING, Any, TypeAlias, Union, cast
+
+from pydantic import BaseModel
+
+from glean.agent_toolkit.adapters.base import BaseAdapter
+from glean.agent_toolkit.spec import ToolSpec
+
+if TYPE_CHECKING:
+    from langchain.tools import Tool as LangchainTool  # pragma: no cover
+else:
+    LangchainTool = Any  # type: ignore  # noqa: N816
+
+from pydantic import Field as PydanticField  # type: ignore
+from pydantic import create_model as pydantic_create_model
+
+ToolClass: Any = object
+Field: Any = object
+create_model = pydantic_create_model
+
+
+class _FallbackLangchainTool:
+    """Fallback for langchain.tools.Tool."""
+
+    name: str
+    description: str
+    func: Any
+    args_schema: Any
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # noqa: D107
+        pass
+
+
+def _fallback_pydantic_field(*args: Any, **kwargs: Any) -> Any:  # noqa: N802
+    """Fallback for pydantic.Field."""
+    return None
+
+
+def _fallback_pydantic_create_model(*args: Any, **kwargs: Any) -> Any:
+    """Fallback for pydantic.create_model."""
+    return None
+
+
+try:
+    from langchain.tools import Tool as _ActualLangchainToolImport  # type: ignore
+    from pydantic import Field as _ActualPydanticFieldImport  # type: ignore
+    from pydantic import create_model as _actual_pydantic_create_model_import
+
+    ToolClass = _ActualLangchainToolImport
+    Field = _ActualPydanticFieldImport
+    create_model = _actual_pydantic_create_model_import
+    HAS_LANGCHAIN = True
+except ImportError:  # pragma: no cover
+    ToolClass = _FallbackLangchainTool  # type: ignore[assignment]
+    Field = _fallback_pydantic_field
+    create_model = _fallback_pydantic_create_model
+    HAS_LANGCHAIN = False
+
+
+if TYPE_CHECKING:
+    LangChainToolType: TypeAlias = "LangchainTool"
+else:
+    from typing import Any as LangChainToolType  # type: ignore
+
+
+class LangChainAdapter(BaseAdapter[LangChainToolType]):
+    """Adapter for LangChain tools."""
+
+    def __init__(self, tool_spec: ToolSpec) -> None:
+        """Initialize the adapter.
+
+        Args:
+            tool_spec: The tool specification
+        """
+        super().__init__(tool_spec)
+        if not HAS_LANGCHAIN:
+            raise ImportError(
+                "LangChain package is required for LangChain adapter. "
+                "Install it with `pip install agent_toolkit[langchain]`."
+            )
+
+    def to_tool(self) -> Any:
+        """Convert to LangChain tool format.
+
+        Returns:
+            LangChain Tool instance
+        """
+        return ToolClass(
+            name=self.tool_spec.name,
+            description=self.tool_spec.description,
+            func=self.tool_spec.function,
+            args_schema=self._create_args_schema(),
+        )
+
+    def _create_args_schema(self) -> type[BaseModel] | None:
+        """Create a Pydantic model for the arguments schema.
+
+        Returns:
+            A Pydantic model class or None if no properties
+        """
+        json_schema = self.tool_spec.input_schema
+
+        props = json_schema.get("properties", {})
+        required = json_schema.get("required", [])
+
+        if not props:
+            return None
+
+        field_defs: dict[str, tuple[type, Any]] = {}
+
+        for name, schema in props.items():
+            field_type = self._get_field_type(schema)
+            is_required = name in required
+
+            description = schema.get("description", "")
+
+            if is_required:
+                field_defs[name] = (field_type, Field(..., description=description))
+            else:
+                field_defs[name] = (field_type, Field(None, description=description))
+
+        model = create_model(f"{self.tool_spec.name}Schema", **field_defs)  # type: ignore
+        return cast(type[BaseModel], model)
+
+    def _get_field_type(self, schema: dict[str, Any]) -> type:
+        """Determine the Python type from JSON schema property.
+
+        Args:
+            schema: JSON schema property definition
+
+        Returns:
+            Appropriate Python type
+        """
+        if "enum" in schema:
+            return str
+
+        schema_type = schema.get("type", "string")
+        schema_format = schema.get("format", "")
+
+        if schema_type == "string":
+            if schema_format == "date-time":
+                return datetime
+            elif schema_format == "date":
+                return date
+            return str
+        elif schema_type == "integer":
+            return int
+        elif schema_type == "number":
+            return float
+        elif schema_type == "boolean":
+            return bool
+        elif schema_type == "array":
+            return list
+        elif schema_type == "object":
+            return dict
+        else:
+            return str

glean/agent_toolkit/adapters/openai.py

@@ -0,0 +1,150 @@
+"""OpenAI adapter for converting tool specifications."""
+
+import json
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, TypeAlias, TypedDict, Union
+
+from glean.agent_toolkit.adapters.base import BaseAdapter
+from glean.agent_toolkit.spec import ToolSpec
+
+if TYPE_CHECKING:
+    from agents.tool import FunctionTool as _RealOpenAIFunctionTool
+else:
+    _RealOpenAIFunctionTool = Any  # type: ignore
+
+HAS_OPENAI: bool
+
+
+class _FallbackOpenAIFunctionTool:
+    """Fallback for agents.tool.FunctionTool."""
+
+    name: str
+    description: str
+    params_json_schema: Any
+    on_invoke_tool: Any
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # noqa: D107
+        pass
+
+
+try:
+    import openai  # noqa: F401 # type: ignore
+    from agents.tool import FunctionTool as _RuntimeFunctionTool  # type: ignore
+
+    _RuntimeOpenAIFunctionTool = _RuntimeFunctionTool  # type: ignore
+    HAS_OPENAI = True
+except ImportError:  # pragma: no cover
+    _RuntimeOpenAIFunctionTool = _FallbackOpenAIFunctionTool  # type: ignore
+    HAS_OPENAI = False
+
+
+OpenAIFunctionTool: TypeAlias = _RealOpenAIFunctionTool | _FallbackOpenAIFunctionTool
+
+
+OpenAIToolType = dict[str, Any] | OpenAIFunctionTool
+
+
+class OpenAIFunctionDef(TypedDict):
+    """Type definition for OpenAI function definition."""
+
+    name: str
+    description: str
+    parameters: dict[str, Any]
+
+
+class OpenAIToolDef(TypedDict):
+    """Type definition for OpenAI tool definition."""
+
+    type: str
+    function: OpenAIFunctionDef
+
+
+class OpenAIAdapter(BaseAdapter[OpenAIToolType]):
+    """Adapter for OpenAI tools."""
+
+    def __init__(self, tool_spec: ToolSpec) -> None:
+        """Initialize the adapter.
+
+        Args:
+            tool_spec: The tool specification
+        """
+        super().__init__(tool_spec)
+        if not HAS_OPENAI:
+            raise ImportError(
+                "OpenAI package is required for OpenAI adapter. "
+                "Install it with `pip install agent_toolkit[openai]`."
+            )
+
+    def to_tool(self) -> Any:
+        """Convert to OpenAI tool format.
+
+        This method tries to use the OpenAI Agents SDK if available,
+        falling back to the standard OpenAI function calling format if not.
+
+        Returns:
+            OpenAI tool specification or Agents SDK FunctionTool
+        """
+        if HAS_OPENAI and _RuntimeOpenAIFunctionTool is not _FallbackOpenAIFunctionTool:
+            return self.to_agents_tool()
+        else:
+            return self.to_standard_tool()
+
+    def to_standard_tool(self) -> OpenAIToolDef:
+        """Convert to standard OpenAI function tool format.
+
+        Returns:
+            OpenAI function calling specification
+        """
+        params_schema = (
+            self.tool_spec.input_schema
+            if self.tool_spec.input_schema
+            else {"type": "object", "properties": {}}
+        )
+
+        return {
+            "type": "function",
+            "function": {
+                "name": self.tool_spec.name,
+                "description": self.tool_spec.description,
+                "parameters": params_schema,
+            },
+        }
+
+    def to_agents_tool(self) -> OpenAIFunctionTool:
+        """Convert to OpenAI Agents SDK FunctionTool.
+
+        Returns:
+            An OpenAI Agents SDK FunctionTool
+        """
+        original_func = self.tool_spec.function
+
+        async def on_invoke_tool(ctx: Any, input_str: str) -> Any:
+            """Function that invokes the tool with parameters."""
+            try:
+                params = json.loads(input_str) if input_str else {}
+                result = original_func(**params)
+                return result
+            except Exception as e:
+                return f"Error executing tool: {str(e)}"
+
+        params_json_schema_dict = (
+            self.tool_spec.input_schema
+            if self.tool_spec.input_schema
+            else {"type": "object", "properties": {}}
+        )
+
+        return _RuntimeOpenAIFunctionTool(
+            name=self.tool_spec.name,
+            description=self.tool_spec.description,
+            params_json_schema=params_json_schema_dict,
+            on_invoke_tool=on_invoke_tool,
+            strict_json_schema=True,
+        )
+
+    def to_callable(self) -> Callable:
+        """Get the callable for OpenAI function calling.
+
+        Returns:
+            The callable function
+        """
+        return self.tool_spec.function