voxagent 0.1.0__py3-none-any.whl

voxagent/code/__init__.py

@@ -0,0 +1,9 @@
+"""Code execution sandbox for token optimization.
+
+This subpackage provides:
+- Sandboxed code execution (subprocess, Pyodide)
+- Tool file generation from MCP servers
+- Skills persistence and discovery
+- PII tokenization for privacy
+"""
+

voxagent/mcp/__init__.py

@@ -0,0 +1,16 @@
+"""Model Context Protocol (MCP) integration.
+
+This subpackage provides:
+- MCPToolDefinition: ToolDefinition subclass for MCP tools
+- MCPServerManager: Manages MCP server lifecycle and tool extraction
+- sanitize_tool_name: Utility to sanitize MCP tool names
+"""
+
+from voxagent.mcp.manager import MCPServerManager
+from voxagent.mcp.tool import MCPToolDefinition, sanitize_tool_name
+
+__all__ = [
+    "MCPServerManager",
+    "MCPToolDefinition",
+    "sanitize_tool_name",
+]

voxagent/mcp/manager.py

@@ -0,0 +1,188 @@
+"""MCP Server Manager for voxagent.
+
+This module provides MCPServerManager, which handles:
+- Connecting to MCP servers
+- Extracting tools from MCP servers
+- Converting MCP tools to ToolDefinition format
+- Managing server lifecycle (connect/disconnect)
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from voxagent.mcp.tool import MCPToolDefinition, sanitize_tool_name
+from voxagent.tools.definition import ToolDefinition
+
+logger = logging.getLogger(__name__)
+
+
+class MCPServerManager:
+    """Manages MCP server connections and tool extraction.
+
+    This class handles the lifecycle of MCP servers and provides methods
+    to extract and convert their tools to voxagent's ToolDefinition format.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the MCPServerManager."""
+        self._servers: list[Any] = []
+        self._connected_servers: list[Any] = []
+        self._tools: list[ToolDefinition] = []
+
+    async def add_servers(self, servers: list[Any]) -> None:
+        """Add MCP servers to manage.
+
+        Args:
+            servers: List of MCP server instances (PydanticAI MCP classes).
+        """
+        self._servers.extend(servers)
+
+    async def connect_all(self) -> list[ToolDefinition]:
+        """Connect to all MCP servers and extract their tools.
+
+        Returns:
+            List of ToolDefinition objects from all connected servers.
+        """
+        self._tools = []
+        self._connected_servers = []
+
+        for server in self._servers:
+            try:
+                # Enter the async context manager
+                await server.__aenter__()
+                self._connected_servers.append(server)
+
+                # Extract tools from this server
+                tools = await self._extract_tools(server)
+                self._tools.extend(tools)
+
+                server_name = getattr(server, "name", None) or getattr(
+                    server, "tool_prefix", "unknown"
+                )
+                logger.info(
+                    f"Connected to MCP server '{server_name}' with {len(tools)} tools"
+                )
+
+            except Exception as e:
+                server_name = getattr(server, "name", None) or getattr(
+                    server, "tool_prefix", "unknown"
+                )
+                logger.warning(f"Failed to connect to MCP server '{server_name}': {e}")
+                # Continue with other servers
+
+        return self._tools
+
+    async def disconnect_all(self) -> None:
+        """Disconnect from all connected MCP servers.
+
+        Note: PydanticAI MCP servers use anyio cancel scopes, which must be
+        entered and exited from the same task. If called from a different task,
+        the disconnect will be skipped to avoid RuntimeError.
+        """
+        for server in self._connected_servers:
+            try:
+                await server.__aexit__(None, None, None)
+            except RuntimeError as e:
+                # anyio cancel scope errors when called from different task
+                if "cancel scope" in str(e).lower() or "different task" in str(e).lower():
+                    server_name = getattr(server, "name", None) or getattr(
+                        server, "tool_prefix", "unknown"
+                    )
+                    logger.debug(
+                        f"MCP server '{server_name}' disconnect skipped (task mismatch): {e}"
+                    )
+                else:
+                    raise
+            except Exception as e:
+                server_name = getattr(server, "name", None) or getattr(
+                    server, "tool_prefix", "unknown"
+                )
+                logger.warning(f"Error disconnecting from MCP server '{server_name}': {e}")
+
+        self._connected_servers = []
+        self._tools = []
+
+    async def _extract_tools(self, server: Any) -> list[ToolDefinition]:
+        """Extract tools from an MCP server and convert to ToolDefinition.
+
+        Args:
+            server: The connected MCP server instance.
+
+        Returns:
+            List of ToolDefinition objects.
+        """
+        tools: list[ToolDefinition] = []
+
+        try:
+            # Get the server name/prefix for tool naming
+            server_name = getattr(server, "name", None) or getattr(
+                server, "tool_prefix", None
+            )
+
+            # List tools from the MCP server
+            mcp_tools = await server.list_tools()
+
+            for mcp_tool in mcp_tools:
+                try:
+                    tool_def = self._convert_mcp_tool(mcp_tool, server, server_name)
+                    tools.append(tool_def)
+                except Exception as e:
+                    tool_name = getattr(mcp_tool, "name", "unknown")
+                    logger.warning(f"Failed to convert MCP tool '{tool_name}': {e}")
+
+        except Exception as e:
+            logger.warning(f"Failed to list tools from MCP server: {e}")
+
+        return tools
+
+    def _convert_mcp_tool(
+        self, mcp_tool: Any, server: Any, server_name: str | None
+    ) -> MCPToolDefinition:
+        """Convert an MCP tool to MCPToolDefinition.
+
+        Args:
+            mcp_tool: The MCP tool object from list_tools().
+            server: The MCP server instance.
+            server_name: The server name/prefix.
+
+        Returns:
+            MCPToolDefinition instance.
+        """
+        # Get tool attributes
+        original_name = mcp_tool.name
+        description = mcp_tool.description or f"MCP tool: {original_name}"
+
+        # Build the full tool name with prefix
+        if server_name:
+            full_name = f"{server_name}_{sanitize_tool_name(original_name)}"
+        else:
+            full_name = sanitize_tool_name(original_name)
+
+        # Get input schema (parameters)
+        parameters: dict[str, Any] = {"type": "object", "properties": {}}
+        if hasattr(mcp_tool, "inputSchema") and mcp_tool.inputSchema:
+            parameters = mcp_tool.inputSchema
+        elif hasattr(mcp_tool, "input_schema") and mcp_tool.input_schema:
+            parameters = mcp_tool.input_schema
+
+        return MCPToolDefinition(
+            name=full_name,
+            description=description,
+            parameters=parameters,
+            mcp_server=server,
+            original_tool_name=original_name,
+            server_name=server_name or "unknown",
+        )
+
+    @property
+    def tools(self) -> list[ToolDefinition]:
+        """Get all extracted tools."""
+        return self._tools
+
+    @property
+    def connected_server_count(self) -> int:
+        """Get the number of connected servers."""
+        return len(self._connected_servers)
+

