@ateam-ai/mcp 0.1.0

package/.env.example

@@ -0,0 +1,3 @@
+ADAS_API_URL=https://api.ateam-ai.com
+ADAS_TENANT=main
+ADAS_API_KEY=your-api-key-here

package/README.md

@@ -0,0 +1,172 @@
+# ateam-mcp
+
+**Give any AI the ability to build, validate, and deploy production multi-agent systems.**
+
+This is an MCP server that connects AI assistants — ChatGPT, Claude, Gemini, Copilot, Cursor, Windsurf, and any MCP-compatible environment — directly to the [ADAS](https://ateam-ai.com) platform.
+
+An AI developer says *"Build me a customer support system with order tracking and escalation"* — and their AI assistant handles the entire lifecycle: reads the spec, builds skill definitions, validates them, deploys to production, and verifies health. No manual JSON authoring, no docs reading, no copy-paste workflows.
+
+## Why this matters
+
+Today, building multi-agent systems requires deep platform knowledge, manual configuration, and switching between docs, editors, and dashboards. **ateam-mcp eliminates all of that** by making the ADAS platform a native capability of the AI tools developers already use.
+
+The AI assistant becomes the developer interface:
+
+```
+Developer: "Create an identity verification agent that checks documents,
+            validates faces, and escalates fraud cases"
+
+AI Assistant:
+  → reads ADAS spec (adas_get_spec)
+  → studies working examples (adas_get_examples)
+  → builds skill + solution definitions
+  → validates iteratively (adas_validate_skill, adas_validate_solution)
+  → deploys to production (adas_deploy_solution)
+  → verifies everything is running (adas_get_solution → health)
+
+Developer: "Add a new skill that handles address verification"
+
+AI Assistant:
+  → deploys into the existing solution (adas_deploy_skill)
+  → redeploys (adas_redeploy)
+  → confirms health
+```
+
+No context switching. No manual steps. The full ADAS platform — specs, validation, deployment, monitoring — is available as natural language.
+
+## How it reaches the AI community
+
+### ChatGPT users
+
+ChatGPT supports MCP connectors in Developer Mode. Users connect by pasting a single URL:
+
+**Settings → Connectors → Developer Mode → paste `https://mcp.ateam-ai.com`**
+
+That's it. All 12 ADAS tools appear in ChatGPT. Any ChatGPT Pro, Plus, Business, or Enterprise user can build and deploy multi-agent solutions through conversation.
+
+### Claude users
+
+**Claude Desktop** — install as an extension (one-click) or add to config:
+
+```json
+{
+  "mcpServers": {
+    "ateam": {
+      "command": "npx",
+      "args": ["-y", "@ateam-ai/mcp"],
+      "env": {
+        "ADAS_TENANT": "your-tenant",
+        "ADAS_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+**Claude Code** — one command:
+
+```bash
+claude mcp add ateam -- npx -y @ateam-ai/mcp
+```
+
+### Cursor / Windsurf / VS Code (Copilot)
+
+Add to `.cursor/mcp.json`, `mcp_config.json`, or `.vscode/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "ateam": {
+      "command": "npx",
+      "args": ["-y", "@ateam-ai/mcp"],
+      "env": {
+        "ADAS_TENANT": "your-tenant",
+        "ADAS_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+### Gemini and other platforms
+
+As MCP adoption grows (it's now governed by the Agentic AI Foundation under the Linux Foundation, co-founded by Anthropic, OpenAI, and Block), every AI platform that implements MCP gets access to ateam-mcp automatically. The remote HTTP endpoint (`https://mcp.ateam-ai.com`) works with any client that supports Streamable HTTP transport.
+
+### Discovery
+
+Developers find ateam-mcp through:
+
+- **npm** — `npm search mcp ai-agents` → `@ateam-ai/mcp`
+- **Official MCP Registry** — registry.modelcontextprotocol.io
+- **Claude Desktop Extensions** — built-in extension browser
+- **Claude Code Plugin Marketplace** — `/plugin` → Discover tab
+- **Windsurf MCP Marketplace** — built-in marketplace
+- **VS Code MCP Gallery** — Extensions view
+- **Community directories** — Smithery, mcp.so, PulseMCP (30,000+ combined listings)
+
+## Available tools
+
+| Tool | What it does |
+|---|---|
+| `adas_get_spec` | Read the ADAS specification — skill schema, solution architecture, enums, agent guides |
+| `adas_get_examples` | Get complete working examples — skills, connectors, solutions |
+| `adas_validate_skill` | Validate a skill definition through the 5-stage pipeline |
+| `adas_validate_solution` | Validate a solution — cross-skill contracts + quality scoring |
+| `adas_deploy_solution` | Deploy a complete solution to production |
+| `adas_deploy_skill` | Add a skill to an existing solution |
+| `adas_deploy_connector` | Deploy a connector to ADAS Core |
+| `adas_list_solutions` | List all deployed solutions |
+| `adas_get_solution` | Inspect a solution — definition, skills, health, status, export |
+| `adas_update` | Update a solution or skill incrementally (PATCH) |
+| `adas_redeploy` | Push changes live — regenerates MCP servers, deploys to ADAS Core |
+| `adas_solution_chat` | Talk to the Solution Bot for guided modifications |
+
+## Setup
+
+```bash
+# Clone
+git clone https://github.com/ariekogan/ateam-mcp.git
+cd ateam-mcp
+
+# Install
+npm install
+
+# Configure
+cp .env.example .env
+# Edit .env with your ADAS tenant and API key
+
+# Run
+npm start
+```
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────┐
+│  AI Environment                             │
+│  (ChatGPT / Claude / Cursor / Windsurf)     │
+│                                             │
+│  Developer: "build me a support system"     │
+└──────────────────┬──────────────────────────┘
+                   │ MCP protocol
+                   │ (stdio or HTTP)
+┌──────────────────▼──────────────────────────┐
+│  ateam-mcp                                  │
+│  12 tools — spec, validate, deploy, manage  │
+└──────────────────┬──────────────────────────┘
+                   │ HTTPS
+                   │ X-ADAS-TENANT / X-API-KEY
+┌──────────────────▼──────────────────────────┐
+│  ADAS External Agent API                    │
+│  api.ateam-ai.com                           │
+└──────────────────┬──────────────────────────┘
+                   │
+┌──────────────────▼──────────────────────────┐
+│  ADAS Core                                  │
+│  Multi-agent runtime                        │
+└─────────────────────────────────────────────┘
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@ateam-ai/mcp",
+  "version": "0.1.0",
+  "description": "ADAS MCP Server — build, validate, and deploy multi-agent solutions from any AI environment",
+  "type": "module",
+  "bin": {
+    "ateam-mcp": "./src/index.js"
+  },
+  "main": "./src/index.js",
+  "scripts": {
+    "start": "node src/index.js",
+    "start:http": "node src/index.js --http",
+    "dev": "node --watch src/index.js",
+    "dev:http": "node --watch src/index.js --http"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "adas",
+    "ai-agents",
+    "multi-agent",
+    "mcp-server"
+  ],
+  "author": "A-Team AI",
+  "license": "MIT",
+  "files": [
+    "src/",
+    "README.md",
+    ".env.example"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ariekogan/ateam-mcp.git"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "express": "^5.2.1"
+  }
+}

package/src/api.js

@@ -0,0 +1,50 @@
+/**
+ * ADAS API client — thin HTTP wrapper for the External Agent API.
+ */
+
+const BASE_URL = process.env.ADAS_API_URL || "https://api.ateam-ai.com";
+const TENANT = process.env.ADAS_TENANT || "main";
+const API_KEY = process.env.ADAS_API_KEY || "";
+
+function headers() {
+  return {
+    "Content-Type": "application/json",
+    "X-ADAS-TENANT": TENANT,
+    "X-API-KEY": API_KEY,
+  };
+}
+
+export async function get(path) {
+  const res = await fetch(`${BASE_URL}${path}`, { headers: headers() });
+  if (!res.ok) throw new Error(`GET ${path} → ${res.status}: ${await res.text()}`);
+  return res.json();
+}
+
+export async function post(path, body) {
+  const res = await fetch(`${BASE_URL}${path}`, {
+    method: "POST",
+    headers: headers(),
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) throw new Error(`POST ${path} → ${res.status}: ${await res.text()}`);
+  return res.json();
+}
+
+export async function patch(path, body) {
+  const res = await fetch(`${BASE_URL}${path}`, {
+    method: "PATCH",
+    headers: headers(),
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) throw new Error(`PATCH ${path} → ${res.status}: ${await res.text()}`);
+  return res.json();
+}
+
+export async function del(path) {
+  const res = await fetch(`${BASE_URL}${path}`, {
+    method: "DELETE",
+    headers: headers(),
+  });
+  if (!res.ok) throw new Error(`DELETE ${path} → ${res.status}: ${await res.text()}`);
+  return res.json();
+}

package/src/http.js

@@ -0,0 +1,113 @@
+/**
+ * Streamable HTTP transport for ateam-mcp.
+ * Enables ChatGPT and remote MCP clients to connect via HTTPS.
+ */
+
+import { randomUUID } from "node:crypto";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import express from "express";
+import { createServer } from "./server.js";
+
+// Active sessions
+const transports = {};
+
+export function startHttpServer(port = 3100) {
+  const app = express();
+  app.use(express.json());
+
+  // ─── Health check ─────────────────────────────────────────────
+  app.get("/health", (_req, res) => {
+    res.json({ ok: true, service: "ateam-mcp", transport: "http" });
+  });
+
+  // ─── MCP POST — handle tool calls + initialize ───────────────
+  app.post("/mcp", async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+
+    try {
+      let transport;
+
+      if (sessionId && transports[sessionId]) {
+        // Reuse existing session
+        transport = transports[sessionId];
+      } else if (!sessionId && isInitializeRequest(req.body)) {
+        // New session
+        transport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: () => randomUUID(),
+          onsessioninitialized: (sid) => {
+            transports[sid] = transport;
+          },
+        });
+
+        transport.onclose = () => {
+          const sid = transport.sessionId;
+          if (sid && transports[sid]) {
+            delete transports[sid];
+          }
+        };
+
+        const server = createServer();
+        await server.connect(transport);
+        await transport.handleRequest(req, res, req.body);
+        return;
+      } else {
+        res.status(400).json({
+          jsonrpc: "2.0",
+          error: { code: -32000, message: "Bad Request: No valid session ID" },
+          id: null,
+        });
+        return;
+      }
+
+      await transport.handleRequest(req, res, req.body);
+    } catch (err) {
+      console.error("MCP request error:", err);
+      if (!res.headersSent) {
+        res.status(500).json({
+          jsonrpc: "2.0",
+          error: { code: -32603, message: "Internal server error" },
+          id: null,
+        });
+      }
+    }
+  });
+
+  // ─── MCP GET — SSE stream for notifications ──────────────────
+  app.get("/mcp", async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+    if (!sessionId || !transports[sessionId]) {
+      res.status(400).send("Invalid or missing session ID");
+      return;
+    }
+    await transports[sessionId].handleRequest(req, res);
+  });
+
+  // ─── MCP DELETE — session termination ────────────────────────
+  app.delete("/mcp", async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+    if (!sessionId || !transports[sessionId]) {
+      res.status(400).send("Invalid or missing session ID");
+      return;
+    }
+    await transports[sessionId].handleRequest(req, res);
+  });
+
+  // ─── Start ────────────────────────────────────────────────────
+  app.listen(port, "0.0.0.0", () => {
+    console.log(`ateam-mcp HTTP server listening on port ${port}`);
+    console.log(`  MCP endpoint: http://localhost:${port}/mcp`);
+    console.log(`  Health check: http://localhost:${port}/health`);
+  });
+
+  // Graceful shutdown
+  process.on("SIGINT", async () => {
+    for (const sid of Object.keys(transports)) {
+      try {
+        await transports[sid].close();
+      } catch {}
+      delete transports[sid];
+    }
+    process.exit(0);
+  });
+}

