mcp-generator 3.2.1__py3-none-any.whl

mcp_generator/__init__.py

@@ -0,0 +1,60 @@
+"""
+MCP Generator Package.
+
+A modular code generator for creating FastMCP 3.x servers from OpenAPI specifications.
+
+Main modules:
+- cli: Command-line interface and entry point
+- generator: Core orchestration and generation logic
+- introspection: API discovery and metadata extraction
+- renderers: Code generation and template rendering
+- models: Data structures for configuration and specs
+- utils: Helper functions for sanitization and formatting
+- templates: Template generators for middleware and auth
+- writers: File writing and directory management
+- test_generator: Generates authentication flow demonstration tests
+
+Usage:
+    python -m mcp_generator
+"""
+
+from importlib.metadata import version as _pkg_version
+
+from .cli import main
+from .generate_client import generate_client_package
+from .generator import generate_all, generate_main_composition_server, generate_modular_servers
+from .introspection import (
+    enrich_spec_tags,
+    get_api_metadata,
+    get_api_modules,
+    get_resource_endpoints,
+    get_security_config,
+)
+from .models import ApiMetadata, ModuleSpec, ParameterInfo, ResourceSpec, SecurityConfig, ToolSpec
+from .test_generator import generate_auth_flow_tests, generate_tool_tests
+from .utils import get_pydantic_model_schema, sanitize_name
+
+__version__ = _pkg_version("mcp-generator")
+
+__all__ = [
+    "main",
+    "generate_client_package",
+    "generate_all",
+    "generate_modular_servers",
+    "generate_main_composition_server",
+    "enrich_spec_tags",
+    "get_api_modules",
+    "get_api_metadata",
+    "get_security_config",
+    "get_resource_endpoints",
+    "ApiMetadata",
+    "SecurityConfig",
+    "ModuleSpec",
+    "ParameterInfo",
+    "ToolSpec",
+    "ResourceSpec",
+    "sanitize_name",
+    "get_pydantic_model_schema",
+    "generate_auth_flow_tests",
+    "generate_tool_tests",
+]

mcp_generator/__main__.py

@@ -0,0 +1,11 @@
+"""
+MCP Generator - Package entry point.
+
+Allows running the generator as a module:
+    python -m mcp_generator
+"""
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

mcp_generator/a2a.py