voxagent/mcp/tool.py

@@ -0,0 +1,152 @@
+"""MCP Tool Definition for voxagent.
+
+This module provides MCPToolDefinition, a ToolDefinition subclass that wraps
+MCP server tools and forwards execution calls to the MCP server.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING, Any
+
+from voxagent.tools.definition import ToolContext, ToolDefinition
+
+if TYPE_CHECKING:
+    pass
+
+
+class MCPToolDefinition(ToolDefinition):
+    """A ToolDefinition that wraps an MCP server tool.
+
+    This class forwards tool execution to the MCP server that provides the tool.
+    It stores a reference to the MCP server and the original tool name.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        description: str,
+        parameters: dict[str, Any],
+        mcp_server: Any,
+        original_tool_name: str,
+        server_name: str,
+    ) -> None:
+        """Initialize MCPToolDefinition.
+
+        Args:
+            name: The sanitized tool name (alphanumeric and underscores).
+            description: Tool description for the LLM.
+            parameters: JSON Schema for the tool's parameters.
+            mcp_server: The MCP server instance that provides this tool.
+            original_tool_name: The original tool name from the MCP server.
+            server_name: The name of the MCP server (for logging/debugging).
+        """
+        # Don't call parent __init__ with execute - we override run() instead
+        # Validate name manually
+        if not re.match(r"^[a-zA-Z_][a-zA-Z0-9_]*$", name):
+            raise ValueError(
+                f"Tool name '{name}' is invalid. "
+                "Must contain only alphanumeric characters and underscores, "
+                "and cannot start with a digit."
+            )
+
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        self.is_async = True  # MCP calls are always async
+
+        # MCP-specific attributes
+        self._mcp_server = mcp_server
+        self._original_tool_name = original_tool_name
+        self._server_name = server_name
+
+        # Set execute to None - we override run() instead
+        self.execute = self._execute_mcp_tool
+
+    async def _execute_mcp_tool(self, **params: Any) -> Any:
+        """Execute the MCP tool by calling the MCP server.
+
+        This is called by the parent's run() method, but we override run()
+        to handle MCP-specific execution.
+        """
+        # This shouldn't be called directly - run() handles execution
+        raise NotImplementedError("Use run() instead")
+
+    async def run(self, params: dict[str, Any], context: ToolContext) -> Any:
+        """Execute the tool by forwarding to the MCP server.
+
+        Args:
+            params: Dictionary of parameter values.
+            context: The ToolContext for this execution.
+
+        Returns:
+            The result from the MCP server tool execution.
+        """
+        try:
+            # Call the MCP server's direct_call_tool method
+            # This bypasses PydanticAI's context requirements
+            result = await self._mcp_server.direct_call_tool(
+                self._original_tool_name,
+                params,
+            )
+
+            # MCP returns a list of content items, extract text
+            if hasattr(result, "content") and result.content:
+                # Concatenate all text content
+                texts = []
+                for item in result.content:
+                    if hasattr(item, "text"):
+                        texts.append(item.text)
+                    elif isinstance(item, dict) and "text" in item:
+                        texts.append(item["text"])
+                    else:
+                        texts.append(str(item))
+                return "\n".join(texts) if texts else str(result)
+
+            return str(result)
+
+        except Exception as e:
+            # Return error as string - the executor will handle it
+            return f"MCP tool error ({self._server_name}/{self._original_tool_name}): {e}"
+
+    @property
+    def mcp_server(self) -> Any:
+        """Get the MCP server instance."""
+        return self._mcp_server
+
+    @property
+    def original_tool_name(self) -> str:
+        """Get the original MCP tool name."""
+        return self._original_tool_name
+
+    @property
+    def server_name(self) -> str:
+        """Get the MCP server name."""
+        return self._server_name
+
+
+def sanitize_tool_name(name: str) -> str:
+    """Sanitize a tool name to be valid for voxagent.
+
+    MCP tool names may contain dashes or other characters that are not
+    valid in Python identifiers. This function converts them to underscores.
+
+    Args:
+        name: The original tool name.
+
+    Returns:
+        A sanitized tool name with only alphanumeric characters and underscores.
+    """
+    # Replace dashes and other invalid characters with underscores
+    sanitized = re.sub(r"[^a-zA-Z0-9_]", "_", name)
+
+    # Ensure it doesn't start with a digit
+    if sanitized and sanitized[0].isdigit():
+        sanitized = "_" + sanitized
+
+    # Ensure it's not empty
+    if not sanitized:
+        sanitized = "unnamed_tool"
+
+    return sanitized
+