package/src/index.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+/**
+ * ADAS MCP Server
+ * Build, validate, and deploy multi-agent solutions from any AI environment.
+ *
+ * Transports:
+ *   --http [port]   Start Streamable HTTP server (default port 3100)
+ *   (default)       Start stdio transport for Claude Code, Cursor, etc.
+ */
+
+import { createServer } from "./server.js";
+
+const httpFlag = process.argv.includes("--http");
+
+if (httpFlag) {
+  // ─── HTTP transport (for ChatGPT, remote clients) ─────────────
+  const { startHttpServer } = await import("./http.js");
+  const portArg = process.argv[process.argv.indexOf("--http") + 1];
+  const port = portArg && !portArg.startsWith("-") ? parseInt(portArg, 10) : 3100;
+  startHttpServer(port);
+} else {
+  // ─── Stdio transport (for Claude Code, Cursor, Windsurf, VS Code) ──
+  const { StdioServerTransport } = await import(
+    "@modelcontextprotocol/sdk/server/stdio.js"
+  );
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}

package/src/server.js

@@ -0,0 +1,26 @@
+/**
+ * Shared MCP server factory — used by both stdio and HTTP transports.
+ */
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { tools, handleToolCall } from "./tools.js";
+
+export function createServer() {
+  const server = new Server(
+    { name: "ateam-mcp", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    return handleToolCall(name, args);
+  });
+
+  return server;
+}

