glaip-sdk 0.6.5b9__py3-none-any.whl → 0.6.6__py3-none-any.whl

glaip_sdk/runner/mcp_adapter/langchain_mcp_adapter.py

@@ -1,158 +0,0 @@
-"""LangChain MCP adapter for local agent runtime.
-
-This module handles adaptation of glaip-sdk MCP references to aip-agents
-MCP configuration format for local execution.
-
-Authors:
-    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
-"""
-
-from typing import Any
-
-from gllm_core.utils import LoggerManager
-
-from glaip_sdk.runner.mcp_adapter.base_mcp_adapter import BaseMCPAdapter
-from glaip_sdk.runner.mcp_adapter.mcp_config_builder import MCPConfigBuilder
-
-logger = LoggerManager().get_logger(__name__)
-
-
-class LangChainMCPAdapter(BaseMCPAdapter):
-    """Adapts glaip-sdk MCPs to aip-agents mcp_config dict format.
-
-    Handles:
-    - MCP class with http transport → convert to mcp_config
-    - MCP class with sse transport → convert to mcp_config
-    - MCP class with stdio transport → convert to mcp_config
-
-    Rejects:
-    - MCP.from_native() → platform-specific
-    - String MCP references → platform-specific
-    """
-
-    def adapt_mcps(self, mcp_refs: list[Any]) -> dict[str, Any]:
-        """Adapt MCP references to aip-agents mcp_config format.
-
-        Args:
-            mcp_refs: List of MCP references from Agent definition.
-
-        Returns:
-            Dictionary mapping server names to configuration dicts.
-            Format: {server_name: {transport: ..., url: ..., ...}}
-
-        Raises:
-            ValueError: If MCP is not supported in local mode.
-        """
-        mcp_configs = {}
-
-        for mcp_ref in mcp_refs:
-            server_name, config = self._adapt_single_mcp(mcp_ref)
-            mcp_configs[server_name] = config
-
-        logger.debug("Adapted %d MCPs to aip-agents format", len(mcp_configs))
-        return mcp_configs
-
-    def _adapt_single_mcp(self, mcp_ref: Any) -> tuple[str, dict[str, Any]]:
-        """Adapt a single MCP reference.
-
-        Args:
-            mcp_ref: Single MCP reference to adapt.
-
-        Returns:
-            Tuple of (server_name, config_dict).
-
-        Raises:
-            ValueError: If MCP is not supported.
-        """
-        # 1. String references (not supported)
-        if isinstance(mcp_ref, str):
-            raise ValueError(self._get_platform_mcp_error(mcp_ref))
-
-        # 2. MCP instance - check if it's local or platform
-        if self._is_local_mcp(mcp_ref):
-            config = self._convert_mcp_config(mcp_ref)
-            return mcp_ref.name, config
-
-        # 3. Platform MCP (from_native, from_id)
-        if self._is_platform_mcp(mcp_ref):
-            raise ValueError(self._get_platform_mcp_error(mcp_ref))
-
-        # 4. Unknown type
-        raise ValueError(
-            f"Unsupported MCP type for local mode: {type(mcp_ref)}. "
-            "Local mode only supports MCP class instances with http/sse/stdio transport."
-        )
-
-    def _is_local_mcp(self, ref: Any) -> bool:
-        """Check if ref is a local MCP (has transport config)."""
-        return (
-            hasattr(ref, "transport")
-            and hasattr(ref, "name")
-            and getattr(ref, "transport", None) in ("http", "sse", "stdio")
-            and not self._is_lookup_only(ref)
-        )
-
-    def _is_lookup_only(self, ref: Any) -> bool:
-        """Check if MCP is lookup-only (platform reference)."""
-        return hasattr(ref, "_lookup_only") and getattr(ref, "_lookup_only", False)
-
-    def _convert_mcp_config(self, mcp: Any) -> dict[str, Any]:
-        """Convert glaip-sdk MCP to aip-agents mcp_config format.
-
-        Args:
-            mcp: glaip-sdk MCP instance.
-
-        Returns:
-            aip-agents compatible MCP config dict.
-        """
-        # Start with user-provided config
-        config = mcp.config.copy() if mcp.config else {}
-
-        # Ensure transport is set
-        config["transport"] = mcp.transport
-
-        # Map server_url to url if needed (aip-agents uses 'url')
-        if "server_url" in config and "url" not in config:
-            config["url"] = config.pop("server_url")
-
-        # Convert authentication to headers using MCPConfigBuilder
-        if hasattr(mcp, "authentication") and mcp.authentication:
-            headers = MCPConfigBuilder.build_headers_from_auth(mcp.authentication)
-            if headers:
-                config["headers"] = headers
-            else:
-                logger.warning("Failed to build headers from authentication for MCP '%s'", mcp.name)
-
-        logger.debug("Converted MCP '%s' with transport '%s'", mcp.name, mcp.transport)
-        return config
-
-    def _is_platform_mcp(self, ref: Any) -> bool:
-        """Check if ref is platform-specific (not supported locally)."""
-        # MCP.from_native() or MCP.from_id() instances
-        if self._is_lookup_only(ref):
-            return True
-
-        # MCP with ID but no local transport
-        if hasattr(ref, "id") and getattr(ref, "id") and not self._is_local_mcp(ref):
-            return True
-
-        return False
-
-    def _get_platform_mcp_error(self, ref: Any) -> str:
-        """Get error message for platform MCPs."""
-        if isinstance(ref, str):
-            mcp_name = ref
-        else:
-            mcp_name = getattr(ref, "name", "<unknown>")
-
-        return (
-            f"MCP '{mcp_name}' is not supported in local mode.\n\n"
-            "Local mode only supports MCPs with local transport configurations:\n"
-            "  - MCP(name='...', transport='http', config={{'url': '...'}})\n"
-            "  - MCP(name='...', transport='sse', config={{'url': '...'}})\n"
-            "  - MCP(name='...', transport='stdio', config={{'command': '...'}})\n\n"
-            "Alternatives:\n"
-            "  1. Configure MCP with a local server URL\n"
-            "  2. Deploy the agent to use platform MCPs: agent.deploy()\n"
-            "  3. Remove MCP for local testing"
-        )

