@robota-sdk/agent-transport-mcp 3.0.0-beta.43

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Robota Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,50 @@
+# @robota-sdk/agent-transport-mcp
+
+MCP transport adapter for exposing `InteractiveSession` as a Model Context Protocol server. Allows MCP-compatible clients (Claude, other agents) to interact with a Robota agent via the standard MCP tool protocol.
+
+## Installation
+
+```bash
+pnpm add @robota-sdk/agent-transport-mcp
+```
+
+## Usage
+
+```typescript
+import { createAgentMcpServer } from '@robota-sdk/agent-transport-mcp';
+import { InteractiveSession, SystemCommandExecutor } from '@robota-sdk/agent-sdk';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+
+const mcpServer = createAgentMcpServer({
+  name: 'robota-agent',
+  version: '1.0.0',
+  session: interactiveSession,
+  commandExecutor,
+});
+
+// Connect via stdio (subprocess / Claude Desktop)
+await mcpServer.connect(new StdioServerTransport());
+```
+
+## MCP Tools
+
+Each tool maps directly to an `InteractiveSession` operation or a system command.
+
+| Tool Name         | Input                | Description                             |
+| ----------------- | -------------------- | --------------------------------------- |
+| `submit`          | `{ prompt: string }` | Submit a prompt, wait for full response |
+| `command_help`    | `{ args?: string }`  | Show available commands                 |
+| `command_clear`   | `{ args?: string }`  | Clear conversation history              |
+| `command_compact` | `{ args?: string }`  | Compress the context window             |
+| `command_mode`    | `{ args?: string }`  | Show or change permission mode          |
+| `command_model`   | `{ args?: string }`  | Change the active AI model              |
+| `command_context` | `{ args?: string }`  | Show context window info                |
+| ...               | ...                  | One tool per registered system command  |
+
+The `submit` tool waits for the session to reach `complete` or `interrupted` state before returning, so MCP clients receive a single text response rather than a stream.
+
+## Dependencies
+
+- `@robota-sdk/agent-sdk` — `InteractiveSession`, `SystemCommandExecutor`
+- `@modelcontextprotocol/sdk` — MCP server implementation
+- `zod` — input schema definitions

package/dist/node/index.cjs