package/src/tools.js

@@ -0,0 +1,336 @@
+/**
+ * ADAS MCP tool definitions and handlers.
+ * 12 tools covering the full ADAS External Agent API.
+ */
+
+import { get, post, patch, del } from "./api.js";
+
+// ─── Tool definitions ───────────────────────────────────────────────
+
+export const tools = [
+  {
+    name: "adas_get_spec",
+    description:
+      "Get the ADAS specification — schemas, validation rules, system tools, agent guides, and templates. Use this to understand how to build skills and solutions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        topic: {
+          type: "string",
+          enum: ["overview", "skill", "solution", "enums"],
+          description:
+            "What to fetch: 'overview' = API overview + endpoints, 'skill' = full skill spec, 'solution' = full solution spec, 'enums' = all enum values",
+        },
+      },
+      required: ["topic"],
+    },
+  },
+  {
+    name: "adas_get_examples",
+    description:
+      "Get complete working examples that pass validation. Study these before building your own.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["skill", "connector", "connector-ui", "solution", "index"],
+          description:
+            "Example type: 'skill' = Order Support Agent, 'connector' = stdio MCP connector, 'connector-ui' = UI-capable connector, 'solution' = full 3-skill e-commerce solution, 'index' = list all available examples",
+        },
+      },
+      required: ["type"],
+    },
+  },
+  {
+    name: "adas_validate_skill",
+    description:
+      "Validate a skill definition through the 5-stage ADAS validation pipeline. Returns errors and suggestions to fix.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        skill: {
+          type: "object",
+          description: "The full skill definition object to validate",
+        },
+      },
+      required: ["skill"],
+    },
+  },
+  {
+    name: "adas_validate_solution",
+    description:
+      "Validate a solution definition — cross-skill contracts, grant economy, handoffs, and LLM quality scoring.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        solution: {
+          type: "object",
+          description: "The full solution definition object to validate",
+        },
+        skills: {
+          type: "array",
+          items: { type: "object" },
+          description: "Array of skill definitions included in the solution",
+        },
+      },
+      required: ["solution"],
+    },
+  },
+  {
+    name: "adas_deploy_solution",
+    description:
+      "Deploy a complete solution to ADAS Core — identity, connectors, skills. The Skill Builder auto-generates MCP servers from tool definitions. This is the main deployment action.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        solution: {
+          type: "object",
+          description: "Solution architecture — identity, grants, handoffs, routing",
+        },
+        skills: {
+          type: "array",
+          items: { type: "object" },
+          description: "Array of full skill definitions",
+        },
+        connectors: {
+          type: "array",
+          items: { type: "object" },
+          description: "Array of connector metadata (id, name, transport, command, args)",
+        },
+        mcp_store: {
+          type: "object",
+          description:
+            "Optional: connector source code files. Key = connector id, value = array of {path, content}",
+        },
+      },
+      required: ["solution", "skills"],
+    },
+  },
+  {
+    name: "adas_deploy_skill",
+    description: "Deploy a single skill into an existing solution.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        solution_id: {
+          type: "string",
+          description: "The existing solution ID to add the skill to",
+        },
+        skill: {
+          type: "object",
+          description: "Full skill definition",
+        },
+      },
+      required: ["solution_id", "skill"],
+    },
+  },
+  {
+    name: "adas_deploy_connector",
+    description: "Deploy a connector — registers in the Skill Builder catalog and connects in ADAS Core.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        connector: {
+          type: "object",
+          description: "Connector metadata (id, name, transport, command, args)",
+        },
+      },
+      required: ["connector"],
+    },
+  },
+  {
+    name: "adas_list_solutions",
+    description: "List all solutions deployed in the Skill Builder.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+    },
+  },
+  {
+    name: "adas_get_solution",
+    description:
+      "Read solution state — definition, skills, health, status, or export. Use this to inspect deployed solutions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        solution_id: {
+          type: "string",
+          description: "The solution ID",
+        },
+        view: {
+          type: "string",
+          enum: ["definition", "skills", "health", "status", "export", "validate", "connectors_health"],
+          description:
+            "What to read: 'definition' = full solution def, 'skills' = list skills, 'health' = live health check, 'status' = deploy status, 'export' = exportable bundle, 'validate' = re-validate from stored state, 'connectors_health' = connector status",
+        },
+        skill_id: {
+          type: "string",
+          description: "Optional: read a specific skill by ID (original or internal)",
+        },
+      },
+      required: ["solution_id", "view"],
+    },
+  },
+  {
+    name: "adas_update",
+    description:
+      "Update a deployed solution or skill incrementally using PATCH. Supports dot notation for scalar fields and _push/_delete/_update for arrays.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        solution_id: {
+          type: "string",
+          description: "The solution ID",
+        },
+        target: {
+          type: "string",
+          enum: ["solution", "skill"],
+          description: "What to update: 'solution' or 'skill'",
+        },
+        skill_id: {
+          type: "string",
+          description: "Required when target is 'skill'",
+        },
+        updates: {
+          type: "object",
+          description:
+            "The update payload — use dot notation for scalars (e.g. 'problem.statement'), and tools_push/tools_delete/tools_update for array operations",
+        },
+      },
+      required: ["solution_id", "target", "updates"],
+    },
+  },
+  {
+    name: "adas_redeploy",
+    description:
+      "Re-deploy after making updates. Regenerates MCP servers and pushes to ADAS Core.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        solution_id: {
+          type: "string",
+          description: "The solution ID",
+        },
+        skill_id: {
+          type: "string",
+          description: "Optional: redeploy a single skill. Omit to redeploy all skills.",
+        },
+      },
+      required: ["solution_id"],
+    },
+  },
+  {
+    name: "adas_solution_chat",
+    description:
+      "Send a message to the Solution Bot — an AI assistant that understands your deployed solution and can help with modifications.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        solution_id: {
+          type: "string",
+          description: "The solution ID",
+        },
+        message: {
+          type: "string",
+          description: "Your message to the Solution Bot",
+        },
+      },
+      required: ["solution_id", "message"],
+    },
+  },
+];
+
+// ─── Tool handlers ──────────────────────────────────────────────────
+
+const SPEC_PATHS = {
+  overview: "/spec",
+  skill: "/spec/skill",
+  solution: "/spec/solution",
+  enums: "/spec/enums",
+};
+
+const EXAMPLE_PATHS = {
+  index: "/spec/examples",
+  skill: "/spec/examples/skill",
+  connector: "/spec/examples/connector",
+  "connector-ui": "/spec/examples/connector-ui",
+  solution: "/spec/examples/solution",
+};
+
+const handlers = {
+  adas_get_spec: async ({ topic }) => get(SPEC_PATHS[topic]),
+
+  adas_get_examples: async ({ type }) => get(EXAMPLE_PATHS[type]),
+
+  adas_validate_skill: async ({ skill }) => post("/validate/skill", { skill }),
+
+  adas_validate_solution: async ({ solution, skills }) =>
+    post("/validate/solution", { solution, skills }),
+
+  adas_deploy_solution: async ({ solution, skills, connectors, mcp_store }) =>
+    post("/deploy/solution", { solution, skills, connectors, mcp_store }),
+
+  adas_deploy_skill: async ({ solution_id, skill }) =>
+    post(`/deploy/solutions/${solution_id}/skills`, { skill }),
+
+  adas_deploy_connector: async ({ connector }) =>
+    post("/deploy/connector", { connector }),
+
+  adas_list_solutions: async () => get("/deploy/solutions"),
+
+  adas_get_solution: async ({ solution_id, view, skill_id }) => {
+    const base = `/deploy/solutions/${solution_id}`;
+    if (skill_id) return get(`${base}/skills/${skill_id}`);
+    const paths = {
+      definition: `${base}/definition`,
+      skills: `${base}/skills`,
+      health: `${base}/health`,
+      status: `/deploy/status/${solution_id}`,
+      export: `${base}/export`,
+      validate: `${base}/validate`,
+      connectors_health: `${base}/connectors/health`,
+    };
+    return get(paths[view]);
+  },
+
+  adas_update: async ({ solution_id, target, skill_id, updates }) => {
+    if (target === "skill") {
+      return patch(`/deploy/solutions/${solution_id}/skills/${skill_id}`, { updates });
+    }
+    return patch(`/deploy/solutions/${solution_id}`, { state_update: updates });
+  },
+
+  adas_redeploy: async ({ solution_id, skill_id }) => {
+    if (skill_id) {
+      return post(`/deploy/solutions/${solution_id}/skills/${skill_id}/redeploy`, {});
+    }
+    return post(`/deploy/solutions/${solution_id}/redeploy`, {});
+  },
+
+  adas_solution_chat: async ({ solution_id, message }) =>
+    post(`/deploy/solutions/${solution_id}/chat`, { message }),
+};
+
+// ─── Dispatcher ─────────────────────────────────────────────────────
+
+export async function handleToolCall(name, args) {
+  const handler = handlers[name];
+  if (!handler) {
+    return {
+      content: [{ type: "text", text: `Unknown tool: ${name}` }],
+      isError: true,
+    };
+  }
+  try {
+    const result = await handler(args);
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+  } catch (err) {
+    return {
+      content: [{ type: "text", text: `Error: ${err.message}` }],
+      isError: true,
+    };
+  }
+}