clay-server 2.34.0-beta.4 → 2.34.0-beta.6

package/lib/sdk-bridge.js

@@ -1227,11 +1227,13 @@ function createSDKBridge(opts) {
     }
 
     var codexConfig = getCodexConfig(sm);
+    var mergedMcpServers = mergeMcpServers(getMcpServers(), getRemoteMcpServers) || undefined;
     var queryOpts = {
       cwd: cwd,
       model: queryModel,
       effort: ls.effort || sm.currentEffort || undefined,
-      toolServers: mergeMcpServers(getMcpServers(), getRemoteMcpServers) || undefined,
+      toolServers: mergedMcpServers,
+      toolServerDescriptors: extractMcpDescriptors(mergedMcpServers) || undefined,
       resumeSessionId: session.cliSessionId || undefined,
       abortController: linuxUser ? undefined : session.abortController,
       canUseTool: function(toolName, input, toolOpts) {
@@ -1240,6 +1242,9 @@ function createSDKBridge(opts) {
       onElicitation: function(request, elicitOpts) {
         return handleElicitation(session, request, elicitOpts);
       },
+      callMcpTool: function(serverName, toolName, args) {
+        return callMcpToolHandler(mergedMcpServers, serverName, toolName, args);
+      },
       adapterOptions: {
         CLAUDE: claudeOpts,
         CODEX: {

package/lib/yoke/adapters/claude-worker.js

@@ -31,6 +31,7 @@ var abortController = null;
 var pendingPermissions = {};  // requestId -> resolve
 var pendingAskUser = {};      // toolUseId -> resolve
 var pendingElicitations = {}; // requestId -> resolve
+var pendingMcpToolCalls = {}; // requestId -> { resolve, reject }
 var conn = null;
 var buffer = "";
 
@@ -81,6 +82,90 @@ function getSDK() {
   return sdkModule;
 }
 
+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 key = keys[i];
+    var prop = props[key];
+    var field;
+
+    if (prop.type === "number" || prop.type === "integer") {
+      field = z.number();
+    } else if (prop.type === "boolean") {
+      field = z.boolean();
+    } else if (prop.type === "array") {
+      field = z.array(z.any());
+    } else if (prop.type === "object") {
+      field = z.record(z.any());
+    } else if (prop.enum) {
+      field = z.enum(prop.enum);
+    } else {
+      field = z.string();
+    }
+
+    if (prop.description) field = field.describe(prop.description);
+    if (required.indexOf(key) === -1) field = field.optional();
+    shape[key] = field;
+  }
+
+  return shape;
+}
+
+function createWorkerMcpToolHandler(serverName, toolName) {
+  return function(args) {
+    var requestId = crypto.randomUUID();
+    sendToDaemon({
+      type: "mcp_tool_call",
+      requestId: requestId,
+      serverName: serverName,
+      toolName: toolName,
+      args: args || {},
+    });
+    return new Promise(function(resolve, reject) {
+      pendingMcpToolCalls[requestId] = { resolve: resolve, reject: reject };
+    });
+  };
+}
+
+function buildMcpServersFromDescriptors(descriptors, sdk) {
+  if (!descriptors || !descriptors.length) return null;
+  var z;
+  try { z = require("zod").z; } catch (e) {
+    try { z = require("zod"); } catch (e2) { return null; }
+  }
+
+  var servers = {};
+  for (var i = 0; i < descriptors.length; i++) {
+    var descriptor = descriptors[i];
+    if (!descriptor || !descriptor.serverName || !descriptor.tools || !descriptor.tools.length) continue;
+    var tools = [];
+    for (var j = 0; j < descriptor.tools.length; j++) {
+      var toolDescriptor = descriptor.tools[j];
+      if (!toolDescriptor || !toolDescriptor.name) continue;
+      tools.push(sdk.tool(
+        toolDescriptor.name,
+        toolDescriptor.description || toolDescriptor.name,
+        buildZodShape(z, toolDescriptor.inputSchema),
+        createWorkerMcpToolHandler(descriptor.serverName, toolDescriptor.name)
+      ));
+    }
+    if (tools.length > 0) {
+      servers[descriptor.serverName] = sdk.createSdkMcpServer({
+        name: descriptor.serverName,
+        version: "1.0.0",
+        tools: tools,
+      });
+    }
+  }
+
+  return Object.keys(servers).length > 0 ? servers : null;
+}
+
 // --- IPC helpers ---
 function sendToDaemon(msg) {
   if (!conn || conn.destroyed) return;
@@ -127,6 +212,9 @@ function handleMessage(msg) {
     case "elicitation_response":
       handleElicitationResponse(msg);
       break;
+    case "mcp_tool_result":
+      handleMcpToolResult(msg);
+      break;
     case "warmup":
       handleWarmup(msg);
       break;
@@ -208,6 +296,17 @@ function handleElicitationResponse(msg) {
   }
 }
 
+function handleMcpToolResult(msg) {
+  var pending = pendingMcpToolCalls[msg.requestId];
+  if (!pending) return;
+  delete pendingMcpToolCalls[msg.requestId];
+  if (msg.error) {
+    pending.reject(new Error(msg.error));
+    return;
+  }
+  pending.resolve(msg.result);
+}
+
 // --- Query handling ---
 async function handleQueryStart(msg) {
   var t0 = msg._perfT0 || Date.now();
@@ -238,6 +337,15 @@ async function handleQueryStart(msg) {
   options.abortController = abortController;
   options.debug = true;
   options.debugFile = "/tmp/clay-cli-debug-" + process.pid + ".log";
+  if (options.mcpServerDescriptors && options.mcpServerDescriptors.length) {
+    try {
+      var mcpServers = buildMcpServersFromDescriptors(options.mcpServerDescriptors, sdk);
+      if (mcpServers) options.mcpServers = mcpServers;
+    } catch (e) {
+      console.error("[sdk-worker] Failed to build MCP servers:", e.message || e);
+    }
+    delete options.mcpServerDescriptors;
+  }
   // Override CLI subprocess spawn to inject NODE_OPTIONS for IPv4-first DNS.
   // The SDK constructs its own env for the CLI process, so worker env vars
   // like NODE_OPTIONS are not inherited. We intercept the spawn to fix this.

package/lib/yoke/adapters/claude.js

@@ -600,7 +600,7 @@ function spawnWorker(linuxUser, workerScriptPath, cwd) {
   worker.send = function(msg) {
     if (!worker.connection || worker.connection.destroyed) return;
     try {
-      worker.connection.write(JSON.stringify(msg) + "\n");
+      worker.connection.write(JSON.stringify(serializeWorkerValue(msg)) + "\n");
     } catch (e) {
       console.error("[yoke/claude] Failed to send to worker:", e.message);
     }
@@ -643,12 +643,45 @@ function cleanupWorker(worker) {
   worker.ready = false;
 }
 
+function serializeWorkerValue(value, seen) {
+  if (value == null) return value;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+  if (typeof value === "bigint") return String(value);
+  if (typeof value === "function" || typeof value === "symbol" || typeof value === "undefined") return undefined;
+  if (value instanceof Date) return value.toISOString();
+  if (Buffer.isBuffer(value)) return value.toString("base64");
+
+  if (!seen) seen = new WeakSet();
+  if (typeof value === "object") {
+    if (seen.has(value)) return undefined;
+    seen.add(value);
+  }
+
+  if (Array.isArray(value)) {
+    var arr = [];
+    for (var i = 0; i < value.length; i++) {
+      var item = serializeWorkerValue(value[i], seen);
+      if (item !== undefined) arr.push(item);
+    }
+    return arr;
+  }
+
+  var out = {};
+  var keys = Object.keys(value);
+  for (var j = 0; j < keys.length; j++) {
+    var key = keys[j];
+    var child = serializeWorkerValue(value[key], seen);
+    if (child !== undefined) out[key] = child;
+  }
+  return out;
+}
+
 // --- Worker QueryHandle ---
 // Wraps worker IPC into the same async iterable + control interface as the
 // in-process QueryHandle. This allows processQueryStream to iterate a worker
 // query identically to an in-process query.
 
-function createWorkerQueryHandle(worker, canUseTool, onElicitation) {
+function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool) {
   // Async iterable state
   var iterQueue = [];
   var iterWaiting = null;
@@ -741,6 +774,20 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation) {
         }
         break;
 
+      case "mcp_tool_call":
+        if (callMcpTool) {
+          callMcpTool(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 && e.message) ? e.message : String(e),
+            });
+          });
+        }
+        break;
+
       case "context_usage":
       case "model_changed":
       case "effort_changed":
@@ -1231,7 +1278,7 @@ function createClaudeAdapter(opts) {
     }
 
     // Create the worker query handle (sets up message handler on worker)
-    var handle = createWorkerQueryHandle(worker, queryOpts.canUseTool, queryOpts.onElicitation);
+    var handle = createWorkerQueryHandle(worker, queryOpts.canUseTool, queryOpts.onElicitation, queryOpts.callMcpTool);
 
     // Wait for worker to be ready before sending query_start
     if (!reusingWorker) {
@@ -1254,7 +1301,7 @@ function createClaudeAdapter(opts) {
     if (claudeOpts.allowDangerouslySkipPermissions) queryOptions.allowDangerouslySkipPermissions = true;
     if (claudeOpts.settings) queryOptions.settings = claudeOpts.settings;
 
-    if (queryOpts.toolServers) queryOptions.mcpServers = queryOpts.toolServers;
+    if (queryOpts.toolServerDescriptors) queryOptions.mcpServerDescriptors = queryOpts.toolServerDescriptors;
     if (queryOpts.model) queryOptions.model = queryOpts.model;
     if (queryOpts.effort) queryOptions.effort = queryOpts.effort;
     if (queryOpts.resumeSessionId) queryOptions.resume = queryOpts.resumeSessionId;

package/package.json

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