agentruntime-mcp 0.0.1__tar.gz

agentruntime_mcp-0.0.1/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: agentruntime-mcp
+Version: 0.0.1
+Summary: AgentRuntime MCP SDK (decorators, runtime, middleware, schemas, proxy, generators)
+Author: AgentRuntime
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastmcp
+Requires-Dist: pydantic>=2
+Requires-Dist: starlette>=0.37
+Requires-Dist: uvicorn[standard]>=0.30
+Requires-Dist: opentelemetry-api>=1.25
+Requires-Dist: opentelemetry-sdk>=1.25
+Requires-Dist: opentelemetry-exporter-otlp>=1.25
+Requires-Dist: PyYAML>=6
+Requires-Dist: httpx>=0.25
+
+# AgentRuntime MCP SDK (Python)
+
+Opinionated SDK for building MCP agents with FastMCP.
+
+## Install
+```bash
+pip install agentruntime-mcp
+```
+
+## Minimal example
+```python
+from pydantic import BaseModel, Field
+from agentruntime.mcp.decorators import tool
+from agentruntime.mcp.runtime import run
+
+class In(BaseModel):
+    a: float = Field(...)
+    b: float = Field(...)
+
+class Out(BaseModel):
+    result: float
+    expression: str
+
+@tool(name="add", input_model=In, output_model=Out)
+def add(a: float, b: float) -> Out:
+    return Out(result=a+b, expression=f"{a} + {b}")
+
+if __name__ == "__main__":
+    run("config.yaml")
+```
+
+## Config
+- `config.yaml` controls server host/port, auth mode, and tracing.  
+- Env overrides: `HOST`, `PORT`, `MCP_AUTH_MODE`.
+
+Auth modes
+- `none`: no auth
+- `token`: `Authorization: Bearer <token>` or `X-MCP-Token`; dev fallback `?auth_token=` if `ALLOW_QUERY_TOKEN=true`
+- `hmac`: headers `X-MCP-KeyId`, `X-MCP-Timestamp` (unix seconds), `X-MCP-Signature` (hex(HMAC-SHA256(secret, `${ts}\n${method}\n${path}`)))
+
+## Proxy (library)
+```python
+from agentruntime.mcp.proxy import run_proxy
+run_proxy(target_url="http://127.0.0.1:8000/mcp", overlay_file="tools.yaml", host="127.0.0.1", port=8010)
+```

agentruntime_mcp-0.0.1/README.md

@@ -0,0 +1,45 @@
+# AgentRuntime MCP SDK (Python)
+
+Opinionated SDK for building MCP agents with FastMCP.
+
+## Install
+```bash
+pip install agentruntime-mcp
+```
+
+## Minimal example
+```python
+from pydantic import BaseModel, Field
+from agentruntime.mcp.decorators import tool
+from agentruntime.mcp.runtime import run
+
+class In(BaseModel):
+    a: float = Field(...)
+    b: float = Field(...)
+
+class Out(BaseModel):
+    result: float
+    expression: str
+
+@tool(name="add", input_model=In, output_model=Out)
+def add(a: float, b: float) -> Out:
+    return Out(result=a+b, expression=f"{a} + {b}")
+
+if __name__ == "__main__":
+    run("config.yaml")
+```
+
+## Config
+- `config.yaml` controls server host/port, auth mode, and tracing.  
+- Env overrides: `HOST`, `PORT`, `MCP_AUTH_MODE`.
+
+Auth modes
+- `none`: no auth
+- `token`: `Authorization: Bearer <token>` or `X-MCP-Token`; dev fallback `?auth_token=` if `ALLOW_QUERY_TOKEN=true`
+- `hmac`: headers `X-MCP-KeyId`, `X-MCP-Timestamp` (unix seconds), `X-MCP-Signature` (hex(HMAC-SHA256(secret, `${ts}\n${method}\n${path}`)))
+
+## Proxy (library)
+```python
+from agentruntime.mcp.proxy import run_proxy
+run_proxy(target_url="http://127.0.0.1:8000/mcp", overlay_file="tools.yaml", host="127.0.0.1", port=8010)
+```