glaip_sdk/runner/mcp_adapter/mcp_config_builder.py

@@ -1,95 +0,0 @@
-"""MCP configuration builder helper.
-
-This module provides utilities for building MCP configurations,
-particularly for handling authentication conversion to headers.
-
-Authors:
-    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
-"""
-
-from typing import Any
-
-from gllm_core.utils import LoggerManager
-
-logger = LoggerManager().get_logger(__name__)
-
-
-class MCPConfigBuilder:
-    """Helper class for building MCP configurations.
-
-    Handles authentication-to-headers conversion and configuration validation.
-    Simplified version focused on local MCP support needs.
-    """
-
-    @staticmethod
-    def build_headers_from_auth(authentication: dict[str, Any]) -> dict[str, str] | None:
-        """Build HTTP headers from authentication configuration.
-
-        Args:
-            authentication: Authentication configuration dict with 'type' and auth-specific fields.
-
-        Returns:
-            dict[str, str] | None: HTTP headers or None if invalid/no-auth.
-        """
-        if not authentication or "type" not in authentication:
-            return None
-
-        auth_type = str(authentication["type"]).lower()
-
-        # Dispatch to type-specific handlers
-        handlers = {
-            "no-auth": MCPConfigBuilder._handle_no_auth,
-            "custom-header": MCPConfigBuilder._handle_custom_header,
-            "bearer-token": MCPConfigBuilder._handle_bearer_token,
-            "api-key": MCPConfigBuilder._handle_api_key,
-        }
-
-        handler = handlers.get(auth_type)
-        if handler:
-            return handler(authentication)
-
-        logger.warning("Unsupported authentication type: %s", auth_type)
-        return None
-
-    @staticmethod
-    def _handle_no_auth(authentication: dict[str, Any]) -> None:  # noqa: ARG004
-        """Handle no-auth type."""
-        return None
-
-    @staticmethod
-    def _handle_custom_header(authentication: dict[str, Any]) -> dict[str, str] | None:
-        """Handle custom-header auth type."""
-        headers = authentication.get("headers")
-        if isinstance(headers, dict) and all(isinstance(k, str) and isinstance(v, str) for k, v in headers.items()):
-            return headers
-        logger.warning("custom-header auth requires 'headers' dict with string keys/values")
-        return None
-
-    @staticmethod
-    def _handle_bearer_token(authentication: dict[str, Any]) -> dict[str, str] | None:
-        """Handle bearer-token auth type."""
-        # Check if headers provided directly
-        headers = authentication.get("headers")
-        if isinstance(headers, dict):
-            return headers
-        # Otherwise build from token
-        token = authentication.get("token")
-        if token:
-            return {"Authorization": f"Bearer {token}"}
-        logger.warning("bearer-token auth requires 'token' field or 'headers' dict")
-        return None
-
-    @staticmethod
-    def _handle_api_key(authentication: dict[str, Any]) -> dict[str, str] | None:
-        """Handle api-key auth type."""
-        # Check if headers provided directly
-        headers = authentication.get("headers")
-        if isinstance(headers, dict):
-            return headers
-        # Otherwise build from key/value
-        key = authentication.get("key")
-        value = authentication.get("value")
-        if key and value:
-            return {str(key): str(value)}
-        logger.warning("api-key auth requires 'key' and 'value' fields or 'headers' dict")
-        return None

