simcpi 0.0.0__tar.gz

simcpi-0.0.0/PKG-INFO

@@ -0,0 +1,3 @@
+Metadata-Version: 2.4
+Name: simcpi
+Version: 0.0.0

simcpi-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

simcpi-0.0.0/simcpi/__init__.py

@@ -0,0 +1,4 @@
+from .mcpserver import MCPApi
+from .mcpclient import MCPClient
+
+__all__ = ["MCPApi", "MCPClient"]

simcpi-0.0.0/simcpi/mcpclient.py

@@ -0,0 +1,344 @@
+"""
+mcpclient.py — simcpi client
+=============================
+Standalone LLM + MCP client. Completely independent of mcpserver.py.
+Point it at ANY MCP server — yours or someone else's.
+
+Usage:
+    import asyncio
+    from mcpclient import MCPClient
+
+    client = MCPClient(
+        mcp_server="http://localhost:8000/mcp/mcp",
+        provider="openai",
+        api_key="sk-...",
+    )
+    result = asyncio.run(client.run("Add 42 and 58"))
+    print(result.answer)
+    print(result.tools_called)
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from dataclasses import dataclass, field
+from typing import Literal
+
+# ── Dependency check ──────────────────────────────────────────────────────────
+_REQUIRED = {
+    "fastmcp": "fastmcp>=3.0.0",
+}
+_missing = []
+for _pkg, _spec in _REQUIRED.items():
+    try:
+        __import__(_pkg)
+    except ImportError:
+        _missing.append(_spec)
+if _missing:
+    print("[simcpi] Missing dependencies. Run: pip install " + " ".join(_missing))
+    sys.exit(1)
+# ─────────────────────────────────────────────────────────────────────────────
+
+from fastmcp import Client as _MCPInternalClient
+from fastmcp.client import StreamableHttpTransport
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Result types
+# ─────────────────────────────────────────────────────────────────────────────
+
+@dataclass
+class ToolCall:
+    """A single tool invocation made by the LLM."""
+    name:      str    # tool name
+    arguments: dict   # arguments the LLM passed
+    result:    str    # what the MCP server returned
+
+
+@dataclass
+class MCPResult:
+    """
+    Returned by MCPClient.run().
+
+    Attributes
+    ----------
+    answer:       Final text response from the LLM.
+    tools_called: Ordered list of every tool the LLM invoked.
+    success:      False if an exception occurred.
+    error:        Error message if success=False.
+    """
+    answer:       str
+    tools_called: list[ToolCall]
+    success:      bool = True
+    error:        str | None = None
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# MCPClient
+# ─────────────────────────────────────────────────────────────────────────────
+
+class MCPClient:
+    """
+    Connects to any MCP server and wires it to an LLM.
+    The LLM sees the tools, calls them, and returns a final answer.
+    This is what Claude Desktop does internally — packaged as a Python function.
+
+    Parameters
+    ----------
+    mcp_server:  MCP server URL  e.g. "http://localhost:8000/mcp/mcp"
+                 OR a FastMCP instance directly (for in-process use).
+    provider:    "openai" or "anthropic"
+    api_key:     Your LLM API key.
+    model:       Model name. Defaults: gpt-4o / claude-sonnet-4-20250514.
+    system:      Optional system prompt for every conversation.
+    timeout:     HTTP timeout in seconds (default 30).
+    base_url:    Custom LLM endpoint e.g. AICredits, OpenRouter.
+    """
+
+    DEFAULTS = {
+        "openai":    "gpt-4o",
+        "anthropic": "claude-sonnet-4-20250514",
+    }
+
+    def __init__(
+        self,
+        mcp_server: str | object,
+        provider:   Literal["openai", "anthropic"],
+        api_key:    str,
+        model:      str | None = None,
+        system:     str | None = None,
+        timeout:    int = 30,
+        base_url:   str | None = None,
+    ):
+        self.mcp_server = mcp_server
+        self.provider   = provider
+        self.api_key    = api_key
+        self.model      = model or self.DEFAULTS[provider]
+        self.system     = system
+        self.timeout    = timeout
+        self.base_url   = base_url
+
+    # ── Transport ─────────────────────────────────────────────────────────────
+
+    def _transport(self):
+        """
+        URL string   → StreamableHttpTransport (real HTTP connection)
+        FastMCP obj  → pass directly (in-process, no network needed)
+        """
+        if isinstance(self.mcp_server, str):
+            return StreamableHttpTransport(self.mcp_server)
+        return self.mcp_server
+
+    # ── Public API ────────────────────────────────────────────────────────────
+
+    async def list_tools(self) -> list[dict]:
+        """Fetch available tools from the MCP server."""
+        async with _MCPInternalClient(self._transport()) as client:
+            tools = await client.list_tools()
+        return [
+            {"name": t.name, "description": t.description, "inputSchema": t.inputSchema}
+            for t in tools
+        ]
+
+    async def run(self, prompt: str, interpret: bool = True) -> MCPResult:
+        """
+        Send a prompt, call MCP tools, return the result.
+
+        Parameters
+        ----------
+        prompt:     The user message / question.
+        interpret:  True  — LLM calls tools AND explains the result in natural language.
+                    False — tools are called, raw tool result returned, no LLM wrap.
+                    Default: True.
+
+        Returns
+        -------
+        MCPResult with .answer, .tools_called, .success, .error
+        """
+        try:
+            tools = await self.list_tools()
+            if not interpret:
+                return await self._run_direct(prompt, tools)
+            if self.provider == "openai":
+                return await self._run_openai(prompt, tools)
+            else:
+                return await self._run_anthropic(prompt, tools)
+        except Exception as e:
+            return MCPResult(answer="", tools_called=[], success=False, error=str(e))
+
+    # ── Internal ──────────────────────────────────────────────────────────────
+
+    async def _call_tool(self, name: str, arguments: dict) -> str:
+        """Execute one tool call on the MCP server and return the result."""
+        async with _MCPInternalClient(self._transport()) as client:
+            result = await client.call_tool(name, arguments)
+        return result.content[0].text if result.content else str(result)
+
+    async def _run_direct(self, prompt: str, mcp_tools: list[dict]) -> MCPResult:
+        """
+        interpret=False path.
+        Ask the LLM to pick a tool and extract arguments only — no final explanation.
+        Execute the tool, return the raw result as .answer.
+        """
+        if self.provider == "openai":
+            from openai import AsyncOpenAI
+            kw = dict(api_key=self.api_key, timeout=self.timeout)
+            if self.base_url:
+                kw["base_url"] = self.base_url
+            client = AsyncOpenAI(**kw)
+
+            oai_tools = [
+                {"type": "function", "function": {
+                    "name":        t["name"],
+                    "description": t.get("description", ""),
+                    "parameters":  t.get("inputSchema", {"type": "object", "properties": {}}),
+                }}
+                for t in mcp_tools
+            ]
+            messages: list = []
+            if self.system:
+                messages.append({"role": "system", "content": self.system})
+            messages.append({"role": "user", "content": prompt})
+
+            response = await client.chat.completions.create(
+                model=self.model, messages=messages,
+                tools=oai_tools, tool_choice="auto",
+            )
+            msg = response.choices[0].message
+
+        else:  # anthropic
+            import anthropic as sdk
+            kw = dict(api_key=self.api_key, timeout=self.timeout)
+            if self.base_url:
+                kw["base_url"] = self.base_url
+            client = sdk.AsyncAnthropic(**kw)
+
+            ant_tools = [
+                {"name": t["name"], "description": t.get("description", ""),
+                 "input_schema": t.get("inputSchema", {"type": "object", "properties": {}})}
+                for t in mcp_tools
+            ]
+            kw2 = dict(model=self.model, max_tokens=256, messages=[{"role": "user", "content": prompt}],
+                       tools=ant_tools)
+            if self.system:
+                kw2["system"] = self.system
+            response = await client.messages.create(**kw2)
+
+            # find first tool_use block
+            tool_block = next((b for b in response.content if b.type == "tool_use"), None)
+            if not tool_block:
+                text = " ".join(b.text for b in response.content if b.type == "text")
+                return MCPResult(answer=text, tools_called=[], success=True)
+
+            result = await self._call_tool(tool_block.name, tool_block.input)
+            return MCPResult(
+                answer=result,
+                tools_called=[ToolCall(name=tool_block.name, arguments=tool_block.input, result=result)],
+            )
+
+        # openai path — check if tool was called
+        if not msg.tool_calls:
+            return MCPResult(answer=msg.content or "", tools_called=[])
+
+        tc     = msg.tool_calls[0]  # first tool only in direct mode
+        args   = json.loads(tc.function.arguments)
+        result = await self._call_tool(tc.function.name, args)
+        return MCPResult(
+            answer=result,
+            tools_called=[ToolCall(name=tc.function.name, arguments=args, result=result)],
+        )
+
+    async def _run_openai(self, prompt: str, mcp_tools: list[dict]) -> MCPResult:
+        from openai import AsyncOpenAI
+
+        kw = dict(api_key=self.api_key, timeout=self.timeout)
+        if self.base_url:
+            kw["base_url"] = self.base_url
+        client = AsyncOpenAI(**kw)
+
+        oai_tools = [
+            {"type": "function", "function": {
+                "name":        t["name"],
+                "description": t.get("description", ""),
+                "parameters":  t.get("inputSchema", {"type": "object", "properties": {}}),
+            }}
+            for t in mcp_tools
+        ]
+
+        messages: list = []
+        if self.system:
+            messages.append({"role": "system", "content": self.system})
+        messages.append({"role": "user", "content": prompt})
+        tool_calls: list[ToolCall] = []
+
+        while True:
+            response = await client.chat.completions.create(
+                model=self.model,
+                messages=messages,
+                tools=oai_tools or None,
+                tool_choice="auto" if oai_tools else None,
+            )
+            msg = response.choices[0].message
+            messages.append(msg)
+
+            if msg.tool_calls:
+                results = []
+                for tc in msg.tool_calls:
+                    args   = json.loads(tc.function.arguments)
+                    result = await self._call_tool(tc.function.name, args)
+                    tool_calls.append(ToolCall(name=tc.function.name, arguments=args, result=result))
+                    results.append({"tool_call_id": tc.id, "role": "tool", "content": result})
+                messages.extend(results)
+            else:
+                return MCPResult(answer=msg.content or "", tools_called=tool_calls)
+
+    async def _run_anthropic(self, prompt: str, mcp_tools: list[dict]) -> MCPResult:
+        import anthropic as sdk
+
+        kw = dict(api_key=self.api_key, timeout=self.timeout)
+        if self.base_url:
+            kw["base_url"] = self.base_url
+        client = sdk.AsyncAnthropic(**kw)
+
+        ant_tools = [
+            {"name": t["name"], "description": t.get("description", ""),
+             "input_schema": t.get("inputSchema", {"type": "object", "properties": {}})}
+            for t in mcp_tools
+        ]
+        messages: list = [{"role": "user", "content": prompt}]
+        tool_calls: list[ToolCall] = []
+
+        while True:
+            kw2 = dict(model=self.model, max_tokens=1024, messages=messages)
+            if self.system:
+                kw2["system"] = self.system
+            if ant_tools:
+                kw2["tools"] = ant_tools
+
+            response = await client.messages.create(**kw2)
+            asst_content, tool_blocks = [], []
+
+            for block in response.content:
+                if block.type == "text":
+                    asst_content.append({"type": "text", "text": block.text})
+                elif block.type == "tool_use":
+                    asst_content.append({"type": "tool_use", "id": block.id,
+                                         "name": block.name, "input": block.input})
+                    tool_blocks.append(block)
+
+            messages.append({"role": "assistant", "content": asst_content})
+
+            if tool_blocks:
+                results = []
+                for block in tool_blocks:
+                    result = await self._call_tool(block.name, block.input)
+                    tool_calls.append(ToolCall(name=block.name, arguments=block.input, result=result))
+                    results.append({"type": "tool_result", "tool_use_id": block.id, "content": result})
+                messages.append({"role": "user", "content": results})
+            else:
+                final = " ".join(b["text"] for b in asst_content if b.get("type") == "text")
+                return MCPResult(
+                    answer=tool_calls[-1].result if not final and tool_calls else final,
+                    tools_called=tool_calls,
+                )

simcpi-0.0.0/simcpi/mcpserver.py

@@ -0,0 +1,406 @@
+"""
+mcpserver.py — simcpi server
+============================
+Single @app.create_tool_api() decorator → REST route + MCP tool.
+
+Routes added automatically:
+  GET  /docs          Swagger UI
+  GET  /mcpark        MCPark — visual explorer + LLM tester
+  POST /mcpark/tools  List registered MCP tools (internal)
+  POST /mcpark/run    Run LLM+MCP loop (internal)
+  POST /mcp/mcp       MCP streamable-http transport
+"""
+
+from __future__ import annotations
+
+import json
+import inspect
+import sys
+from inspect import cleandoc
+import functools
+from contextlib import asynccontextmanager
+from typing import Callable, Literal, get_type_hints
+
+# ── Dependency check ──────────────────────────────────────────────────────────
+_REQUIRED = {
+    "fastapi": "fastapi>=0.100.0",
+    "fastmcp": "fastmcp>=3.0.0",
+    "pydantic": "pydantic>=2.0.0",
+    "uvicorn": "uvicorn>=0.20.0",
+}
+_missing = []
+for _pkg, _spec in _REQUIRED.items():
+    try:
+        __import__(_pkg)
+    except ImportError:
+        _missing.append(_spec)
+if _missing:
+    print("[simcpi] Missing dependencies. Run: pip install " + " ".join(_missing))
+    sys.exit(1)
+# ─────────────────────────────────────────────────────────────────────────────
+
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastmcp import FastMCP
+from fastmcp import Client as _MCPInternalClient
+from fastmcp.client import StreamableHttpTransport
+from pydantic import BaseModel
+from pathlib import Path
+
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# MCPark HTML — served at /mcpark
+# ─────────────────────────────────────────────────────────────────────────────
+
+html_path = Path(__file__).parent / "static" / "mcpark.html"
+
+with open(html_path, "r", encoding="utf-8") as f:
+    MCPARK_HTML = f.read()
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Pydantic models
+# ─────────────────────────────────────────────────────────────────────────────
+
+class RunRequest(BaseModel):
+    prompt:   str
+    api_key:  str | None = None
+    provider: Literal["openai", "anthropic"] | None = None
+    model:    str = "gpt-4o"
+    base_url: str | None = None
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# MCPApi — the server class
+# ─────────────────────────────────────────────────────────────────────────────
+
+class MCPApi:
+    """
+    Merges FastAPI and FastMCP into a single server.
+
+    Parameters
+    ----------
+    title:          API / MCP server name.
+    mcp_path:       MCP transport prefix (default: "/mcp").
+    version:        Version string.
+    description:    Shown in OpenAPI docs and MCP server instructions.
+    mcpark_path:    Path for MCPark UI (default: "/mcpark"). None to disable.
+    provider:       Default LLM provider — "openai" or "anthropic".
+    api_key:        Default LLM API key. Inherited by MCPark UI + get_client().
+    base_url:       Default LLM base URL (for proxies like AICredits, OpenRouter).
+    model:          Default model name. Shown pre-selected in MCPark.
+    """
+
+    def __init__(
+        self,
+        title:        str = "simcpi",
+        mcp_path:     str = "/mcp",
+        version:      str = "0.1.0",
+        description:  str | None = None,
+        mcpark_path:  str | None = "/mcpark",
+        provider:     Literal["openai", "anthropic"] | None = None,
+        api_key:      str | None = None,
+        base_url:     str | None = None,
+        model:        str | None = None,
+    ):
+        self.title       = title
+        self.mcp_path    = mcp_path.rstrip("/")
+        self.mcpark_path = mcpark_path
+        self.provider    = provider
+        self.api_key     = api_key
+        self.base_url    = base_url
+        self.model       = model
+
+        # ── FastMCP ──────────────────────────────────────────────────────────
+        self.mcp     = FastMCP(name=title, version=version, instructions=description)
+        self._mcp_app = self.mcp.http_app()
+
+        # ── FastAPI + wired MCP lifespan ─────────────────────────────────────
+        mcp_app = self._mcp_app
+
+        @asynccontextmanager
+        async def combined_lifespan(app: FastAPI):
+            async with mcp_app.lifespan(mcp_app):
+                yield
+
+        self.api = FastAPI(
+            title=title,
+            version=version,
+            description=description or "",
+            lifespan=combined_lifespan,
+        )
+
+        self.api.mount(self.mcp_path, self._mcp_app)
+
+        # ── Routes ───────────────────────────────────────────────────────────
+        self._register_mcpark()
+
+        # ── Registry ─────────────────────────────────────────────────────────
+        self._registry: dict[str, Callable] = {}
+
+    # ── MCPark routes ─────────────────────────────────────────────────────────
+
+    def _register_mcpark(self):
+        if not self.mcpark_path:
+            return
+
+        path = self.mcpark_path
+
+        # Build server config dict — injected into the HTML so UI pre-fills
+        def _server_config(self=self) -> dict:
+            return {
+                "provider": self.provider or "openai",
+                "has_server_key": bool(self.api_key),
+                "base_url": self.base_url,
+                "model":    self.model or "gpt-4o",
+                "mcp_path": self.mcp_path,
+            }
+
+        @self.api.get(path, response_class=HTMLResponse, include_in_schema=False)
+        async def mcpark_ui():
+            import json as _json
+            config_json = _json.dumps(_server_config())
+            html = MCPARK_HTML.replace("__SERVER_CONFIG__", config_json)
+            return HTMLResponse(html)
+
+        @self.api.post(f"{path}/tools", include_in_schema=False)
+        async def mcpark_tools():
+            async with _MCPInternalClient(self.mcp) as client:
+                tools = await client.list_tools()
+            return JSONResponse({
+                "tools": [
+                    {"name": t.name, "description": t.description, "inputSchema": t.inputSchema}
+                    for t in tools
+                ]
+            })
+
+        @self.api.post(f"{path}/run", include_in_schema=False)
+        async def mcpark_run(req: RunRequest, request: Request):
+            # Resolve — request body wins, instance defaults as fallback
+            resolved_provider = req.provider or self.provider
+            resolved_api_key  = req.api_key  or self.api_key
+            resolved_base_url = req.base_url or self.base_url
+            resolved_model    = req.model    or self.model or "gpt-4o"
+
+            if not resolved_provider or not resolved_api_key:
+                return JSONResponse({
+                    "error": "provider and api_key are required — set on MCPApi() or pass in the UI",
+                    "trace": [], "tools_called": False
+                })
+
+            base    = str(request.base_url).rstrip("/")
+            mcp_url = f"{base}{self.mcp_path}/mcp"
+
+            # Fetch tools via real HTTP transport
+            transport = StreamableHttpTransport(mcp_url)
+            async with _MCPInternalClient(transport) as client:
+                raw_tools = await client.list_tools()
+
+            mcp_tools = [
+                {"name": t.name, "description": t.description, "inputSchema": t.inputSchema}
+                for t in raw_tools
+            ]
+
+            trace:        list[dict] = []
+            tools_called: bool      = False
+
+            try:
+                if resolved_provider == "openai":
+                    from openai import AsyncOpenAI
+                    kw = dict(api_key=resolved_api_key)
+                    if resolved_base_url:
+                        kw["base_url"] = resolved_base_url
+                    oai = AsyncOpenAI(**kw)
+
+                    oai_tools = [
+                        {"type": "function", "function": {
+                            "name":        t["name"],
+                            "description": t.get("description", ""),
+                            "parameters":  t.get("inputSchema", {"type": "object", "properties": {}}),
+                        }}
+                        for t in mcp_tools
+                    ]
+                    messages = [{"role": "user", "content": req.prompt}]
+
+                    while True:
+                        resp = await oai.chat.completions.create(
+                            model=resolved_model, messages=messages,
+                            tools=oai_tools, tool_choice="auto",
+                        )
+                        msg = resp.choices[0].message
+                        messages.append(msg)
+
+                        if msg.tool_calls:
+                            tools_called = True
+                            results = []
+                            for tc in msg.tool_calls:
+                                import json as _j
+                                args = _j.loads(tc.function.arguments)
+                                trace.append({"type": "tool_call", "name": tc.function.name, "arguments": args})
+                                async with _MCPInternalClient(StreamableHttpTransport(mcp_url)) as c:
+                                    r = await c.call_tool(tc.function.name, args)
+                                txt = r.content[0].text if r.content else str(r)
+                                trace.append({"type": "tool_result", "name": tc.function.name, "result": txt})
+                                results.append({"tool_call_id": tc.id, "role": "tool", "content": txt})
+                            messages.extend(results)
+                        else:
+                            if msg.content:
+                                trace.append({"type": "message", "content": msg.content})
+                            break
+
+                else:  # anthropic
+                    import anthropic as _sdk
+                    kw = dict(api_key=resolved_api_key)
+                    if resolved_base_url:
+                        kw["base_url"] = resolved_base_url
+                    ant = _sdk.AsyncAnthropic(**kw)
+
+                    ant_tools = [
+                        {"name": t["name"], "description": t.get("description", ""),
+                         "input_schema": t.get("inputSchema", {"type": "object", "properties": {}})}
+                        for t in mcp_tools
+                    ]
+                    messages = [{"role": "user", "content": req.prompt}]
+
+                    while True:
+                        resp = await ant.messages.create(
+                            model=resolved_model, max_tokens=1024,
+                            tools=ant_tools, messages=messages,
+                        )
+                        asst_content, tool_blocks = [], []
+                        for block in resp.content:
+                            if block.type == "text":
+                                asst_content.append({"type": "text", "text": block.text})
+                                if block.text:
+                                    trace.append({"type": "message", "content": block.text})
+                            elif block.type == "tool_use":
+                                tools_called = True
+                                asst_content.append({"type": "tool_use", "id": block.id,
+                                                     "name": block.name, "input": block.input})
+                                trace.append({"type": "tool_call", "name": block.name, "arguments": block.input})
+                                tool_blocks.append(block)
+
+                        messages.append({"role": "assistant", "content": asst_content})
+
+                        if tool_blocks:
+                            results = []
+                            for block in tool_blocks:
+                                async with _MCPInternalClient(StreamableHttpTransport(mcp_url)) as c:
+                                    r = await c.call_tool(block.name, block.input)
+                                txt = r.content[0].text if r.content else str(r)
+                                trace.append({"type": "tool_result", "name": block.name, "result": txt})
+                                results.append({"type": "tool_result", "tool_use_id": block.id, "content": txt})
+                            messages.append({"role": "user", "content": results})
+                        else:
+                            break
+
+            except Exception as e:
+                return JSONResponse({"error": str(e), "trace": trace, "tools_called": tools_called})
+
+            return JSONResponse({"trace": trace, "tools_called": tools_called})
+
+    # ── @create_tool_api decorator ────────────────────────────────────────────
+
+    def create_tool_api(
+        self,
+        path: str,
+        *,
+        method:    Literal["GET", "POST", "PUT", "PATCH", "DELETE"] = "POST",
+        tool_name: str | None = None,
+        tags:      list[str] | None = None,
+        summary:   str | None = None,
+    ) -> Callable:
+        """
+        Register a function as both a FastAPI REST endpoint and a FastMCP tool.
+
+        The function's docstring becomes the MCP tool description —
+        write it for the LLM, not just for humans.
+
+        Usage:
+            @app.create_tool_api("/add", method="POST")
+            def add(a: int, b: int) -> int:
+                \"\"\"
+                Add two numbers.
+                Use this when the user asks to sum or total numbers.
+                \"\"\"
+                return a + b
+        """
+        def decorator(fn: Callable) -> Callable:
+            name = tool_name or fn.__name__
+            doc  = cleandoc(fn.__doc__) if fn.__doc__ else ""
+
+            # 1. FastMCP tool
+            self.mcp.tool(name=name, description=doc)(fn)
+
+            # 2. FastAPI route
+            @functools.wraps(fn)
+            async def route_handler(*args, **kwargs):
+                if inspect.iscoroutinefunction(fn):
+                    return await fn(*args, **kwargs)
+                return fn(*args, **kwargs)
+
+            route_handler.__annotations__ = get_type_hints(fn)
+            route_handler.__doc__ = doc
+
+            getattr(self.api, method.lower())(
+                path, summary=summary or name,
+                description=doc, tags=tags, name=name,
+            )(route_handler)
+
+            self._registry[name] = fn
+            return fn
+
+        return decorator
+
+    # ── ASGI passthrough ──────────────────────────────────────────────────────
+
+    async def __call__(self, scope, receive, send):
+        await self.api(scope, receive, send)
+
+    # ── get_client — returns a wired MCPClient ────────────────────────────────
+
+    def get_client(
+        self,
+        provider: Literal["openai", "anthropic"] | None = None,
+        api_key:  str | None = None,
+        model:    str | None = None,
+        system:   str | None = None,
+        timeout:  int = 30,
+        base_url: str | None = None,
+    ) -> "MCPClient":
+        """
+        Return an MCPClient pre-wired to this server's MCP instance (in-process).
+
+        Falls back to provider/api_key/base_url/model set on MCPApi().
+
+        Usage:
+            app = MCPApi(provider="openai", api_key="sk-...")
+            client = app.get_client()
+            result = await client.run("Add 42 and 58")
+        """
+        from .mcpclient import MCPClient
+
+        resolved_provider = provider or self.provider
+        resolved_api_key  = api_key  or self.api_key
+        resolved_base_url = base_url or self.base_url
+        resolved_model    = model    or self.model
+
+        if not resolved_provider:
+            raise ValueError("provider required — set on MCPApi() or pass to get_client()")
+        if not resolved_api_key:
+            raise ValueError("api_key required — set on MCPApi() or pass to get_client()")
+
+        return MCPClient(
+            mcp_server=self.mcp,
+            provider=resolved_provider,
+            api_key=resolved_api_key,
+            model=resolved_model,
+            system=system,
+            timeout=timeout,
+            base_url=resolved_base_url,
+        )
+
+    def list_tools(self) -> list[str]:
+        """Return names of all registered tools."""
+        return list(self._registry.keys())

simcpi-0.0.0/simcpi.egg-info/PKG-INFO

@@ -0,0 +1,3 @@
+Metadata-Version: 2.4
+Name: simcpi
+Version: 0.0.0

simcpi-0.0.0/simcpi.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+simcpi/__init__.py
+simcpi/mcpclient.py
+simcpi/mcpserver.py
+simcpi.egg-info/PKG-INFO
+simcpi.egg-info/SOURCES.txt
+simcpi.egg-info/dependency_links.txt
+simcpi.egg-info/top_level.txt

simcpi-0.0.0/simcpi.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

simcpi-0.0.0/simcpi.egg-info/top_level.txt

@@ -0,0 +1 @@
+simcpi