agentruntime_mcp-0.0.1/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agentruntime-mcp"
+version = "0.0.1"
+description = "AgentRuntime MCP SDK (decorators, runtime, middleware, schemas, proxy, generators)"
+requires-python = ">=3.10"
+readme = "README.md"
+authors = [{ name = "AgentRuntime" }]
+dependencies = [
+  "fastmcp",
+  "pydantic>=2",
+  "starlette>=0.37",
+  "uvicorn[standard]>=0.30",
+  "opentelemetry-api>=1.25",
+  "opentelemetry-sdk>=1.25",
+  "opentelemetry-exporter-otlp>=1.25",
+  "PyYAML>=6",
+  "httpx>=0.25",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+

agentruntime_mcp-0.0.1/setup.cfg

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

agentruntime_mcp-0.0.1/src/agentruntime/__init__.py

@@ -0,0 +1,2 @@
+# Namespace package for AgentRuntime
+

agentruntime_mcp-0.0.1/src/agentruntime/mcp/__init__.py

@@ -0,0 +1,4 @@
+from .decorators import tool, mount_tools  # noqa: F401
+from .runtime import run, make_server, load_config  # noqa: F401
+from .schemas import emit_json_shape, emit_flat_shape, build_schemas  # noqa: F401
+

agentruntime_mcp-0.0.1/src/agentruntime/mcp/decorators.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from typing import Callable, Optional, Type, Any, Dict, List, Tuple
+from pydantic import BaseModel
+from fastmcp import FastMCP
+
+
+class ToolRegistry:
+    def __init__(self) -> None:
+        self.entries: List[Dict[str, Any]] = []
+
+    def register(
+        self,
+        name: str,
+        func: Callable[..., Any],
+        input_model: Optional[Type[BaseModel]],
+        output_model: Optional[Type[BaseModel]],
+        description: Optional[str],
+    ) -> None:
+        self.entries.append(
+            {
+                "name": name,
+                "func": func,
+                "in_model": input_model,
+                "out_model": output_model,
+                "desc": (description or "").strip() or None,
+            }
+        )
+
+
+registry = ToolRegistry()
+
+
+def tool(
+    name: str,
+    input_model: Optional[Type[BaseModel]] = None,
+    output_model: Optional[Type[BaseModel]] = None,
+    description: Optional[str] = None,
+):
+    def deco(func: Callable[..., Any]) -> Callable[..., Any]:
+        registry.register(name, func, input_model, output_model, description or getattr(func, "__doc__", None))
+        return func
+
+    return deco
+
+
+def mount_tools(
+    mcp: FastMCP,
+    schema_builder: Callable[[Optional[type], Optional[type]], Tuple[Dict[str, Any], Dict[str, Any]]],
+) -> List[Tuple[Dict[str, Any], Callable[..., Any]]]:
+    """Expose tools from the registry on the given FastMCP app and add tools/list."""
+    exposed: List[Tuple[Dict[str, Any], Callable[..., Any]]] = []
+    for e in registry.entries:
+        exposed_fn = mcp.tool(name=e["name"])(e["func"])  # type: ignore[arg-type]
+        exposed.append((e, exposed_fn))
+
+    @mcp.tool(name="list_tools")
+    def list_tools() -> Dict[str, Any]:
+        items: List[Dict[str, Any]] = []
+        for e, _ in exposed:
+            s_in, s_out = schema_builder(e.get("in_model"), e.get("out_model"))
+            items.append(
+                {
+                    "name": e["name"],
+                    "description": e.get("desc"),
+                    "inputSchema": s_in,
+                    "outputSchema": s_out,
+                }
+            )
+        return {"tools": items}
+
+    return exposed
+
+

agentruntime_mcp-0.0.1/src/agentruntime/mcp/generators/openapi_to_mcp.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, Dict
+
+TEMPLATE_HEADER = """from fastmcp import FastMCP
+from pydantic import BaseModel, Field
+import httpx
+
+app = FastMCP(name="OpenAPI_MCP")
+
+def _client():
+    return httpx.Client(timeout=10)
+"""
+
+
+def generate(openapi_file: str, output_py: str) -> None:
+    with open(openapi_file, "r", encoding="utf-8") as f:
+        spec: Dict[str, Any] = json.load(f)
+
+    code = [TEMPLATE_HEADER]
+    base_url = spec.get("servers", [{}])[0].get("url", "")
+
+    paths = spec.get("paths", {})
+    for path, methods in paths.items():
+        for method, op in methods.items():
+            if method.lower() not in {"get", "post"}:
+                continue
+            op_id = op.get("operationId") or (method + "_" + path.strip("/").replace("/", "_").replace("-", "_") or "root")
+            fn_name = f"tool_{op_id}"
+            url_expr = base_url.rstrip("/") + path
+            code.append(f"\n@app.tool(name=\"{op_id}\")\ndef {fn_name}(**kwargs):\n    \"\"\"Generated from OpenAPI {method.upper()} {path}\n    kwargs are sent as JSON for POST or as params for GET\n    \"\"\"\n    with _client() as c:\n        if '{method.lower()}' == 'get':\n            r = c.get(\"{url_expr}\", params=kwargs)\n        else:\n            r = c.post(\"{url_expr}\", json=kwargs)\n        r.raise_for_status()\n        return {{'structuredContent': r.json()}}\n")
+
+    os.makedirs(os.path.dirname(output_py), exist_ok=True)
+    with open(output_py, "w", encoding="utf-8") as f:
+        f.write("\n".join(code))
+
+
+if __name__ == "__main__":
+    import argparse
+    p = argparse.ArgumentParser()
+    p.add_argument("-i", "--input", required=True, help="openapi.json path")
+    p.add_argument("-o", "--output", default="generated/openapi_tools.py")
+    args = p.parse_args()
+    generate(args.input, args.output)
+
+

agentruntime_mcp-0.0.1/src/agentruntime/mcp/middleware.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+import os
+import traceback
+from typing import Any, Dict, Optional
+import time
+import hmac
+import hashlib
+
+from fastmcp.server.middleware import Middleware, MiddlewareContext
+
+
+# ---- OpenTelemetry (OTLP over HTTP to local collector/jaeger) ----
+trace: Any = None
+TraceContextTextMapPropagator: Any = None
+tracer = None
+try:
+    from opentelemetry import trace  # type: ignore
+    from opentelemetry.trace.propagation.tracecontext import (  # type: ignore
+        TraceContextTextMapPropagator,
+    )
+    from opentelemetry.exporter.otlp.proto.http.trace_exporter import (  # type: ignore
+        OTLPSpanExporter,
+    )
+    from opentelemetry.sdk.trace import TracerProvider  # type: ignore
+    from opentelemetry.sdk.resources import Resource  # type: ignore
+    from opentelemetry.sdk.trace.export import BatchSpanProcessor  # type: ignore
+
+    otlp_endpoint = os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT", "http://127.0.0.1:4318")
+    resource = Resource.create({"service.name": os.getenv("OTEL_SERVICE_NAME", "fastmcp-enhanced")})
+    provider = TracerProvider(resource=resource)
+    processor = BatchSpanProcessor(OTLPSpanExporter(endpoint=f"{otlp_endpoint}/v1/traces"))
+    provider.add_span_processor(processor)
+    trace.set_tracer_provider(provider)
+    tracer = trace.get_tracer(os.getenv("OTEL_SERVICE_NAME", "fastmcp-enhanced"))
+
+    print("OpenTelemetry setup complete")
+except Exception:
+    print("Error setting up OpenTelemetry:")
+    print(traceback.format_exc())
+    tracer = None
+
+
+class CustomHeaderMiddleware(Middleware):
+    async def on_request(self, context: MiddlewareContext, call_next):
+        method = getattr(context, "method", "UNKNOWN")
+        tool_name = getattr(getattr(context, "message", None), "name", None)
+
+        # If OpenTelemetry isn't available, skip tracing entirely
+        if tracer is None or "trace" not in globals() or trace is None or "TraceContextTextMapPropagator" not in globals() or TraceContextTextMapPropagator is None:  # type: ignore[name-defined]
+            return await call_next(context)
+
+        def _extract_parent_ctx(req) -> Any:
+            propagator = TraceContextTextMapPropagator()
+
+            # Try headers first
+            try:
+                hdr_ctx = propagator.extract(req.headers)
+                hdr_span = trace.get_current_span(hdr_ctx).get_span_context()
+                if hdr_span and getattr(hdr_span, "is_valid", False):
+                    return hdr_ctx
+            except Exception:
+                pass
+
+            # Fallback to query parameters (?traceparent=&tracestate=)
+            try:
+                qp = getattr(req, "query_params", None)
+                if qp:
+                    carrier: Dict[str, str] = {}
+                    tp = qp.get("traceparent")
+                    ts = qp.get("tracestate")
+                    if tp:
+                        carrier["traceparent"] = tp
+                    if ts:
+                        carrier["tracestate"] = ts
+                    if carrier:
+                        q_ctx = propagator.extract(carrier)
+                        q_span = trace.get_current_span(q_ctx).get_span_context()
+                        if q_span and getattr(q_span, "is_valid", False):
+                            return q_ctx
+            except Exception:
+                pass
+
+            return None
+
+        parent_ctx: Any = None
+        try:
+            fast_ctx = getattr(context, "fastmcp_context", None)
+            if fast_ctx is not None and getattr(fast_ctx, "request_context", None) is not None:
+                req = getattr(fast_ctx.request_context, "request", None)
+                if req is not None:
+                    parent_ctx = _extract_parent_ctx(req)
+        except Exception:
+            parent_ctx = None
+
+        span_name = f"mcp.{method}"
+        if tool_name:
+            span_name = f"mcp.tools.{tool_name}"
+
+        with tracer.start_as_current_span(span_name, context=parent_ctx) as span:  # type: ignore[attr-defined]
+            span.set_attribute("mcp.method", method)
+            if tool_name:
+                span.set_attribute("mcp.tool", tool_name)
+            result = await call_next(context)
+            return result
+
+
+class AuthTokenMiddleware(Middleware):
+    async def on_request(self, context: MiddlewareContext, call_next):
+        expected_token = os.getenv("MCP_AUTH_TOKEN")
+        # Only enforce if an expected token is configured
+        if expected_token:
+            token: Optional[str] = None
+            try:
+                fast_ctx = getattr(context, "fastmcp_context", None)
+                if fast_ctx is not None and getattr(fast_ctx, "request_context", None) is not None:
+                    req = getattr(fast_ctx.request_context, "request", None)
+                    if req is not None:
+                        # 1) Prefer Authorization: Bearer <token>
+                        auth = None
+                        try:
+                            auth = req.headers.get("Authorization")
+                        except Exception:
+                            auth = None
+                        if auth and isinstance(auth, str) and auth.lower().startswith("bearer "):
+                            token = auth.split(" ", 1)[1].strip()
+                        # 2) Or X-MCP-Token header
+                        if not token:
+                            try:
+                                token = req.headers.get("X-MCP-Token")
+                            except Exception:
+                                token = None
+                        # 3) Dev fallback: query param if allowed
+                        allow_query = os.getenv("ALLOW_QUERY_TOKEN", "true").lower() == "true"
+                        if not token and allow_query and hasattr(req, "query_params"):
+                            token = req.query_params.get("auth_token")
+            except Exception:
+                token = None
+
+            if not token or token != expected_token:
+                raise PermissionError("invalid or missing auth token")
+
+        return await call_next(context)
+
+
+# Simple HMAC auth: client sends X-MCP-KeyId, X-MCP-Timestamp, X-MCP-Signature.
+# Signature is hex(hmac_sha256(secret, f"{ts}\n{method}\n{path}")) with up to 5 minutes skew.
+class HMACAuthMiddleware(Middleware):
+    def _load_secret(self, key_id: str) -> Optional[str]:
+        # Single key via env
+        single_id = os.getenv("MCP_HMAC_KEY_ID")
+        single_secret = os.getenv("MCP_HMAC_SECRET")
+        if single_id and single_secret and key_id == single_id:
+            return single_secret
+        # TODO: Optionally support JSON map in MCP_HMAC_KEYS_JSON later
+        return None
+
+    async def on_request(self, context: MiddlewareContext, call_next):
+        # If HMAC is configured via env, enforce; otherwise allow through
+        configured = bool(os.getenv("MCP_HMAC_KEY_ID") and os.getenv("MCP_HMAC_SECRET"))
+        if not configured:
+            return await call_next(context)
+
+        try:
+            fast_ctx = getattr(context, "fastmcp_context", None)
+            if fast_ctx is None or getattr(fast_ctx, "request_context", None) is None:
+                raise PermissionError("missing request context")
+            req = getattr(fast_ctx.request_context, "request", None)
+            if req is None:
+                raise PermissionError("missing request")
+
+            # Extract headers
+            key_id = req.headers.get("X-MCP-KeyId") or req.headers.get("X-MCP-Key")
+            ts = req.headers.get("X-MCP-Timestamp")
+            sig = req.headers.get("X-MCP-Signature")
+            if not key_id or not ts or not sig:
+                raise PermissionError("missing hmac headers")
+
+            # Timestamp freshness (skew up to 300s)
+            try:
+                ts_int = int(ts)
+            except Exception:
+                raise PermissionError("invalid timestamp")
+            now = int(time.time())
+            if abs(now - ts_int) > 300:
+                raise PermissionError("stale timestamp")
+
+            secret = self._load_secret(key_id)
+            if not secret:
+                raise PermissionError("unknown key id")
+
+            method = (getattr(req, "method", "POST") or "POST").upper()
+            path = getattr(getattr(req, "url", None), "path", "/mcp") or "/mcp"
+            base = f"{ts}\n{method}\n{path}"
+            expected = hmac.new(secret.encode("utf-8"), base.encode("utf-8"), hashlib.sha256).hexdigest()
+
+            if not hmac.compare_digest(expected, sig):
+                raise PermissionError("invalid signature")
+
+        except PermissionError:
+            raise
+        except Exception:
+            raise PermissionError("hmac verification failed")
+
+        return await call_next(context)
+
+

agentruntime_mcp-0.0.1/src/agentruntime/mcp/proxy.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, List, Optional
+
+from fastmcp import FastMCP
+import httpx
+import yaml
+
+
+def _overlay(overlay_file: Optional[str]) -> Dict[str, Any]:
+    if not overlay_file:
+        return {}
+    try:
+        with open(overlay_file, "r", encoding="utf-8") as f:
+            return yaml.safe_load(f) or {}
+    except Exception:
+        return {}
+
+
+def _post(target_url: str, payload: Dict[str, Any], bearer_token: Optional[str]) -> Dict[str, Any]:
+    headers = {"Accept": "application/json, text/event-stream", "Content-Type": "application/json"}
+    if bearer_token:
+        headers["Authorization"] = f"Bearer {bearer_token}"
+    r = httpx.post(target_url, headers=headers, content=json.dumps(payload), timeout=15)
+    r.raise_for_status()
+    return r.json()
+
+
+def build_proxy_app(target_url: str, overlay_file: Optional[str] = None, bearer_token: Optional[str] = None) -> FastMCP:
+    app = FastMCP(name="MCPProxy")
+
+    @app.tool(name="list_tools")
+    def list_tools() -> Dict[str, Any]:
+        if not target_url:
+            return {"tools": []}
+        res = _post(target_url, {"jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {}}, bearer_token)
+        tools: List[Dict[str, Any]] = res.get("result", {}).get("tools", [])
+        ov = _overlay(overlay_file)
+        ov_map = {t.get("name"): t for t in ov.get("tools", [])}
+        merged: List[Dict[str, Any]] = []
+        for t in tools:
+            name = t.get("name")
+            if name in ov_map:
+                mt = {**t}
+                o = ov_map[name]
+                if o.get("description"):
+                    mt["description"] = o["description"]
+                if o.get("inputSchema"):
+                    mt["inputSchema"] = o["inputSchema"]
+                if o.get("outputSchema"):
+                    mt["outputSchema"] = o["outputSchema"]
+                merged.append(mt)
+            else:
+                merged.append(t)
+        return {"tools": merged}
+
+    @app.tool(name="call")
+    def call(name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        if not target_url:
+            raise ValueError("Proxy target not configured")
+        res = _post(
+            target_url,
+            {"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": name, "arguments": arguments}},
+            bearer_token,
+        )
+        return res.get("result", {})
+
+    return app
+
+
+def run_proxy(target_url: str, overlay_file: Optional[str] = None, bearer_token: Optional[str] = None, host: str = "127.0.0.1", port: int = 8010) -> None:
+    app = build_proxy_app(target_url, overlay_file, bearer_token)
+    app.run(transport="http", host=host, port=port, stateless_http=True)
+
+

agentruntime_mcp-0.0.1/src/agentruntime/mcp/runtime.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import os
+import yaml
+from typing import Any, Dict
+from fastmcp import FastMCP
+
+from .decorators import mount_tools
+from .schemas import build_schemas
+from .middleware import CustomHeaderMiddleware, AuthTokenMiddleware, HMACAuthMiddleware
+
+
+def load_config(path: str = "config.yaml") -> Dict[str, Any]:
+    if not os.path.exists(path):
+        return {}
+    with open(path, "r", encoding="utf-8") as f:
+        return yaml.safe_load(f) or {}
+
+
+def make_server(config_path: str = "config.yaml") -> FastMCP:
+    cfg = load_config(config_path)
+    name = cfg.get("server", {}).get("name", "MCPServer")
+    app = FastMCP(name=name)
+
+    # Middleware toggles
+    if cfg.get("tracing", {}).get("enabled", True):
+        app.add_middleware(CustomHeaderMiddleware())
+    auth_mode = os.getenv("MCP_AUTH_MODE") or cfg.get("auth", {}).get("mode", "token")
+    if auth_mode == "token":
+        app.add_middleware(AuthTokenMiddleware())
+    elif auth_mode == "hmac":
+        app.add_middleware(HMACAuthMiddleware())
+
+    # Mount tools from decorators registry; add list_tools
+    mount_tools(app, build_schemas)
+    return app
+
+
+def run(config_path: str = "config.yaml") -> None:
+    app = make_server(config_path)
+    cfg = load_config(config_path)
+    host = os.getenv("HOST") or cfg.get("server", {}).get("host", "127.0.0.1")
+    port = int(os.getenv("PORT") or cfg.get("server", {}).get("port", 8000))
+    stateless = cfg.get("server", {}).get("stateless_http", True)
+    app.run(transport="http", host=host, port=port, stateless_http=stateless)
+
+

agentruntime_mcp-0.0.1/src/agentruntime/mcp/schemas.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional, Type, List, get_args, get_origin
+from pydantic import BaseModel
+from enum import Enum
+
+
+def _map_type_json(py_type: Any) -> Dict[str, Any]:
+    origin = get_origin(py_type)
+    args = get_args(py_type)
+    if origin in (list, List):
+        item_type = args[0] if args else Any
+        return {"type": "array", "items": _map_type_json(item_type)}
+    if isinstance(py_type, type) and issubclass(py_type, Enum):
+        try:
+            values = [m.value for m in py_type]
+        except Exception:
+            values = [str(m) for m in py_type]
+        return {"type": "enum", "enum": values}
+    if py_type is str:
+        return {"type": "string"}
+    if py_type is int:
+        return {"type": "integer"}
+    if py_type is float:
+        return {"type": "float"}
+    if py_type is bool:
+        return {"type": "boolean"}
+    if py_type is dict:
+        return {"type": "object"}
+    return {"type": "string"}
+
+
+def _json_constraints(prop: Dict[str, Any], field_info: Any) -> None:
+    min_len = getattr(field_info, "min_length", None) or getattr(field_info, "min_items", None)
+    max_len = getattr(field_info, "max_length", None) or getattr(field_info, "max_items", None)
+    if prop.get("type") == "string":
+        if min_len is not None:
+            prop["minLength"] = int(min_len)
+        if max_len is not None:
+            prop["maxLength"] = int(max_len)
+    ge = getattr(field_info, "ge", None)
+    le = getattr(field_info, "le", None)
+    gt = getattr(field_info, "gt", None)
+    lt = getattr(field_info, "lt", None)
+    if prop.get("type") in {"integer", "float", "number"}:
+        if ge is not None:
+            prop["minimum"] = float(ge)
+        elif gt is not None:
+            prop["minimum"] = float(gt)
+        if le is not None:
+            prop["maximum"] = float(le)
+        elif lt is not None:
+            prop["maximum"] = float(lt)
+    if prop.get("type") == "array":
+        items = prop.get("items", {})
+        if items.get("type") == "string":
+            if min_len is not None:
+                items["minLength"] = int(min_len)
+            if max_len is not None:
+                items["maxLength"] = int(max_len)
+        if items.get("type") in {"integer", "float", "number"}:
+            if ge is not None:
+                items["minimum"] = float(ge)
+            elif gt is not None:
+                items["minimum"] = float(gt)
+            if le is not None:
+                items["maximum"] = float(le)
+            elif lt is not None:
+                items["maximum"] = float(lt)
+        prop["items"] = items
+
+
+def emit_json_shape(model_cls: Optional[Type[BaseModel]]) -> Dict[str, Any]:
+    if not model_cls:
+        return {"properties": {}}
+
+    # Pydantic v2 vs v1 compatibility
+    if hasattr(model_cls, "model_fields"):
+        fields = model_cls.model_fields  # type: ignore[attr-defined]
+        def _iter_fields():
+            for name, f in fields.items():
+                yield name, getattr(f, "annotation", Any), f
+        is_required = lambda f: getattr(f, "is_required", lambda: getattr(f, "required", False))()
+        get_info = lambda f: getattr(f, "field_info", f)
+    else:
+        fields = getattr(model_cls, "__fields__", {})  # type: ignore[assignment]
+        def _iter_fields():
+            for name, f in fields.items():
+                yield name, getattr(f, "type_", Any), f
+        is_required = lambda f: getattr(f, "required", False)
+        get_info = lambda f: getattr(f, "field_info", f)
+
+    props: Dict[str, Any] = {}
+    req: List[str] = []
+    for name, ann, f in _iter_fields():
+        prop = _map_type_json(ann)
+        info = get_info(f)
+        desc = getattr(info, "description", None)
+        if desc:
+            prop["description"] = desc
+        _json_constraints(prop, info)
+        # Alias support
+        alias = getattr(info, "alias", None)
+        json_name = alias or name
+        props[json_name] = prop
+        if is_required(f):
+            req.append(json_name)
+    out: Dict[str, Any] = {"properties": props}
+    if req:
+        out["required"] = req
+    return out
+
+
+def emit_flat_shape(model_cls: Optional[Type[BaseModel]]) -> Dict[str, Any]:
+    if not model_cls:
+        return {}
+
+    if hasattr(model_cls, "model_fields"):
+        fields = model_cls.model_fields  # type: ignore[attr-defined]
+        def _iter_fields():
+            for name, f in fields.items():
+                yield name, getattr(f, "annotation", Any), f
+        is_required = lambda f: getattr(f, "is_required", lambda: getattr(f, "required", False))()
+        get_info = lambda f: getattr(f, "field_info", f)
+    else:
+        fields = getattr(model_cls, "__fields__", {})
+        def _iter_fields():
+            for name, f in fields.items():
+                yield name, getattr(f, "type_", Any), f
+        is_required = lambda f: getattr(f, "required", False)
+        get_info = lambda f: getattr(f, "field_info", f)
+
+    props: Dict[str, Any] = {}
+    for name, ann, f in _iter_fields():
+        v = _map_type_json(ann)
+        direct: Dict[str, Any] = {"type": v.get("type", "string")}
+        info = get_info(f)
+        desc = getattr(info, "description", None)
+        if desc:
+            direct["description"] = desc
+        # For arrays promote element type, mark isArray
+        if v.get("type") == "array":
+            items = v.get("items", {})
+            direct["type"] = items.get("type", "string")
+            direct["isArray"] = True
+        # Constraints minimal set
+        min_len = getattr(info, "min_length", None)
+        max_len = getattr(info, "max_length", None)
+        if min_len is not None:
+            direct["minLength"] = int(min_len)
+        if max_len is not None:
+            direct["maxLength"] = int(max_len)
+        ge = getattr(info, "ge", None)
+        le = getattr(info, "le", None)
+        if ge is not None:
+            direct["minimum"] = float(ge)
+        if le is not None:
+            direct["maximum"] = float(le)
+        if is_required(f):
+            direct["required"] = True
+        alias = getattr(info, "alias", None)
+        json_name = alias or name
+        props[json_name] = direct
+    return props
+
+
+def build_schemas(in_model: Optional[Type[BaseModel]], out_model: Optional[Type[BaseModel]]):
+    return emit_json_shape(in_model), emit_json_shape(out_model)
+
+

agentruntime_mcp-0.0.1/src/agentruntime_mcp.egg-info/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: agentruntime-mcp
+Version: 0.0.1
+Summary: AgentRuntime MCP SDK (decorators, runtime, middleware, schemas, proxy, generators)
+Author: AgentRuntime
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastmcp
+Requires-Dist: pydantic>=2
+Requires-Dist: starlette>=0.37
+Requires-Dist: uvicorn[standard]>=0.30
+Requires-Dist: opentelemetry-api>=1.25
+Requires-Dist: opentelemetry-sdk>=1.25
+Requires-Dist: opentelemetry-exporter-otlp>=1.25
+Requires-Dist: PyYAML>=6
+Requires-Dist: httpx>=0.25
+
+# AgentRuntime MCP SDK (Python)
+
+Opinionated SDK for building MCP agents with FastMCP.
+
+## Install
+```bash
+pip install agentruntime-mcp
+```
+
+## Minimal example
+```python
+from pydantic import BaseModel, Field
+from agentruntime.mcp.decorators import tool
+from agentruntime.mcp.runtime import run
+
+class In(BaseModel):
+    a: float = Field(...)
+    b: float = Field(...)
+
+class Out(BaseModel):
+    result: float
+    expression: str
+
+@tool(name="add", input_model=In, output_model=Out)
+def add(a: float, b: float) -> Out:
+    return Out(result=a+b, expression=f"{a} + {b}")
+
+if __name__ == "__main__":
+    run("config.yaml")
+```
+
+## Config
+- `config.yaml` controls server host/port, auth mode, and tracing.  
+- Env overrides: `HOST`, `PORT`, `MCP_AUTH_MODE`.
+
+Auth modes
+- `none`: no auth
+- `token`: `Authorization: Bearer <token>` or `X-MCP-Token`; dev fallback `?auth_token=` if `ALLOW_QUERY_TOKEN=true`
+- `hmac`: headers `X-MCP-KeyId`, `X-MCP-Timestamp` (unix seconds), `X-MCP-Signature` (hex(HMAC-SHA256(secret, `${ts}\n${method}\n${path}`)))
+
+## Proxy (library)
+```python
+from agentruntime.mcp.proxy import run_proxy
+run_proxy(target_url="http://127.0.0.1:8000/mcp", overlay_file="tools.yaml", host="127.0.0.1", port=8010)
+```

agentruntime_mcp-0.0.1/src/agentruntime_mcp.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/agentruntime/__init__.py
+src/agentruntime/mcp/__init__.py
+src/agentruntime/mcp/decorators.py
+src/agentruntime/mcp/middleware.py
+src/agentruntime/mcp/proxy.py
+src/agentruntime/mcp/runtime.py
+src/agentruntime/mcp/schemas.py
+src/agentruntime/mcp/generators/openapi_to_mcp.py
+src/agentruntime_mcp.egg-info/PKG-INFO
+src/agentruntime_mcp.egg-info/SOURCES.txt
+src/agentruntime_mcp.egg-info/dependency_links.txt
+src/agentruntime_mcp.egg-info/requires.txt
+src/agentruntime_mcp.egg-info/top_level.txt

agentruntime_mcp-0.0.1/src/agentruntime_mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agentruntime_mcp-0.0.1/src/agentruntime_mcp.egg-info/requires.txt

@@ -0,0 +1,9 @@
+fastmcp
+pydantic>=2
+starlette>=0.37
+uvicorn[standard]>=0.30
+opentelemetry-api>=1.25
+opentelemetry-sdk>=1.25
+opentelemetry-exporter-otlp>=1.25
+PyYAML>=6
+httpx>=0.25

agentruntime_mcp-0.0.1/src/agentruntime_mcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+agentruntime