@@ -0,0 +1,130 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createAgentMcpServer: () => createAgentMcpServer
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/mcp-server.ts
+var import_server = require("@modelcontextprotocol/sdk/server/index.js");
+var import_types = require("@modelcontextprotocol/sdk/types.js");
+function createAgentMcpServer(options) {
+  const { name, version, session, commandExecutor, exposeCommands = true } = options;
+  const server = new import_server.Server({ name, version }, { capabilities: { tools: {} } });
+  const tools = [
+    {
+      name: "submit",
+      description: "Submit a prompt to the AI agent and wait for the response",
+      inputSchema: {
+        type: "object",
+        properties: {
+          prompt: { type: "string", description: "The prompt to send to the agent" }
+        },
+        required: ["prompt"]
+      }
+    }
+  ];
+  if (exposeCommands) {
+    for (const cmd of commandExecutor.listCommands()) {
+      tools.push({
+        name: `command_${cmd.name}`,
+        description: cmd.description,
+        inputSchema: {
+          type: "object",
+          properties: {
+            args: { type: "string", description: "Command arguments" }
+          }
+        }
+      });
+    }
+  }
+  server.setRequestHandler(import_types.ListToolsRequestSchema, async () => ({
+    tools
+  }));
+  server.setRequestHandler(import_types.CallToolRequestSchema, async (request) => {
+    const { name: toolName, arguments: toolArgs } = request.params;
+    if (toolName === "submit") {
+      const prompt = toolArgs?.prompt;
+      if (!prompt) {
+        return {
+          content: [{ type: "text", text: "Error: prompt is required" }],
+          isError: true
+        };
+      }
+      const result = await waitForCompletion(session, prompt);
+      return {
+        content: [{ type: "text", text: result.response }]
+      };
+    }
+    if (toolName.startsWith("command_")) {
+      const cmdName = toolName.slice("command_".length);
+      const args = toolArgs?.args ?? "";
+      const result = await commandExecutor.execute(cmdName, session, args);
+      return {
+        content: [
+          {
+            type: "text",
+            text: result?.message ?? `Unknown command: ${cmdName}`
+          }
+        ],
+        isError: !result
+      };
+    }
+    return {
+      content: [{ type: "text", text: `Unknown tool: ${toolName}` }],
+      isError: true
+    };
+  });
+  return server;
+}
+function waitForCompletion(session, prompt) {
+  return new Promise((resolve, reject) => {
+    const onComplete = (result) => {
+      cleanup();
+      resolve(result);
+    };
+    const onInterrupted = (result) => {
+      cleanup();
+      resolve(result);
+    };
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const cleanup = () => {
+      session.off("complete", onComplete);
+      session.off("interrupted", onInterrupted);
+      session.off("error", onError);
+    };
+    session.on("complete", onComplete);
+    session.on("interrupted", onInterrupted);
+    session.on("error", onError);
+    session.submit(prompt).catch((err) => {
+      cleanup();
+      reject(err instanceof Error ? err : new Error(String(err)));
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAgentMcpServer
+});

package/dist/node/index.d.cts

@@ -0,0 +1,42 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { InteractiveSession, SystemCommandExecutor } from '@robota-sdk/agent-sdk';
+
+/**
+ * MCP transport adapter — exposes InteractiveSession as an MCP server.
+ *
+ * Uses the low-level MCP Server class to avoid TypeScript depth issues
+ * with McpServer.registerTool() generics. Registers tools/list and
+ * tools/call handlers directly.
+ */
+
+interface IAgentMcpOptions {
+    /** Name for the MCP server. */
+    name: string;
+    /** Version string. */
+    version: string;
+    /** InteractiveSession to expose. */
+    session: InteractiveSession;
+    /** System command executor. */
+    commandExecutor: SystemCommandExecutor;
+    /** If true, register each system command as a separate MCP tool. Default: true. */
+    exposeCommands?: boolean;
+}
+/**
+ * Create an MCP server that exposes InteractiveSession over Model Context Protocol.
+ *
+ * Usage:
+ * ```typescript
+ * const server = createAgentMcpServer({
+ *   name: 'robota-agent',
+ *   version: '1.0.0',
+ *   session: interactiveSession,
+ *   commandExecutor,
+ * });
+ *
+ * import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+ * await server.connect(new StdioServerTransport());
+ * ```
+ */
+declare function createAgentMcpServer(options: IAgentMcpOptions): Server;
+
+export { type IAgentMcpOptions, createAgentMcpServer };

package/dist/node/index.d.ts

@@ -0,0 +1,42 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { InteractiveSession, SystemCommandExecutor } from '@robota-sdk/agent-sdk';
+
+/**
+ * MCP transport adapter — exposes InteractiveSession as an MCP server.
+ *
+ * Uses the low-level MCP Server class to avoid TypeScript depth issues
+ * with McpServer.registerTool() generics. Registers tools/list and
+ * tools/call handlers directly.
+ */
+
+interface IAgentMcpOptions {
+    /** Name for the MCP server. */
+    name: string;
+    /** Version string. */
+    version: string;
+    /** InteractiveSession to expose. */
+    session: InteractiveSession;
+    /** System command executor. */
+    commandExecutor: SystemCommandExecutor;
+    /** If true, register each system command as a separate MCP tool. Default: true. */
+    exposeCommands?: boolean;
+}
+/**
+ * Create an MCP server that exposes InteractiveSession over Model Context Protocol.
+ *
+ * Usage:
+ * ```typescript
+ * const server = createAgentMcpServer({
+ *   name: 'robota-agent',
+ *   version: '1.0.0',
+ *   session: interactiveSession,
+ *   commandExecutor,
+ * });
+ *
+ * import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+ * await server.connect(new StdioServerTransport());
+ * ```
+ */
+declare function createAgentMcpServer(options: IAgentMcpOptions): Server;
+
+export { type IAgentMcpOptions, createAgentMcpServer };

package/dist/node/index.js

@@ -0,0 +1,103 @@
+// src/mcp-server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+function createAgentMcpServer(options) {
+  const { name, version, session, commandExecutor, exposeCommands = true } = options;
+  const server = new Server({ name, version }, { capabilities: { tools: {} } });
+  const tools = [
+    {
+      name: "submit",
+      description: "Submit a prompt to the AI agent and wait for the response",
+      inputSchema: {
+        type: "object",
+        properties: {
+          prompt: { type: "string", description: "The prompt to send to the agent" }
+        },
+        required: ["prompt"]
+      }
+    }
+  ];
+  if (exposeCommands) {
+    for (const cmd of commandExecutor.listCommands()) {
+      tools.push({
+        name: `command_${cmd.name}`,
+        description: cmd.description,
+        inputSchema: {
+          type: "object",
+          properties: {
+            args: { type: "string", description: "Command arguments" }
+          }
+        }
+      });
+    }
+  }
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name: toolName, arguments: toolArgs } = request.params;
+    if (toolName === "submit") {
+      const prompt = toolArgs?.prompt;
+      if (!prompt) {
+        return {
+          content: [{ type: "text", text: "Error: prompt is required" }],
+          isError: true
+        };
+      }
+      const result = await waitForCompletion(session, prompt);
+      return {
+        content: [{ type: "text", text: result.response }]
+      };
+    }
+    if (toolName.startsWith("command_")) {
+      const cmdName = toolName.slice("command_".length);
+      const args = toolArgs?.args ?? "";
+      const result = await commandExecutor.execute(cmdName, session, args);
+      return {
+        content: [
+          {
+            type: "text",
+            text: result?.message ?? `Unknown command: ${cmdName}`
+          }
+        ],
+        isError: !result
+      };
+    }
+    return {
+      content: [{ type: "text", text: `Unknown tool: ${toolName}` }],
+      isError: true
+    };
+  });
+  return server;
+}
+function waitForCompletion(session, prompt) {
+  return new Promise((resolve, reject) => {
+    const onComplete = (result) => {
+      cleanup();
+      resolve(result);
+    };
+    const onInterrupted = (result) => {
+      cleanup();
+      resolve(result);
+    };
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const cleanup = () => {
+      session.off("complete", onComplete);
+      session.off("interrupted", onInterrupted);
+      session.off("error", onError);
+    };
+    session.on("complete", onComplete);
+    session.on("interrupted", onInterrupted);
+    session.on("error", onError);
+    session.submit(prompt).catch((err) => {
+      cleanup();
+      reject(err instanceof Error ? err : new Error(String(err)));
+    });
+  });
+}
+export {
+  createAgentMcpServer
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@robota-sdk/agent-transport-mcp",
+  "version": "3.0.0-beta.43",
+  "description": "MCP transport adapter for exposing InteractiveSession as an MCP server",
+  "type": "module",
+  "main": "dist/node/index.js",
+  "types": "dist/node/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/node/index.d.ts",
+      "node": {
+        "import": "./dist/node/index.js",
+        "require": "./dist/node/index.cjs"
+      },
+      "default": {
+        "import": "./dist/node/index.js",
+        "require": "./dist/node/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.28.0",
+    "zod": "^3.24.4",
+    "@robota-sdk/agent-sdk": "3.0.0-beta.43"
+  },
+  "devDependencies": {
+    "rimraf": "^5.0.5",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vitest": "^1.6.1"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --out-dir dist/node --clean",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/ --ext .ts",
+    "clean": "rimraf dist"
+  }
+}