@macaw-ai/client 0.0.0-stage → 0.9.10

package/payload/secureAI/examples/mcp/2f_proxy_stdio_databricks.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""
+Example: SecureMCPProxy with Databricks MCP Server (stdio transport)
+
+Demonstrates SecureMCPProxy connecting to Databricks via stdio transport.
+This uses the community databricks-mcp-server package.
+
+Security Model:
+- MACAW creates AuthenticatedContext for EACH invocation
+- Even with persistent subprocess, each call gets fresh identity/policy/signature
+- Databricks operations are policy-enforced and audited
+
+Prerequisites:
+    1. Databricks account with PAT token
+    2. pip install databricks-mcp-server
+    3. Environment variables:
+       export DATABRICKS_HOST="https://your-workspace.cloud.databricks.com"
+       export DATABRICKS_TOKEN="dapi..."
+    4. MACAW: pip install macaw-adapters[mcp-proxy]
+
+Usage:
+    python 2g_proxy_stdio_databricks.py
+"""
+
+import os
+import sys
+import shutil
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def main():
+    """Test SecureMCPProxy with Databricks MCP (stdio)."""
+    from macaw_adapters.mcp import SecureMCPProxy
+
+    print("=" * 60)
+    print("SecureMCPProxy + Databricks MCP (stdio)")
+    print("=" * 60)
+
+    # Step 1: Check prerequisites
+    print("\n1. Checking prerequisites...")
+
+    # Check uvx/databricks-mcp-server
+    if not shutil.which("uvx"):
+        print("   ERROR: uvx not found")
+        print("   Fix: pip install uv")
+        return 1
+    print("   OK: uvx found")
+
+    # Check environment variables
+    host = os.environ.get("DATABRICKS_HOST", "")
+    token = os.environ.get("DATABRICKS_TOKEN", "")
+
+    if not host or not token:
+        print("   ERROR: DATABRICKS_HOST and DATABRICKS_TOKEN required")
+        print("   Fix:")
+        print('     export DATABRICKS_HOST="https://your-workspace.cloud.databricks.com"')
+        print('     export DATABRICKS_TOKEN="dapi..."')
+        return 1
+    print(f"   OK: DATABRICKS_HOST={host[:40]}...")
+    print("   OK: DATABRICKS_TOKEN=dapi***")
+
+    # Step 2: Create proxy with stdio transport
+    print("\n2. Creating SecureMCPProxy with Databricks stdio...")
+    try:
+        proxy = SecureMCPProxy(
+            app_name="databricks-stdio",
+            command=["uvx", "databricks-mcp-server@latest"],
+            env={
+                "DATABRICKS_HOST": host,
+                "DATABRICKS_TOKEN": token,
+                "HOME": os.environ.get("HOME", ""),
+                "PATH": os.environ.get("PATH", ""),
+            }
+        )
+        print(f"   OK: {proxy}")
+    except ConnectionError as e:
+        print(f"   ERROR: Failed to connect: {e}")
+        print("\n   Troubleshooting:")
+        print("   1. Install: pip install databricks-mcp-server")
+        print("   2. Or run directly: uvx databricks-mcp-server@latest --help")
+        return 1
+    except Exception as e:
+        print(f"   ERROR: {e}")
+        return 1
+
+    # Step 3: Discover tools
+    print("\n3. Discovering Databricks tools...")
+    tools = proxy.list_tools()
+    print(f"   Found {len(tools)} tools:")
+    for tool in tools[:10]:  # Show first 10
+        desc = tool.get('description', '')[:50]
+        print(f"   - {tool['name']}: {desc}...")
+    if len(tools) > 10:
+        print(f"   ... and {len(tools) - 10} more")
+
+    if not tools:
+        print("   ERROR: No tools discovered")
+        return 1
+
+    # Step 4: Test a tool call
+    print("\n4. Testing tool call...")
+
+    # Try to find a simple query tool
+    tool_names = [t['name'] for t in tools]
+
+    # Common tool names in databricks-mcp-server
+    test_tools = ['execute_query', 'run_query', 'list_catalogs', 'list_schemas']
+
+    for test_tool in test_tools:
+        if test_tool in tool_names:
+            print(f"   Found tool: {test_tool}")
+            try:
+                if 'query' in test_tool:
+                    result = proxy.call_tool(test_tool, {
+                        "query": "SELECT current_user()"
+                    })
+                else:
+                    result = proxy.call_tool(test_tool, {})
+
+                content = result.get('result', result) if isinstance(result, dict) else result
+                preview = str(content)[:200]
+                print(f"   OK: {preview}...")
+                break
+            except Exception as e:
+                print(f"   Tool {test_tool} error: {e}")
+    else:
+        print("   Skipping tool call - no known test tool found")
+        print(f"   Available: {tool_names[:5]}...")
+
+    print("\n" + "=" * 60)
+    print("SUCCESS: SecureMCPProxy Databricks stdio works!")
+    print("=" * 60)
+    print("\nKey points:")
+    print("  - stdio transport to databricks-mcp-server")
+    print("  - Same credentials as HTTP (DATABRICKS_HOST/TOKEN)")
+    print("  - MACAW policy enforcement on all calls")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/payload/secureAI/examples/mcp/3a_native_mcp_client.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""
+3a_native_mcp_client.py - A vanilla MCP client talking to SecureMCP
+
+This client knows NOTHING about MACAW. It has no macaw imports, no agent
+registration, no target_agent, no LocalAgent. It is the same code you would write
+against any MCP server, and it is what Claude Desktop / Cursor do internally.
+
+It still gets full MACAW enforcement, because the server's run(transport="stdio")
+turns every JSON-RPC call into the same invoke_tool() a MACAW client would make:
+
+    this client --JSON-RPC--> calculator's MCP endpoint
+                                  |
+                                  +--> invoke_tool --> LocalAgent --> PEP --> add()
+                                            policy . signing . audit
+
+Prerequisites:
+    - MACAW LocalAgent running
+    - pip install mcp
+
+Run:
+    python 3a_native_mcp_client.py
+
+    (this spawns securemcp_calculator.py itself - no separate terminal needed)
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+SERVER = Path(__file__).parent / "securemcp_calculator.py"
+
+
+def field(obj, *names):
+    """Read an SDK field by whichever name this mcp version uses.
+
+    MCP 2026-07-28 renamed result fields from camelCase to snake_case
+    (serverInfo -> server_info). A real client targets one SDK and just uses
+    that spelling; this example runs against both.
+    """
+    return next((getattr(obj, n) for n in names if hasattr(obj, n)), None)
+
+
+async def main() -> int:
+    print("=" * 60)
+    print("Vanilla MCP client -> SecureMCP calculator")
+    print("=" * 60)
+
+    params = StdioServerParameters(
+        command=sys.executable,
+        args=[str(SERVER), "stdio"],
+    )
+
+    async with stdio_client(params) as (read_stream, write_stream):
+        async with ClientSession(read_stream, write_stream) as session:
+
+            # 1. Handshake
+            init = await session.initialize()
+            info = field(init, "server_info", "serverInfo")
+            print(f"\nConnected to: {info.name} v{info.version}")
+            print(f"Protocol: {field(init, 'protocol_version', 'protocolVersion')}")
+
+            # 2. Discovery - comes straight off the MACAW tool registry
+            listed = await session.list_tools()
+            print(f"\nDiscovered {len(listed.tools)} tools:")
+            for tool in listed.tools:
+                schema = field(tool, "input_schema", "inputSchema") or {}
+                required = schema.get("required", [])
+                print(f"  - {tool.name}({', '.join(required)}): {tool.description}")
+
+            # 3. Call tools - each one goes through the MACAW PEP
+            print("\nCalls (each policy-checked, signed, audited):")
+            for tool_name, args in [
+                ("add", {"a": 10, "b": 5}),
+                ("subtract", {"a": 100, "b": 42}),
+                ("multiply", {"a": 7, "b": 8}),
+                ("divide", {"a": 100, "b": 4}),
+            ]:
+                result = await session.call_tool(tool_name, args)
+                shown = ", ".join(f"{k}={v}" for k, v in args.items())
+                print(f"  {tool_name}({shown}) = {result.content[0].text}")
+
+            # 4. A tool that uses Context (vault + audit) - works unchanged
+            result = await session.call_tool(
+                "calculate", {"operation": "add", "a": 10, "b": 3}
+            )
+            print(f"  calculate(add, 10, 3) = {result.content[0].text}")
+
+    print("\n" + "=" * 60)
+    print("Done - and this file contains no MACAW code at all.")
+    print("=" * 60)
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(asyncio.run(main()))
+    except Exception as e:
+        print(f"\nERROR: {e}")
+        print("\nCheck that the MACAW LocalAgent is running.")
+        sys.exit(1)

package/payload/secureAI/examples/mcp/3b_native_mcp_proxy.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""
+3b_native_mcp_proxy.py - A vanilla MCP client talking THROUGH SecureMCPProxy
+
+The "we don't have the code" case. mcp_server_fetch is a third-party MCP server
+we don't control. Put it behind SecureMCPProxy and every call is policy-checked,
+signed, and audited - and the client can't tell the difference:
+
+    this client --JSON-RPC--> proxy.run()
+                                  |
+                                  +--> invoke_tool --> LocalAgent --> PEP
+                                                                       |
+                                                    proxy handler --> mcp_server_fetch
+                                                        (stdio)             |
+                                                                        the web
+
+This is the drop-in story: in a Claude Desktop config you point at this proxy
+instead of at mcp_server_fetch, and nothing else changes.
+
+Prerequisites:
+    - MACAW LocalAgent running
+    - pip install mcp mcp-server-fetch
+    - Policy allowing: tool:fetch-test/fetch
+
+Run:
+    python 3b_native_mcp_proxy.py
+
+    (this spawns the proxy itself - no separate terminal needed)
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+
+def field(obj, *names):
+    """Read an SDK field by whichever name this mcp version uses.
+
+    MCP 2026-07-28 renamed result fields from camelCase to snake_case
+    (serverInfo -> server_info). A real client targets one SDK and just uses
+    that spelling; this example runs against both.
+    """
+    return next((getattr(obj, n) for n in names if hasattr(obj, n)), None)
+
+
+APP_NAME = "fetch-test"
+
+# The proxy process this client spawns. Two lines of real code:
+#     SecureMCPProxy(app_name=..., command=[...]).run()
+# In a Claude Desktop config, this is what "command"/"args" would point at.
+RUNNER = f'''
+import sys
+from macaw_adapters.mcp import SecureMCPProxy
+SecureMCPProxy(
+    app_name="{APP_NAME}",
+    command=[sys.executable, "-m", "mcp_server_fetch"],
+).run(transport="stdio")
+'''
+
+
+async def main() -> int:
+    print("=" * 60)
+    print("Vanilla MCP client -> SecureMCPProxy -> mcp_server_fetch")
+    print("=" * 60)
+
+    params = StdioServerParameters(command=sys.executable, args=["-c", RUNNER])
+
+    async with stdio_client(params) as (read_stream, write_stream):
+        async with ClientSession(read_stream, write_stream) as session:
+
+            init = await session.initialize()
+            print(f"\nConnected to: {field(init, 'server_info', 'serverInfo').name}")
+
+            # Discovery passes upstream's schema through untouched - the proxy
+            # never had to know what a "fetch" tool looks like.
+            listed = await session.list_tools()
+            print(f"\nDiscovered {len(listed.tools)} tools (schemas from upstream):")
+            for tool in listed.tools:
+                schema = field(tool, "input_schema", "inputSchema") or {}
+                props = list(schema.get("properties", {}).keys())
+                print(f"  - {tool.name}({', '.join(props)})")
+                print(f"    {(tool.description or '')[:70]}...")
+
+            print("\nCall (policy-checked, signed, audited, then forwarded upstream):")
+            print("-" * 60)
+            result = await session.call_tool("fetch", {"url": "https://example.com"})
+            preview = result.content[0].text[:180].replace("\n", " ")
+            print(f"  fetch(https://example.com) -> {preview}...")
+
+    print("\n" + "=" * 60)
+    print("Done - upstream is untouched, this client has no MACAW code,")
+    print("and MACAW enforced every call in between.")
+    print("=" * 60)
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        import mcp_server_fetch  # noqa: F401
+    except ImportError:
+        print("ERROR: mcp-server-fetch not installed")
+        print("Fix: pip install mcp-server-fetch")
+        sys.exit(1)
+
+    try:
+        sys.exit(asyncio.run(main()))
+    except Exception as e:
+        print(f"\nERROR: {e}")
+        print("\nCheck that the MACAW LocalAgent is running, and that policy")
+        print(f"allows: tool:{APP_NAME}/fetch")
+        sys.exit(1)

package/payload/secureAI/examples/mcp/3c_native_mcp_sampling.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+"""
+3c_native_mcp_sampling.py - MCP Sampling through the native endpoint
+
+The duplex test. A vanilla MCP client (no MACAW code) calls a SecureMCP tool,
+and that tool calls back OUT to this client's LLM via ctx.sample():
+
+    this client --tools/call--> sampling-demo's MCP endpoint
+                                     |
+                                     +--> invoke_tool --> PEP --> summarize()
+                                                                      |
+                                                            ctx.sample()
+                                                                      |
+                              +--- invoke_tool("_mcp_sample") <-------+
+                              |         (over the MACAW bus)
+                              v
+                       the endpoint's stub agent
+                              |
+                              +--- sampling/createMessage --> this client's callback
+                                                                      |
+                                                              Anthropic API
+                                                                      |
+    summary <---------------------------------------------------------+
+
+Both directions cross the boundary: the request goes in over JSON-RPC and down
+through the MACAW PEP; the LLM callback comes back out over the same JSON-RPC
+session. This is the same _mcp_sample mechanism 1e_sampling_client.py uses over
+the bus - the only difference is that the stub forwards it over MCP instead of
+calling an LLM directly.
+
+Prerequisites:
+    - MACAW LocalAgent running
+    - pip install mcp anthropic
+    - ANTHROPIC_API_KEY set (this is the client's LLM - the whole point of sampling)
+
+Run:
+    export ANTHROPIC_API_KEY=sk-ant-...
+    python 3c_native_mcp_sampling.py
+
+    (this spawns 1e_sampling_server.py itself - no separate terminal needed)
+"""
+
+import asyncio
+import os
+import sys
+from pathlib import Path
+
+import anthropic
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+import mcp.types as types
+
+SERVER = Path(__file__).parent / "1e_sampling_server.py"
+MODEL = "claude-opus-4-8"
+
+
+def field(obj, *names):
+    """Read an SDK field by whichever name this mcp version uses.
+
+    MCP 2026-07-28 renamed result fields from camelCase to snake_case
+    (serverInfo -> server_info). A real client targets one SDK and just uses
+    that spelling; this example runs against both.
+    """
+    return next((getattr(obj, n) for n in names if hasattr(obj, n)), None)
+
+llm = anthropic.Anthropic()
+
+
+async def sampling_callback(
+    # The callback shape is (context, params) on every mcp version; only the
+    # context type moved (RequestContext on mcp<2, ClientRequestContext on
+    # mcp>=2), and it is unused here, so it is left unannotated.
+    context,
+    params: types.CreateMessageRequestParams,
+) -> types.CreateMessageResult | types.ErrorData:
+    """Serve the server's ctx.sample() request using THIS client's LLM.
+
+    This is the client half of MCP sampling: the server has no model of its own,
+    so it borrows ours. Nothing here knows about MACAW.
+    """
+    prompt = "\n".join(
+        block.text for m in params.messages
+        if (block := m.content).type == "text"
+    )
+    print(f"  [LLM] <- server asked: {prompt[:70]}...")
+
+    def call(**extra):
+        return llm.messages.create(
+            model=MODEL,
+            max_tokens=field(params, "max_tokens", "maxTokens"),
+            system=field(params, "system_prompt", "systemPrompt")
+            or "You are a helpful assistant.",
+            messages=[{"role": "user", "content": prompt}],
+            **extra,
+        )
+
+    # Forward a temperature only if the tool asked for one, and don't assume whether
+    # this model takes it - try, and fall back if it doesn't. Current Claude models
+    # (Opus 4.8/4.7, Sonnet 5, Fable 5) reject temperature/top_p/top_k with a 400;
+    # older ones accept it. MCP treats sampling params as hints a client may ignore,
+    # so degrading beats failing the call over one.
+    extra = {} if params.temperature is None else {"temperature": params.temperature}
+    try:
+        try:
+            response = call(**extra)
+        except anthropic.BadRequestError:
+            if not extra:
+                raise
+            print(f"  [LLM] {MODEL} rejected temperature={params.temperature}; retrying without")
+            response = call()
+    except anthropic.APIStatusError as e:
+        return types.ErrorData(code=types.INTERNAL_ERROR, message=str(e))
+
+    text = next((b.text for b in response.content if b.type == "text"), "")
+    print(f"  [LLM] -> answered: {text[:70]}...")
+
+    return types.CreateMessageResult(
+        role="assistant",
+        content=types.TextContent(type="text", text=text),
+        model=response.model,
+        stopReason="endTurn",
+    )
+
+
+async def main() -> int:
+    print("=" * 60)
+    print("Vanilla MCP client + sampling -> SecureMCP")
+    print("=" * 60)
+
+    params = StdioServerParameters(command=sys.executable, args=[str(SERVER), "stdio"])
+
+    async with stdio_client(params) as (read_stream, write_stream):
+        async with ClientSession(
+            read_stream, write_stream, sampling_callback=sampling_callback
+        ) as session:
+            init = await session.initialize()
+            print(f"\nConnected to: {field(init, 'server_info', 'serverInfo').name}")
+
+            listed = await session.list_tools()
+            print(f"Tools: {[t.name for t in listed.tools]}\n")
+
+            print("summarize() - the tool will call back to our LLM:")
+            print("-" * 60)
+            result = await session.call_tool("summarize", {
+                "text": (
+                    "MACAW places a policy enforcement point between an agent and the "
+                    "tools it calls. Every invocation is checked against policy, signed, "
+                    "and written to an audit log, so a non-deterministic model still "
+                    "produces deterministic, reviewable actions."
+                ),
+                "max_length": 40,
+            })
+            print(f"  RESULT: {result.content[0].text}\n")
+
+            print("analyze_sentiment() - same round trip:")
+            print("-" * 60)
+            result = await session.call_tool("analyze_sentiment", {
+                "text": "I love this product! It's amazing and works perfectly!"
+            })
+            print(f"  RESULT: {result.content[0].text}")
+
+    print("\n" + "=" * 60)
+    print("Done - request in over MCP, LLM callback back out over MCP,")
+    print("policy and audit in the middle. No MACAW code in this file.")
+    print("=" * 60)
+    return 0
+
+
+if __name__ == "__main__":
+    if not os.environ.get("ANTHROPIC_API_KEY"):
+        print("ERROR: ANTHROPIC_API_KEY is not set.")
+        print("Sampling means the SERVER borrows THIS client's LLM, so a real key")
+        print("is required - there is no mock path in this example by design.")
+        sys.exit(1)
+    try:
+        sys.exit(asyncio.run(main()))
+    except Exception as e:
+        print(f"\nERROR: {e}")
+        print("\nCheck that the MACAW LocalAgent is running.")
+        sys.exit(1)

package/payload/secureAI/examples/mcp/3d_native_mcp_2026.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""
+Example 3d: MCP 2026-07-28 by hand - no client library at all.
+
+MCP revision 2026-07-28 made the protocol stateless. There is no initialize
+handshake and no Mcp-Session-Id: every request carries its own protocol version
+and client capabilities in _meta, and servers answer server/discover to advertise
+what they speak.
+
+That is a good fit for MACAW, because MACAW never had connection state to lose.
+Identity, policy, and the signature travel with each invocation, not with a
+session - which is exactly what the spec moved toward.
+
+This client is plain HTTP. No mcp package, no ClientSession, no handshake:
+
+    this file --POST /mcp--> SecureMCP --invoke_tool--> LocalAgent --> PEP --> tool
+
+Every call below is still policy-checked, signed, and audited, because the wire
+format has nothing to do with where enforcement happens.
+
+Run:
+    # terminal 1 - requires mcp>=2
+    python3 securemcp_calculator.py http
+
+    # terminal 2
+    python3 3d_native_mcp_2026.py
+"""
+
+import json
+import sys
+import urllib.error
+import urllib.request
+
+URL = "http://127.0.0.1:8080/mcp"
+PROTOCOL = "2026-07-28"
+
+# Reserved _meta keys. Every request self-describes; there is no handshake to
+# establish them once.
+PROTOCOL_VERSION = "io.modelcontextprotocol/protocolVersion"
+CLIENT_INFO = "io.modelcontextprotocol/clientInfo"
+CLIENT_CAPABILITIES = "io.modelcontextprotocol/clientCapabilities"
+
+
+def rpc(method: str, params: dict | None = None, name: str | None = None) -> dict:
+    """One stateless JSON-RPC call. No session, no prior state."""
+    body = {
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": method,
+        "params": {
+            **(params or {}),
+            "_meta": {
+                PROTOCOL_VERSION: PROTOCOL,
+                CLIENT_INFO: {"name": "raw-http-demo", "version": "1.0"},
+                CLIENT_CAPABILITIES: {},
+            },
+        },
+    }
+    headers = {
+        "Content-Type": "application/json",
+        "Accept": "application/json, text/event-stream",
+        # Selects the 2026-07-28 era. Without it the server answers the older
+        # session-based revision for backward compatibility.
+        "MCP-Protocol-Version": PROTOCOL,
+        "Mcp-Method": method,
+    }
+    if name:
+        headers["Mcp-Name"] = name
+
+    req = urllib.request.Request(URL, json.dumps(body).encode(), headers)
+    with urllib.request.urlopen(req, timeout=30) as resp:
+        session_id = resp.headers.get("mcp-session-id")
+        text = resp.read().decode()
+
+    # Responses may arrive as a one-event SSE stream.
+    if text.startswith("event:"):
+        text = "".join(l[6:] for l in text.splitlines() if l.startswith("data: "))
+
+    payload = json.loads(text)
+    if "error" in payload:
+        raise RuntimeError(f"{method}: {payload['error']}")
+    return {"result": payload["result"], "session_id": session_id}
+
+
+def main() -> int:
+    print("=" * 60)
+    print(f"Raw HTTP client -> SecureMCP, protocol {PROTOCOL}")
+    print("=" * 60)
+
+    # 1. Discovery. Replaces the initialize handshake: ask what the server speaks.
+    d = rpc("server/discover")
+    discover, session_id = d["result"], d["session_id"]
+    print(f"\nserver/discover  (session id: {session_id or 'none - stateless'})")
+    print(f"  supportedVersions : {discover['supportedVersions']}")
+    print(f"  capabilities      : {discover['capabilities']}")
+    print(f"  serverInfo        : {discover['_meta'][ 'io.modelcontextprotocol/serverInfo']}")
+
+    # 2. Tools. ttlMs/cacheScope are the server's caching contract with the client.
+    listed = rpc("tools/list")["result"]
+    print("\ntools/list")
+    print(f"  resultType        : {listed['resultType']}")
+    print(f"  ttlMs / cacheScope: {listed['ttlMs']} / {listed['cacheScope']}")
+    print("     ttlMs=0 means do not cache. Which tools exist is an authorization")
+    print("     answer, and a cached authorization answer is a stale one.")
+    print(f"  tools             : {', '.join(t['name'] for t in listed['tools'])}")
+
+    # 3. Calls. Each one is a fresh, self-describing request - and each one is
+    #    policy-checked, signed, and audited by MACAW on the way through.
+    print("\ntools/call (each policy-checked, signed, audited)")
+    for tool, args in [
+        ("add", {"a": 10, "b": 5}),
+        ("divide", {"a": 100, "b": 4}),
+        ("calculate", {"operation": "add", "a": 10, "b": 3}),
+    ]:
+        out = rpc("tools/call", {"name": tool, "arguments": args}, name=tool)["result"]
+        shown = ", ".join(f"{k}={v}" for k, v in args.items())
+        print(f"  {tool}({shown}) = {out['content'][0]['text']}")
+
+    print("\n" + "=" * 60)
+    print("No handshake, no session, no MCP library - and still fully enforced.")
+    print("=" * 60)
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except urllib.error.URLError as e:
+        print(f"\nERROR: cannot reach {URL} ({e})")
+        print("Start the server first:  python3 securemcp_calculator.py http")
+        print("2026-07-28 requires mcp>=2 - check with: pip show mcp")
+        sys.exit(1)
+    except RuntimeError as e:
+        print(f"\nERROR: {e}")
+        sys.exit(1)