glaip_sdk/runner/tool_adapter/__init__.py

@@ -1,18 +0,0 @@
-"""Tool adapter for local agent runtime.
-
-This package provides adapters to convert glaip-sdk tool references
-to backend-specific formats for local execution.
-
-Authors:
-    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
-"""
-
-from glaip_sdk.runner.tool_adapter.base_tool_adapter import BaseToolAdapter
-from glaip_sdk.runner.tool_adapter.langchain_tool_adapter import (
-    LangChainToolAdapter,
-)
-
-__all__ = [
-    "BaseToolAdapter",
-    "LangChainToolAdapter",
-]

glaip_sdk/runner/tool_adapter/base_tool_adapter.py

@@ -1,44 +0,0 @@
-"""Base tool adapter for local agent runtime.
-
-This module defines the abstract base class for tool adapters.
-Different backends (LangGraph, Google ADK) implement their own adapters.
-
-Authors:
-    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import Any
-
-
-class BaseToolAdapter(ABC):
-    """Abstract base class for tool adapters.
-
-    One Interface, Multiple Implementations:
-    - LangChainToolAdapter: Adapts to LangChain BaseTool (for aip-agents)
-    - GoogleADKToolAdapter: Adapts to Google ADK format (future)
-
-    Each backend implements this interface to adapt glaip-sdk tools
-    to their specific tool format.
-    """
-
-    @abstractmethod
-    def adapt_tools(self, tool_refs: list[Any]) -> list[Any]:
-        """Adapt glaip-sdk tool references to backend-specific format.
-
-        Args:
-            tool_refs: List of tool references from Agent definition.
-                Can be: LangChain classes/instances, Tool.from_langchain(),
-                Tool.from_native(), string names, etc.
-
-        Returns:
-            List of tools in backend-specific format.
-            For LangChain: list of BaseTool instances.
-            For Google ADK: list of Google ADK tool objects.
-
-        Raises:
-            ValueError: If tool is not supported by this backend.
-        """
-        ...

glaip_sdk/runner/tool_adapter/langchain_tool_adapter.py

@@ -1,177 +0,0 @@
-"""LangChain tool adapter for local agent runtime.
-
-This module handles adaptation of glaip-sdk tool references to LangChain
-BaseTool instances for local execution with aip-agents (LangGraph backend).
-
-Authors:
-    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
-"""
-
-from typing import Any
-
-from gllm_core.utils import LoggerManager
-
-from glaip_sdk.runner.tool_adapter.base_tool_adapter import BaseToolAdapter
-
-logger = LoggerManager().get_logger(__name__)
-
-
-class LangChainToolAdapter(BaseToolAdapter):
-    """Adapts glaip-sdk tools to LangChain BaseTool format for aip-agents.
-
-    Handles:
-    - LangChain BaseTool classes → instantiate
-    - LangChain BaseTool instances → return as-is
-    - Tool.from_langchain() → extract underlying tool
-    - @tool_plugin decorator → ignore (just metadata)
-
-    Rejects:
-    - Tool.from_native() → platform-specific
-    - String tool names → platform-specific
-    """
-
-    def adapt_tools(self, tool_refs: list[Any]) -> list[Any]:
-        """Adapt tool references to LangChain BaseTool instances.
-
-        Args:
-            tool_refs: List of tool references from Agent definition.
-
-        Returns:
-            List of LangChain BaseTool instances.
-
-        Raises:
-            ValueError: If tool is not supported in local mode.
-        """
-        langchain_tools = []
-
-        for tool_ref in tool_refs:
-            langchain_tool = self._adapt_single_tool(tool_ref)
-            langchain_tools.append(langchain_tool)
-
-        logger.debug("Adapted %d tools to LangChain format", len(langchain_tools))
-        return langchain_tools
-
-    def _adapt_single_tool(self, tool_ref: Any) -> Any:
-        """Adapt a single tool reference.
-
-        Args:
-            tool_ref: Single tool reference to adapt.
-
-        Returns:
-            LangChain BaseTool instance.
-
-        Raises:
-            ValueError: If tool is not supported.
-        """
-        # 1. Tool.from_langchain() wrapper
-        if self._is_tool_wrapper(tool_ref):
-            return self._extract_from_wrapper(tool_ref)
-
-        # 2. Direct LangChain BaseTool
-        if self._is_langchain_tool(tool_ref):
-            return self._instantiate_langchain_tool(tool_ref)
-
-        # 3. Platform tools (not supported)
-        if self._is_platform_tool(tool_ref):
-            raise ValueError(self._get_platform_tool_error(tool_ref))
-
-        # 4. Unknown type
-        raise ValueError(
-            f"Unsupported tool type for local mode: {type(tool_ref)}. "
-            "Local mode only supports LangChain BaseTool classes/instances."
-        )
-
-    def _is_tool_wrapper(self, ref: Any) -> bool:
-        """Check if ref is a Tool.from_langchain() wrapper.
-
-        Args:
-            ref: Object to check.
-
-        Returns:
-            True if ref is a Tool.from_langchain() wrapper.
-        """
-        return hasattr(ref, "langchain_tool") and hasattr(ref, "id") and hasattr(ref, "name")
-
-    def _extract_from_wrapper(self, wrapper: Any) -> Any:
-        """Extract underlying LangChain tool from Tool.from_langchain().
-
-        Args:
-            wrapper: Tool.from_langchain() wrapper object.
-
-        Returns:
-            LangChain BaseTool instance.
-        """
-        langchain_tool = wrapper.langchain_tool
-
-        # If it's a class, instantiate it
-        if isinstance(langchain_tool, type):
-            langchain_tool = langchain_tool()
-
-        logger.debug(
-            "Extracted LangChain tool from wrapper: %s",
-            getattr(langchain_tool, "name", "<unknown>"),
-        )
-        return langchain_tool
-
-    def _is_langchain_tool(self, ref: Any) -> bool:
-        """Check if ref is a LangChain BaseTool class or instance.
-
-        Args:
-            ref: Object to check.
-
-        Returns:
-            True if ref is a LangChain BaseTool.
-        """
-        from glaip_sdk.utils.tool_detection import is_langchain_tool  # noqa: PLC0415
-
-        return is_langchain_tool(ref)
-
-    def _instantiate_langchain_tool(self, ref: Any) -> Any:
-        """Instantiate LangChain tool if class, return as-is if instance.
-
-        Args:
-            ref: LangChain BaseTool class or instance.
-
-        Returns:
-            LangChain BaseTool instance.
-        """
-        if isinstance(ref, type):
-            # It's a class, instantiate it
-            # Note: @tool_plugin decorator doesn't affect instantiation
-            return ref()
-        return ref
-
-    def _is_platform_tool(self, ref: Any) -> bool:
-        """Check if ref is platform-specific (not supported locally).
-
-        Args:
-            ref: Object to check.
-
-        Returns:
-            True if ref is a platform-specific tool.
-        """
-        # String tool names
-        if isinstance(ref, str):
-            return True
-
-        # Tool.from_native() instances
-        if hasattr(ref, "id") and hasattr(ref, "name") and not hasattr(ref, "langchain_tool"):
-            return True
-
-        return False
-
-    def _get_platform_tool_error(self, ref: Any) -> str:
-        """Get error message for platform tools.
-
-        Args:
-            ref: Platform tool reference.
-
-        Returns:
-            Error message string.
-        """
-        from glaip_sdk.runner.deps import (  # noqa: PLC0415
-            get_local_mode_not_supported_for_tool_message,
-        )
-
-        tool_name = ref if isinstance(ref, str) else getattr(ref, "name", "<unknown>")
-        return get_local_mode_not_supported_for_tool_message(tool_name)

glaip_sdk/utils/a2a/__init__.py

@@ -1,34 +0,0 @@
-"""A2A (Agent-to-Agent) event processing utilities.
-
-This module provides utilities for processing A2A stream events emitted by
-agent execution backends. Used by the runner module and CLI rendering.
-
-Authors:
-    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
-"""
-
-from glaip_sdk.utils.a2a.event_processor import (
-    EVENT_TYPE_ERROR,
-    EVENT_TYPE_FINAL_RESPONSE,
-    EVENT_TYPE_STATUS_UPDATE,
-    EVENT_TYPE_TOOL_CALL,
-    EVENT_TYPE_TOOL_RESULT,
-    A2AEventStreamProcessor,
-    extract_final_response,
-    get_event_type,
-    is_error_event,
-    is_tool_event,
-)
-
-__all__ = [
-    "A2AEventStreamProcessor",
-    "EVENT_TYPE_ERROR",
-    "EVENT_TYPE_FINAL_RESPONSE",
-    "EVENT_TYPE_STATUS_UPDATE",
-    "EVENT_TYPE_TOOL_CALL",
-    "EVENT_TYPE_TOOL_RESULT",
-    "extract_final_response",
-    "get_event_type",
-    "is_error_event",
-    "is_tool_event",
-]