@@ -0,0 +1,238 @@
+"""
+A2A (Agent-to-Agent) adapter generation.
+
+Generates an AgentCard JSON and a thin A2A adapter that exposes the
+generated MCP server as an A2A-compatible agent.
+
+See: https://github.com/a2aproject/A2A
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from .models import ApiMetadata, ModuleSpec
+
+logger = logging.getLogger(__name__)
+
+
+def generate_agent_card(
+    api_metadata: ApiMetadata,
+    modules: dict[str, ModuleSpec],
+    *,
+    agent_url: str = "http://localhost:8000",
+) -> dict[str, Any]:
+    """Build an A2A AgentCard from OpenAPI metadata and generated modules.
+
+    The AgentCard follows the A2A specification and describes the agent's
+    capabilities, skills, and supported content types so other agents or
+    orchestrators can discover and invoke it.
+
+    Args:
+        api_metadata: Extracted API metadata.
+        modules: Generated MCP module specs (used to derive skills).
+        agent_url: Base URL where the A2A agent will be hosted.
+
+    Returns:
+        AgentCard as a JSON-serialisable dict.
+    """
+    skills = []
+    for mod_name, mod in sorted(modules.items()):
+        # Each module becomes a skill
+        tag_label = mod_name.replace("_", " ")
+        skills.append(
+            {
+                "id": f"{mod_name}_skill",
+                "name": f"{tag_label.title()} Operations",
+                "description": f"Handles {tag_label} API operations via MCP tools ({mod.tool_count} tools).",
+                "tags": [mod_name, "mcp", "api"],
+                "examples": [f"Manage {tag_label} resources"],
+            }
+        )
+
+    card: dict[str, Any] = {
+        "name": api_metadata.title,
+        "description": api_metadata.description or f"A2A agent for {api_metadata.title}",
+        "url": agent_url,
+        "version": api_metadata.version,
+        "capabilities": {
+            "streaming": True,
+            "pushNotifications": False,
+        },
+        "defaultInputModes": ["text", "text/plain"],
+        "defaultOutputModes": ["text", "text/plain"],
+        "skills": skills,
+    }
+    return card
+
+
+def render_a2a_adapter(api_metadata: ApiMetadata) -> str:
+    """Generate a Python adapter that exposes the MCP server as an A2A agent.
+
+    The adapter:
+    - Loads the AgentCard from ``agent_card.json``
+    - Wraps the existing FastMCP server and translates A2A requests to MCP tool calls
+    - Runs a Starlette app on a configurable port
+
+    Returns:
+        Python source code for ``a2a_adapter.py``.
+    """
+    from .utils import sanitize_server_name
+
+    server_name = sanitize_server_name(api_metadata.title)
+    server_module = f"{server_name}_mcp_generated"
+
+    return f'''"""
+A2A Adapter — exposes the MCP server as an A2A-compatible agent.
+
+Translates incoming A2A task requests into MCP tool calls and streams
+results back using the A2A protocol.
+
+Requirements:
+    pip install a2a-sdk starlette uvicorn
+
+Usage:
+    python a2a_adapter.py [--host 0.0.0.0] [--port 8000]
+
+Auto-generated by mcp_generator.
+"""
+
+import asyncio
+import json
+import logging
+import os
+import sys
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Lazy imports — fail gracefully if a2a-sdk is not installed
+# ---------------------------------------------------------------------------
+
+try:
+    from a2a.server.apps import A2AStarletteApplication
+    from a2a.server.request_handlers import DefaultRequestHandler
+    from a2a.server.tasks import InMemoryTaskStore
+    from a2a.types import AgentCard, AgentSkill, AgentCapabilities
+    A2A_AVAILABLE = True
+except ImportError:
+    A2A_AVAILABLE = False
+
+
+def _load_agent_card() -> dict:
+    """Load the generated agent_card.json from the same directory."""
+    card_path = Path(__file__).parent / "agent_card.json"
+    with open(card_path, encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _build_agent_card(raw: dict, agent_url: str) -> "AgentCard":
+    """Construct a typed AgentCard from the raw JSON dict."""
+    skills = [
+        AgentSkill(
+            id=s["id"],
+            name=s["name"],
+            description=s["description"],
+            tags=s.get("tags", []),
+            examples=s.get("examples", []),
+        )
+        for s in raw.get("skills", [])
+    ]
+    return AgentCard(
+        name=raw["name"],
+        description=raw.get("description", ""),
+        url=agent_url,
+        version=raw.get("version", "1.0.0"),
+        capabilities=AgentCapabilities(
+            streaming=raw.get("capabilities", {{}}).get("streaming", True),
+            pushNotifications=raw.get("capabilities", {{}}).get("pushNotifications", False),
+        ),
+        defaultInputModes=raw.get("defaultInputModes", ["text"]),
+        defaultOutputModes=raw.get("defaultOutputModes", ["text"]),
+        skills=skills,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Simple MCP-backed agent executor
+# ---------------------------------------------------------------------------
+
+class MCPAgentExecutor:
+    """Translates A2A task execution into MCP tool calls.
+
+    This executor:
+    1. Receives a user message from the A2A framework.
+    2. Forwards it to the MCP server (in-process) as a tool call.
+    3. Returns the tool result as the A2A task output.
+    """
+
+    def __init__(self):
+        # Import the generated MCP server
+        sys.path.insert(0, str(Path(__file__).parent))
+        from {server_module} import mcp  # noqa: F811
+        self.mcp = mcp
+
+    async def execute(self, task_input: str, **kwargs) -> str:
+        """Execute a task by delegating to the MCP server's tools."""
+        # List available tools and try to match the input
+        tools = await self.mcp._tool_manager.list_tools()
+        tool_names = [t.name for t in tools]
+
+        # Simple heuristic: if input matches a tool name, call it directly
+        input_lower = task_input.lower().strip()
+        for tool in tools:
+            if tool.name.lower() == input_lower:
+                result = await self.mcp._tool_manager.call_tool(tool.name, {{}})
+                return str(result)
+
+        # Otherwise return available tools as guidance
+        return (
+            f"Available MCP tools: {{', '.join(tool_names)}}. "
+            f"Please specify which tool to call and its parameters."
+        )
+
+
+# ---------------------------------------------------------------------------
+# CLI entry point
+# ---------------------------------------------------------------------------
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description="A2A Adapter for {api_metadata.title}")
+    parser.add_argument("--host", default=os.getenv("A2A_HOST", "localhost"))
+    parser.add_argument("--port", type=int, default=int(os.getenv("A2A_PORT", "8000")))
+    args = parser.parse_args()
+
+    if not A2A_AVAILABLE:
+        print("❌ a2a-sdk is required: pip install a2a-sdk")
+        sys.exit(1)
+
+    raw_card = _load_agent_card()
+    agent_url = f"http://{{args.host}}:{{args.port}}"
+    agent_card = _build_agent_card(raw_card, agent_url)
+
+    executor = MCPAgentExecutor()
+    handler = DefaultRequestHandler(
+        agent_executor=executor,
+        task_store=InMemoryTaskStore(),
+    )
+
+    server = A2AStarletteApplication(
+        agent_card=agent_card,
+        http_handler=handler,
+    )
+
+    print(f"🤖 A2A Agent: {{agent_card.name}}")
+    print(f"   URL: {{agent_url}}")
+    print(f"   Skills: {{len(agent_card.skills)}}")
+
+    import uvicorn
+    uvicorn.run(server.build(), host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    main()
+'''