clay-server 2.29.0 → 2.29.1

package/lib/sdk-bridge.js

@@ -10,6 +10,59 @@ var { splitShellSegments, attachSkillDiscovery } = require("./sdk-skill-discover
 var { createMessageQueue } = require("./sdk-message-queue");
 var { attachMessageProcessor } = require("./sdk-message-processor");
 
+// Extract serializable tool descriptors from MCP server instances.
+// Used for IPC to worker processes (McpSdkServerConfigWithInstance is not serializable).
+function extractMcpDescriptors(mcpServers) {
+  if (!mcpServers) return null;
+  var toJSONSchema;
+  try { toJSONSchema = require("zod").toJSONSchema; } catch (e) { return null; }
+  var descriptors = [];
+  var names = Object.keys(mcpServers);
+  for (var i = 0; i < names.length; i++) {
+    var serverName = names[i];
+    var server = mcpServers[serverName];
+    if (!server || !server.instance || !server.instance._registeredTools) continue;
+    var tools = [];
+    var toolNames = Object.keys(server.instance._registeredTools);
+    for (var j = 0; j < toolNames.length; j++) {
+      var toolName = toolNames[j];
+      var toolDef = server.instance._registeredTools[toolName];
+      var inputSchema = { type: "object", properties: {} };
+      try {
+        if (toolDef.inputSchema) inputSchema = toJSONSchema(toolDef.inputSchema);
+      } catch (e) { /* fallback to empty schema */ }
+      tools.push({
+        name: toolName,
+        description: toolDef.description || toolName,
+        inputSchema: inputSchema,
+      });
+    }
+    if (tools.length > 0) descriptors.push({ serverName: serverName, tools: tools });
+  }
+  return descriptors.length > 0 ? descriptors : null;
+}
+
+// Call an MCP tool handler by server name and tool name.
+// Returns a promise that resolves with the tool result.
+function callMcpToolHandler(mcpServers, serverName, toolName, args) {
+  if (!mcpServers || !mcpServers[serverName]) {
+    return Promise.reject(new Error("MCP server not found: " + serverName));
+  }
+  var server = mcpServers[serverName];
+  if (!server.instance || !server.instance._registeredTools || !server.instance._registeredTools[toolName]) {
+    return Promise.reject(new Error("MCP tool not found: " + serverName + "/" + toolName));
+  }
+  var handler = server.instance._registeredTools[toolName].handler;
+  if (typeof handler !== "function") {
+    return Promise.reject(new Error("MCP tool handler not a function: " + serverName + "/" + toolName));
+  }
+  try {
+    return Promise.resolve(handler(args));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+}
+
 // Merge in-process MCP servers with remote (extension-bridged) MCP servers.
 // Returns the merged object, or null if no servers exist.
 function mergeMcpServers(localServers, getRemoteFn) {
@@ -579,8 +632,13 @@ function createSDKBridge(opts) {
       agentProgressSummaries: true,
     };
 
+    // MCP servers contain circular references (McpServer instances) and cannot
+    // be serialized for IPC. Instead, extract serializable tool descriptors and
+    // proxy tool calls back to the daemon via IPC.
     var _mergedMcp = mergeMcpServers(mcpServers, getRemoteMcpServers);
-    if (_mergedMcp) queryOptions.mcpServers = _mergedMcp;
+    var _mcpDescriptors = extractMcpDescriptors(_mergedMcp);
+    // Do NOT put _mergedMcp into queryOptions; the worker will reconstruct
+    // MCP servers from descriptors with IPC-proxied handlers.
 
     // Per-loop settings override global defaults when present
     var ls2 = session.loopSettings || {};
@@ -673,6 +731,18 @@ function createSDKBridge(opts) {
           });
           break;
 
+        case "mcp_tool_call":
+          // Worker is proxying an MCP tool call back to the daemon where
+          // the actual MCP server instances (with handlers) live.
+          callMcpToolHandler(_mergedMcp, msg.serverName, msg.toolName, msg.args)
+            .then(function(result) {
+              worker.send({ type: "mcp_tool_result", requestId: msg.requestId, result: result });
+            })
+            .catch(function(e) {
+              worker.send({ type: "mcp_tool_result", requestId: msg.requestId, error: e.message || String(e) });
+            });
+          break;
+
         case "context_usage":
           session.lastContextUsage = msg.data;
           sendToSession(session, { type: "context_usage", data: msg.data });
@@ -859,6 +929,7 @@ function createSDKBridge(opts) {
       type: "query_start",
       prompt: initialMessage,
       options: queryOptions,
+      mcpDescriptors: _mcpDescriptors,
       singleTurn: !!session.singleTurn,
       originalHome: require("./config").REAL_HOME || null,
       projectPath: session.cwd || null,

package/lib/sdk-worker.js

@@ -31,6 +31,7 @@ var abortController = null;
 var pendingPermissions = {};  // requestId -> resolve
 var pendingAskUser = {};      // toolUseId -> resolve
 var pendingElicitations = {}; // requestId -> resolve
+var pendingMcpCalls = {};     // requestId -> { resolve, reject }
 var conn = null;
 var buffer = "";
 
@@ -127,6 +128,9 @@ function handleMessage(msg) {
     case "elicitation_response":
       handleElicitationResponse(msg);
       break;
+    case "mcp_tool_result":
+      handleMcpToolResult(msg);
+      break;
     case "warmup":
       handleWarmup(msg);
       break;
@@ -208,6 +212,107 @@ function handleElicitationResponse(msg) {
   }
 }
 
+function handleMcpToolResult(msg) {
+  var pending = pendingMcpCalls[msg.requestId];
+  if (!pending) return;
+  delete pendingMcpCalls[msg.requestId];
+  if (msg.error) {
+    pending.reject(new Error(msg.error));
+  } else {
+    pending.resolve(msg.result);
+  }
+}
+
+// Reconstruct MCP servers from serializable descriptors with IPC-proxied handlers.
+// Each tool call is forwarded to the daemon which has the real MCP server instances.
+function buildMcpServersFromDescriptors(sdk, descriptors) {
+  if (!descriptors || descriptors.length === 0) return null;
+  var z;
+  try { z = require("zod").z; } catch (e) {
+    try { z = require("zod"); } catch (e2) {
+      console.error("[sdk-worker] Failed to load zod for MCP reconstruction:", e2.message);
+      return null;
+    }
+  }
+  var createSdkMcpServer = sdk.createSdkMcpServer;
+  var toolFn = sdk.tool;
+  if (!createSdkMcpServer || !toolFn) {
+    console.error("[sdk-worker] SDK missing createSdkMcpServer or tool helper");
+    return null;
+  }
+
+  var servers = {};
+  for (var i = 0; i < descriptors.length; i++) {
+    var desc = descriptors[i];
+    var tools = [];
+    for (var j = 0; j < desc.tools.length; j++) {
+      var td = desc.tools[j];
+      var shape = buildZodShape(z, td.inputSchema);
+      tools.push(toolFn(
+        td.name,
+        td.description || td.name,
+        shape,
+        createMcpProxyHandler(desc.serverName, td.name)
+      ));
+    }
+    if (tools.length > 0) {
+      servers[desc.serverName] = createSdkMcpServer({
+        name: desc.serverName,
+        version: "1.0.0",
+        tools: tools,
+      });
+    }
+  }
+  return Object.keys(servers).length > 0 ? servers : null;
+}
+
+function createMcpProxyHandler(serverName, toolName) {
+  return function(args) {
+    return new Promise(function(resolve, reject) {
+      var requestId = "mcp_" + Date.now() + "_" + crypto.randomUUID().slice(0, 8);
+      pendingMcpCalls[requestId] = { resolve: resolve, reject: reject };
+      sendToDaemon({
+        type: "mcp_tool_call",
+        requestId: requestId,
+        serverName: serverName,
+        toolName: toolName,
+        args: args,
+      });
+    });
+  };
+}
+
+// Build a Zod shape from MCP JSON Schema inputSchema (mirrors project-mcp.js logic)
+function buildZodShape(z, inputSchema) {
+  if (!inputSchema || !inputSchema.properties) return {};
+  var shape = {};
+  var props = inputSchema.properties;
+  var required = inputSchema.required || [];
+  var keys = Object.keys(props);
+  for (var i = 0; i < keys.length; i++) {
+    var k = keys[i];
+    var p = props[k];
+    var field;
+    if (p.type === "number" || p.type === "integer") {
+      field = z.number();
+    } else if (p.type === "boolean") {
+      field = z.boolean();
+    } else if (p.type === "array") {
+      field = z.array(z.any());
+    } else if (p.type === "object") {
+      field = z.record(z.any());
+    } else if (p.enum) {
+      field = z.enum(p.enum);
+    } else {
+      field = z.string();
+    }
+    if (p.description) field = field.describe(p.description);
+    if (required.indexOf(k) === -1) field = field.optional();
+    shape[k] = field;
+  }
+  return shape;
+}
+
 // --- Query handling ---
 async function handleQueryStart(msg) {
   var t0 = msg._perfT0 || Date.now();
@@ -233,8 +338,17 @@ async function handleQueryStart(msg) {
     messageQueue.push(msg.prompt);
   }
 
+  // Reconstruct MCP servers from serializable descriptors (IPC-proxied handlers)
+  if (msg.mcpDescriptors) {
+    var _mcpServers = buildMcpServersFromDescriptors(sdk, msg.mcpDescriptors);
+    if (_mcpServers) {
+      perf("MCP servers reconstructed from descriptors (" + Object.keys(_mcpServers).length + " servers)");
+    }
+  }
+
   // Build query options (callbacks are local, everything else from daemon)
   var options = msg.options || {};
+  if (_mcpServers) options.mcpServers = _mcpServers;
   options.abortController = abortController;
   options.debug = true;
   options.debugFile = "/tmp/clay-cli-debug-" + process.pid + ".log";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clay-server",
-  "version": "2.29.0",
+  "version": "2.29.1",
   "description": "Self-hosted Claude Code in your browser. Multi-session, multi-user, push notifications.",
   "bin": {
     "clay-server": "./bin/cli.js",