codetether 1.2.2__py3-none-any.whl

a2a_server/agent_card.py

@@ -0,0 +1,408 @@
+"""
+Agent Card implementation for A2A protocol.
+
+Provides utilities for creating, managing, and serving agent cards
+for agent discovery and capability advertisement.
+"""
+
+import json
+from typing import List, Optional, Dict, Any
+from pathlib import Path
+
+from .models import (
+    AgentCard as AgentCardModel,
+    AgentProvider,
+    AgentCapabilities,
+    AgentSkill,
+    AuthenticationScheme,
+    AgentExtension,
+    AdditionalInterfaces,
+    LiveKitInterface
+)
+
+
+class AgentCard:
+    """Helper class for creating and managing A2A Agent Cards."""
+
+    def __init__(
+        self,
+        name: str,
+        description: str,
+        url: str,
+        provider: AgentProvider,
+        capabilities: Optional[AgentCapabilities] = None,
+        authentication: Optional[List[AuthenticationScheme]] = None,
+        skills: Optional[List[AgentSkill]] = None,
+        additional_interfaces: Optional[AdditionalInterfaces] = None,
+        version: str = "1.0"
+    ):
+        self.card = AgentCardModel(
+            name=name,
+            description=description,
+            url=url,
+            provider=provider,
+            capabilities=capabilities or AgentCapabilities(),
+            authentication=authentication or [],
+            skills=skills or [],
+            additional_interfaces=additional_interfaces,
+            version=version
+        )
+
+    def add_skill(
+        self,
+        skill_id: str,
+        name: str,
+        description: str,
+        input_modes: Optional[List[str]] = None,
+        output_modes: Optional[List[str]] = None,
+        examples: Optional[List[Dict[str, Any]]] = None
+    ) -> 'AgentCard':
+        """Add a skill to the agent card."""
+        skill = AgentSkill(
+            id=skill_id,
+            name=name,
+            description=description,
+            input_modes=input_modes or ["text"],
+            output_modes=output_modes or ["text"],
+            examples=examples
+        )
+        self.card.skills.append(skill)
+        return self
+
+    def add_authentication(
+        self,
+        scheme: str,
+        description: Optional[str] = None
+    ) -> 'AgentCard':
+        """Add an authentication scheme to the agent card."""
+        auth = AuthenticationScheme(
+            scheme=scheme,
+            description=description
+        )
+        self.card.authentication.append(auth)
+        return self
+
+    def enable_streaming(self) -> 'AgentCard':
+        """Enable streaming capability."""
+        if not self.card.capabilities:
+            self.card.capabilities = AgentCapabilities()
+        self.card.capabilities.streaming = True
+        return self
+
+    def enable_push_notifications(self) -> 'AgentCard':
+        """Enable push notifications capability."""
+        if not self.card.capabilities:
+            self.card.capabilities = AgentCapabilities()
+        self.card.capabilities.push_notifications = True
+        return self
+
+    def enable_state_history(self) -> 'AgentCard':
+        """Enable state transition history capability."""
+        if not self.card.capabilities:
+            self.card.capabilities = AgentCapabilities()
+        self.card.capabilities.state_transition_history = True
+        return self
+
+    def enable_media(self) -> 'AgentCard':
+        """Enable media capability."""
+        if not self.card.capabilities:
+            self.card.capabilities = AgentCapabilities()
+        self.card.capabilities.media = True
+        return self
+
+    def add_livekit_interface(
+        self,
+        token_endpoint: str,
+        join_url_template: Optional[str] = None,
+        server_managed: bool = True
+    ) -> 'AgentCard':
+        """Add LiveKit interface configuration.
+
+        Args:
+            token_endpoint: Endpoint for obtaining LiveKit access tokens
+            join_url_template: Template for generating join URLs
+            server_managed: Whether the server manages LiveKit resources
+        """
+        if not self.card.additional_interfaces:
+            self.card.additional_interfaces = AdditionalInterfaces()
+
+        self.card.additional_interfaces.livekit = LiveKitInterface(
+            token_endpoint=token_endpoint,
+            join_url_template=join_url_template,
+            server_managed=server_managed
+        )
+
+        # Also enable media capability
+        self.enable_media()
+
+        return self
+
+    def add_mcp_interface(
+        self,
+        endpoint: str,
+        protocol: str = "http",
+        description: Optional[str] = None
+    ) -> 'AgentCard':
+        """Add MCP (Model Context Protocol) interface for agent synchronization.
+
+        Args:
+            endpoint: HTTP endpoint for MCP JSON-RPC (e.g., http://localhost:9000/mcp/v1/rpc)
+            protocol: Protocol type (http, stdio, sse)
+            description: Optional description of available MCP tools
+        """
+        if not self.card.additional_interfaces:
+            self.card.additional_interfaces = AdditionalInterfaces()
+
+        # Add MCP interface as custom field
+        if not hasattr(self.card.additional_interfaces, 'mcp'):
+            # Store as extra field in additional_interfaces
+            mcp_info = {
+                "endpoint": endpoint,
+                "protocol": protocol,
+                "description": description or "MCP tools for agent synchronization and coordination"
+            }
+            # Store as an extra field (allowed by model_config)
+            if not hasattr(self.card.additional_interfaces, '__pydantic_extra__'):
+                self.card.additional_interfaces.__pydantic_extra__ = {}
+            self.card.additional_interfaces.__pydantic_extra__["mcp"] = mcp_info
+
+        return self
+
+    def add_extension(
+        self,
+        uri: str,
+        description: Optional[str] = None,
+        required: bool = False
+    ) -> 'AgentCard':
+        """Add a protocol extension to the agent card."""
+        if not self.card.capabilities:
+            self.card.capabilities = AgentCapabilities()
+        if not self.card.capabilities.extensions:
+            self.card.capabilities.extensions = []
+
+        extension = AgentExtension(
+            uri=uri,
+            description=description,
+            required=required
+        )
+        self.card.capabilities.extensions.append(extension)
+        return self
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the agent card to a dictionary."""
+        return self.card.model_dump(exclude_none=True)
+
+    def to_json(self, indent: Optional[int] = 2) -> str:
+        """Convert the agent card to JSON."""
+        return self.card.model_dump_json(exclude_none=True, indent=indent)
+
+    def save_to_file(self, file_path: str) -> None:
+        """Save the agent card to a JSON file."""
+        path = Path(file_path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(path, 'w', encoding='utf-8') as f:
+            f.write(self.to_json())
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'AgentCard':
+        """Create an AgentCard from a dictionary."""
+        card_model = AgentCardModel.model_validate(data)
+        instance = cls.__new__(cls)
+        instance.card = card_model
+        return instance
+
+    @classmethod
+    def from_json(cls, json_str: str) -> 'AgentCard':
+        """Create an AgentCard from a JSON string."""
+        data = json.loads(json_str)
+        return cls.from_dict(data)
+
+    @classmethod
+    def from_file(cls, file_path: str) -> 'AgentCard':
+        """Load an AgentCard from a JSON file."""
+        with open(file_path, 'r', encoding='utf-8') as f:
+            return cls.from_json(f.read())
+
+
+class AgentCardBuilder:
+    """Fluent builder for creating Agent Cards."""
+
+    def __init__(self):
+        self._name: Optional[str] = None
+        self._description: Optional[str] = None
+        self._url: Optional[str] = None
+        self._provider: Optional[AgentProvider] = None
+        self._capabilities: Optional[AgentCapabilities] = None
+        self._authentication: List[AuthenticationScheme] = []
+        self._skills: List[AgentSkill] = []
+        self._additional_interfaces: Optional[AdditionalInterfaces] = None
+        self._version: str = "1.0"
+
+    def name(self, name: str) -> 'AgentCardBuilder':
+        """Set the agent name."""
+        self._name = name
+        return self
+
+    def description(self, description: str) -> 'AgentCardBuilder':
+        """Set the agent description."""
+        self._description = description
+        return self
+
+    def url(self, url: str) -> 'AgentCardBuilder':
+        """Set the agent URL."""
+        self._url = url
+        return self
+
+    def provider(
+        self,
+        organization: str,
+        url: str
+    ) -> 'AgentCardBuilder':
+        """Set the agent provider information."""
+        self._provider = AgentProvider(
+            organization=organization,
+            url=url
+        )
+        return self
+
+    def with_streaming(self) -> 'AgentCardBuilder':
+        """Enable streaming capability."""
+        if not self._capabilities:
+            self._capabilities = AgentCapabilities()
+        self._capabilities.streaming = True
+        return self
+
+    def with_push_notifications(self) -> 'AgentCardBuilder':
+        """Enable push notifications capability."""
+        if not self._capabilities:
+            self._capabilities = AgentCapabilities()
+        self._capabilities.push_notifications = True
+        return self
+
+    def with_state_history(self) -> 'AgentCardBuilder':
+        """Enable state transition history capability."""
+        if not self._capabilities:
+            self._capabilities = AgentCapabilities()
+        self._capabilities.state_transition_history = True
+        return self
+
+    def with_media(self) -> 'AgentCardBuilder':
+        """Enable media capability."""
+        if not self._capabilities:
+            self._capabilities = AgentCapabilities()
+        self._capabilities.media = True
+        return self
+
+    def with_livekit_interface(
+        self,
+        token_endpoint: str,
+        join_url_template: Optional[str] = None,
+        server_managed: bool = True
+    ) -> 'AgentCardBuilder':
+        """Add LiveKit interface configuration."""
+        if not self._additional_interfaces:
+            self._additional_interfaces = AdditionalInterfaces()
+
+        self._additional_interfaces.livekit = LiveKitInterface(
+            token_endpoint=token_endpoint,
+            join_url_template=join_url_template,
+            server_managed=server_managed
+        )
+
+        # Also enable media capability
+        self.with_media()
+
+        return self
+
+    def with_extension(
+        self,
+        uri: str,
+        description: Optional[str] = None,
+        required: bool = False
+    ) -> 'AgentCardBuilder':
+        """Add a protocol extension."""
+        if not self._capabilities:
+            self._capabilities = AgentCapabilities()
+        if not self._capabilities.extensions:
+            self._capabilities.extensions = []
+
+        extension = AgentExtension(
+            uri=uri,
+            description=description,
+            required=required
+        )
+        self._capabilities.extensions.append(extension)
+        return self
+
+    def with_authentication(
+        self,
+        scheme: str,
+        description: Optional[str] = None
+    ) -> 'AgentCardBuilder':
+        """Add an authentication scheme."""
+        auth = AuthenticationScheme(
+            scheme=scheme,
+            description=description
+        )
+        self._authentication.append(auth)
+        return self
+
+    def with_skill(
+        self,
+        skill_id: str,
+        name: str,
+        description: str,
+        input_modes: Optional[List[str]] = None,
+        output_modes: Optional[List[str]] = None,
+        examples: Optional[List[Dict[str, Any]]] = None
+    ) -> 'AgentCardBuilder':
+        """Add a skill."""
+        skill = AgentSkill(
+            id=skill_id,
+            name=name,
+            description=description,
+            input_modes=input_modes or ["text"],
+            output_modes=output_modes or ["text"],
+            examples=examples
+        )
+        self._skills.append(skill)
+        return self
+
+    def version(self, version: str) -> 'AgentCardBuilder':
+        """Set the agent card version."""
+        self._version = version
+        return self
+
+    def build(self) -> AgentCard:
+        """Build the agent card."""
+        if not all([self._name, self._description, self._url, self._provider]):
+            raise ValueError("Name, description, URL, and provider are required")
+
+        return AgentCard(
+            name=self._name,
+            description=self._description,
+            url=self._url,
+            provider=self._provider,
+            capabilities=self._capabilities,
+            authentication=self._authentication,
+            skills=self._skills,
+            additional_interfaces=self._additional_interfaces,
+            version=self._version
+        )
+
+
+# Convenience function for creating agent cards
+def create_agent_card(
+    name: str,
+    description: str,
+    url: str,
+    organization: str,
+    organization_url: str
+) -> AgentCardBuilder:
+    """Create a new agent card builder with basic information."""
+    return (AgentCardBuilder()
+            .name(name)
+            .description(description)
+            .url(url)
+            .provider(organization, organization_url))

a2a_server/agents_server.py

@@ -0,0 +1,271 @@
+"""
+A2A Server using OpenAI Agents SDK
+This replaces the custom MCP implementation with the official OpenAI Agents SDK.
+"""
+import asyncio
+import logging
+from typing import Any, Dict, Optional
+from datetime import datetime
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+
+from agents import Agent, Runner, function_tool
+from agents.memory import SQLiteSession
+
+logger = logging.getLogger(__name__)
+
+
+class TaskRequest(BaseModel):
+    """Request to create a task."""
+    input: str
+    session_id: Optional[str] = None
+    agent_name: Optional[str] = "Assistant"
+
+
+class TaskResponse(BaseModel):
+    """Response from task execution."""
+    output: str
+    session_id: Optional[str] = None
+    timestamp: str
+
+
+# Define agent tools using the @function_tool decorator
+@function_tool
+def calculator(operation: str, a: float, b: float = 0.0) -> str:
+    """
+    Perform mathematical calculations.
+
+    Args:
+        operation: The operation to perform (add, subtract, multiply, divide, square, sqrt)
+        a: First number
+        b: Second number (optional for unary operations)
+
+    Returns:
+        The result of the calculation as a string
+    """
+    try:
+        if operation == "add":
+            result = a + b
+        elif operation == "subtract":
+            result = a - b
+        elif operation == "multiply":
+            result = a * b
+        elif operation == "divide":
+            if b == 0:
+                return "Error: Division by zero"
+            result = a / b
+        elif operation == "square":
+            result = a ** 2
+        elif operation == "sqrt":
+            if a < 0:
+                return "Error: Cannot take square root of negative number"
+            result = a ** 0.5
+        else:
+            return f"Error: Unknown operation '{operation}'"
+
+        return f"Result: {result}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+@function_tool
+def get_weather(city: str) -> str:
+    """
+    Get weather information for a city.
+
+    Args:
+        city: The name of the city
+
+    Returns:
+        Weather information as a string
+    """
+    # Mock weather data
+    return f"The weather in {city} is sunny with a temperature of 72°F (22°C)."
+
+
+@function_tool
+def echo(message: str) -> str:
+    """
+    Echo back a message.
+
+    Args:
+        message: The message to echo
+
+    Returns:
+        The same message
+    """
+    return message
+
+
+class AgentsServer:
+    """FastAPI server using OpenAI Agents SDK."""
+
+    def __init__(self, port: int = 9000):
+        self.app = FastAPI(title="A2A Agents Server", version="0.1.0")
+        self.port = port
+        self.sessions_db = "a2a_sessions.db"
+
+        # Create default agents
+        self.agents = {
+            "Assistant": Agent(
+                name="Assistant",
+                instructions="You are a helpful assistant with access to various tools.",
+                tools=[calculator, get_weather, echo]
+            ),
+            "Calculator": Agent(
+                name="Calculator Agent",
+                instructions="You specialize in mathematical calculations. Use the calculator tool for all math operations.",
+                tools=[calculator]
+            ),
+            "Weather": Agent(
+                name="Weather Agent",
+                instructions="You specialize in providing weather information. Use the weather tool to get current conditions.",
+                tools=[get_weather]
+            )
+        }
+
+        # Setup routes
+        self._setup_routes()
+
+    def _setup_routes(self):
+        """Setup FastAPI routes."""
+
+        @self.app.get("/")
+        async def root():
+            """Root endpoint with server info."""
+            return {
+                "name": "A2A Agents Server",
+                "version": "0.1.0",
+                "framework": "OpenAI Agents SDK",
+                "agents": list(self.agents.keys()),
+                "endpoints": {
+                    "chat": "/chat",
+                    "agents": "/agents",
+                    "health": "/health"
+                }
+            }
+
+        @self.app.get("/health")
+        async def health():
+            """Health check endpoint."""
+            return {"status": "healthy", "timestamp": datetime.now().isoformat()}
+
+        @self.app.get("/agents")
+        async def list_agents():
+            """List available agents."""
+            return {
+                "agents": [
+                    {
+                        "name": name,
+                        "instructions": agent.instructions,
+                        "tools": [tool.__name__ if hasattr(tool, '__name__') else str(tool) for tool in agent.tools]
+                    }
+                    for name, agent in self.agents.items()
+                ]
+            }
+
+        @self.app.post("/chat", response_model=TaskResponse)
+        async def chat(request: TaskRequest):
+            """
+            Run an agent with the given input.
+
+            Supports session memory if session_id is provided.
+            """
+            try:
+                # Get the agent
+                agent = self.agents.get(request.agent_name)
+                if not agent:
+                    raise HTTPException(
+                        status_code=404,
+                        detail=f"Agent '{request.agent_name}' not found"
+                    )
+
+                # Create session if session_id provided
+                session = None
+                if request.session_id:
+                    session = SQLiteSession(request.session_id, self.sessions_db)
+
+                # Run the agent
+                result = await Runner.run(
+                    agent,
+                    input=request.input,
+                    session=session
+                )
+
+                return TaskResponse(
+                    output=result.final_output,
+                    session_id=request.session_id,
+                    timestamp=datetime.now().isoformat()
+                )
+
+            except Exception as e:
+                logger.error(f"Error running agent: {e}", exc_info=True)
+                raise HTTPException(status_code=500, detail=str(e))
+
+        @self.app.get("/chat/stream")
+        async def chat_stream(input: str, agent_name: str = "Assistant", session_id: Optional[str] = None):
+            """
+            Stream agent responses using Server-Sent Events.
+            """
+            async def event_generator():
+                try:
+                    # Get the agent
+                    agent = self.agents.get(agent_name)
+                    if not agent:
+                        yield f"data: {{'error': 'Agent not found'}}\n\n"
+                        return
+
+                    # Create session if needed
+                    session = None
+                    if session_id:
+                        session = SQLiteSession(session_id, self.sessions_db)
+
+                    # Stream the response
+                    result = Runner.run_streamed(agent, input=input, session=session)
+
+                    async for event in result.stream_events():
+                        if event.type == "run_item_stream_event":
+                            yield f"data: {{'type': 'chunk', 'content': '{event.item}'}}\n\n"
+
+                    # Send final output
+                    yield f"data: {{'type': 'final', 'output': '{result.final_output}'}}\n\n"
+
+                except Exception as e:
+                    logger.error(f"Error in stream: {e}", exc_info=True)
+                    yield f"data: {{'error': '{str(e)}'}}\n\n"
+
+            return StreamingResponse(
+                event_generator(),
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache",
+                    "Connection": "keep-alive",
+                    "X-Accel-Buffering": "no"
+                }
+            )
+
+    async def start(self):
+        """Start the server."""
+        import uvicorn
+        config = uvicorn.Config(
+            self.app,
+            host="0.0.0.0",
+            port=self.port,
+            log_level="info"
+        )
+        server = uvicorn.Server(config)
+        await server.serve()
+
+
+async def main():
+    """Main entry point."""
+    server = AgentsServer(port=9000)
+    logger.info(f"Starting A2A Agents Server on port {server.port}")
+    await server.start()
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    asyncio.run(main())