voxagent/providers/__init__.py

@@ -0,0 +1,110 @@
+"""LLM provider implementations.
+
+This subpackage contains unified interfaces for various LLM providers:
+- OpenAI (GPT-4, GPT-4o)
+- Anthropic (Claude)
+- Google (Gemini)
+- Groq (Llama, Mixtral)
+- Ollama (local models)
+- ChatGPT (ChatGPT Plus backend)
+- Augment (Auggie CLI)
+- Codex (OpenAI Codex CLI)
+- ClaudeCode (Claude Code CLI)
+"""
+
+from voxagent.providers.anthropic import AnthropicProvider
+from voxagent.providers.augment import AugmentProvider
+from voxagent.providers.auth import (
+    AuthProfile,
+    AuthProfileManager,
+    FailoverError,
+    FailoverReason,
+)
+from voxagent.providers.base import (
+    AbortSignal,
+    BaseProvider,
+    ErrorChunk,
+    MessageEndChunk,
+    StreamChunk,
+    TextDeltaChunk,
+    ToolUseChunk,
+)
+from voxagent.providers.chatgpt import ChatGPTProvider
+from voxagent.providers.claudecode import ClaudeCodeProvider
+from voxagent.providers.cli_base import CLINotFoundError, CLIProvider
+from voxagent.providers.codex import CodexProvider
+from voxagent.providers.failover import (
+    FailoverExhaustedError,
+    NoProfilesAvailableError,
+    run_with_failover,
+)
+from voxagent.providers.google import GoogleProvider
+from voxagent.providers.groq import GroqProvider
+from voxagent.providers.ollama import OllamaProvider
+from voxagent.providers.openai import OpenAIProvider
+from voxagent.providers.registry import (
+    InvalidModelStringError,
+    ProviderNotFoundError,
+    ProviderRegistry,
+    get_default_registry,
+)
+
+__all__ = [
+    "AbortSignal",
+    "AnthropicProvider",
+    "AugmentProvider",
+    "AuthProfile",
+    "AuthProfileManager",
+    "BaseProvider",
+    "ChatGPTProvider",
+    "CLINotFoundError",
+    "CLIProvider",
+    "ClaudeCodeProvider",
+    "CodexProvider",
+    "ErrorChunk",
+    "FailoverError",
+    "FailoverExhaustedError",
+    "FailoverReason",
+    "GoogleProvider",
+    "GroqProvider",
+    "InvalidModelStringError",
+    "MessageEndChunk",
+    "NoProfilesAvailableError",
+    "OllamaProvider",
+    "OpenAIProvider",
+    "ProviderNotFoundError",
+    "ProviderRegistry",
+    "StreamChunk",
+    "TextDeltaChunk",
+    "ToolUseChunk",
+    "get_default_registry",
+    "run_with_failover",
+]
+
+
+# =============================================================================
+# Register default providers
+# =============================================================================
+
+def _register_default_providers() -> None:
+    """Register all built-in providers with the default registry."""
+    registry = get_default_registry()
+
+    # Only register if not already registered (idempotent)
+    if not registry.list_providers():
+        # HTTP API providers
+        registry.register("openai", OpenAIProvider)
+        registry.register("anthropic", AnthropicProvider)
+        registry.register("google", GoogleProvider)
+        registry.register("groq", GroqProvider)
+        registry.register("ollama", OllamaProvider)
+        registry.register("chatgpt", ChatGPTProvider)
+        # CLI-wrapped providers
+        registry.register("augment", AugmentProvider)
+        registry.register("codex", CodexProvider)
+        registry.register("claudecode", ClaudeCodeProvider)
+
+
+# Auto-register providers on module import
+_register_default_providers()
+