clay-server 3.3.2-beta.2 → 3.4.0-beta.1

package/lib/public/opencode-avatar.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="OpenCode">
+  <rect width="64" height="64" rx="16" fill="#111814"/>
+  <path d="m26 19-13 13 13 13M38 19l13 13-13 13" fill="none" stroke="#78e08f" stroke-width="6" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

package/lib/sdk-bridge.js

@@ -129,7 +129,7 @@ function createSDKBridge(opts) {
   var _cachedFreshAuthState = null;
   var _cachedFreshAuthAt = 0;
 
-  function getKiroMcpServers(session) {
+  function getAcpMcpServers(session) {
     if (!session) return [];
     var bridgeArgs = [
       path.join(__dirname, "yoke", "mcp-bridge-server.js"),
@@ -1525,13 +1525,16 @@ function createSDKBridge(opts) {
           sandboxMode: codexConfig.sandbox,
           webSearchMode: codexConfig.webSearch,
         },
+        ACP: {
+          mcpServers: getAcpMcpServers(session),
+        },
         KIRO: {
           engine: kiroConfig.engine,
           mode: kiroConfig.mode,
           // ACP accepts additional stdio MCP servers per session. The bridge is
           // bound to this Clay session so partner calls cannot leak across
           // concurrent Kiro sessions or users.
-          mcpServers: getKiroMcpServers(session),
+          mcpServers: getAcpMcpServers(session),
         },
       },
     };
@@ -1787,6 +1790,19 @@ function createSDKBridge(opts) {
     } catch (e) {}
     if ((codexBin && fs.existsSync(codexBin)) || tryLookup(yoke.getVendorInfo("codex").binaryName)) result.push("codex");
 
+    var acpVendorKeys = ["gemini", "opencode"];
+    var acpProfiles = require("./yoke/acp-agent-profiles");
+    for (var acpVendorIndex = 0; acpVendorIndex < acpVendorKeys.length; acpVendorIndex++) {
+      var acpVendor = acpVendorKeys[acpVendorIndex];
+      var acpInfo = yoke.getVendorInfo(acpVendor);
+      if (!linuxUser || acpInfo.osUserIsolation) {
+        var acpProfile = acpProfiles.getAcpAgentProfile(acpVendor);
+        if (acpProfiles.findAcpAgentPath(acpProfile)) result.push(acpVendor);
+      } else {
+        console.log("[sdk-bridge] " + acpInfo.displayName + " hidden for OS-isolated user " + linuxUser + ": per-user spawning is not implemented");
+      }
+    }
+
     // Kiro has no per-user ACP spawn path yet. Do not advertise the daemon's
     // binary to an OS-isolated user, even if that user also has Kiro installed.
     var kiroInfo = yoke.getVendorInfo("kiro");

package/lib/yoke/acp-agent-profiles.js

@@ -0,0 +1,188 @@
+// ACP Agent Drivers
+// -----------------
+// Vendor-specific facts and optional hooks for agents that implement ACP.
+// Static profiles are sufficient for standard agents; richer runtimes can add
+// hooks without forcing YOKE down to ACP's least-common-denominator feature set.
+
+var fs = require("fs");
+var execFile = require("child_process").execFile;
+var execFileSync = require("child_process").execFileSync;
+
+function findOnPath(binaryName, overrideName) {
+  var overridePath = overrideName && process.env[overrideName];
+  if (overridePath && fs.existsSync(overridePath)) return overridePath;
+  try {
+    var command = process.platform === "win32" ? "where" : "which";
+    var out = execFileSync(command, [binaryName], {
+      timeout: 3000,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return out.trim().split(/\r?\n/)[0] || null;
+  } catch (e) {
+    return null;
+  }
+}
+
+function fetchOpenCodeModels(binaryPath, cwd) {
+  return new Promise(function(resolve) {
+    execFile(binaryPath, ["models"], {
+      cwd: cwd || process.cwd(),
+      timeout: 20000,
+      maxBuffer: 4 * 1024 * 1024,
+    }, function(err, stdout) {
+      if (err || !stdout) { resolve([]); return; }
+      var seen = {};
+      var models = [];
+      var lines = String(stdout).split(/\r?\n/);
+      for (var i = 0; i < lines.length; i++) {
+        var value = lines[i].trim();
+        if (!value || seen[value]) continue;
+        seen[value] = true;
+        models.push(value);
+      }
+      resolve(models);
+    });
+  });
+}
+
+function fetchOpenCodeResolvedConfig(binaryPath, cwd, env) {
+  return new Promise(function(resolve, reject) {
+    execFile(binaryPath, ["debug", "config"], {
+      cwd: cwd || process.cwd(),
+      env: Object.assign({}, process.env, env || {}),
+      timeout: 30000,
+      maxBuffer: 4 * 1024 * 1024,
+    }, function(err, stdout) {
+      if (err) { reject(err); return; }
+      try {
+        resolve(JSON.parse(String(stdout || "{}")));
+      } catch (e) {
+        reject(new Error("OpenCode returned invalid resolved configuration"));
+      }
+    });
+  });
+}
+
+function fetchOpenCodeAgentNames(binaryPath, cwd, env) {
+  return fetchOpenCodeResolvedConfig(binaryPath, cwd, env).then(function(config) {
+    return Object.keys(config.agent || {});
+  });
+}
+
+function isSafeOpenCodePermission(value) {
+  if (value === "ask" || value === "deny") return true;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  var keys = Object.keys(value);
+  if (!keys.length) return false;
+  for (var i = 0; i < keys.length; i++) {
+    if (!isSafeOpenCodePermission(value[keys[i]])) return false;
+  }
+  return true;
+}
+
+function validateOpenCodeConfig(config) {
+  if (!config || config.permission !== "ask") {
+    throw new Error("OpenCode resolved configuration does not preserve global ask permissions");
+  }
+  var agents = config.agent || {};
+  var names = Object.keys(agents);
+  for (var i = 0; i < names.length; i++) {
+    var agent = agents[names[i]] || {};
+    if (agent.permission === undefined) continue;
+    if (!isSafeOpenCodePermission(agent.permission)) {
+      throw new Error("OpenCode agent has unsafe resolved permissions: " + names[i]);
+    }
+  }
+}
+
+var ACP_AGENT_PROFILES = {
+  gemini: {
+    vendor: "gemini",
+    displayName: "Gemini CLI",
+    binaryName: "gemini",
+    overrideName: "GEMINI_CLI_PATH",
+    args: ["--acp", "--approval-mode=default"],
+    defaultModels: ["auto"],
+    defaultModel: "auto",
+    // Gemini advertises loadSession, but releases through 0.46.0 could load
+    // the transcript without restoring the model's conversation memory.
+    // Keep resume gated until Clay's live contract test proves it reliable.
+    sessionResume: false,
+    permissionModeGuaranteed: true,
+  },
+  opencode: {
+    vendor: "opencode",
+    displayName: "OpenCode",
+    binaryName: "opencode",
+    overrideName: "OPENCODE_CLI_PATH",
+    args: ["acp"],
+    defaultModels: ["auto"],
+    defaultModel: "auto",
+    sessionResume: null,
+    fetchModels: fetchOpenCodeModels,
+    permissionModeGuaranteed: true,
+    prepare: function(ctx) {
+      var injected = ctx.initOpts && ctx.initOpts._openCodeAgentNames;
+      if (Array.isArray(injected)) {
+        ctx.driverState.agentNames = injected.slice();
+        return;
+      }
+      return fetchOpenCodeAgentNames(ctx.binaryPath, ctx.cwd, ctx.initOpts && ctx.initOpts.env).then(function(names) {
+        ctx.driverState.agentNames = names;
+      });
+    },
+    buildProcessOptions: function(ctx, base) {
+      var existing = (base.env && base.env.OPENCODE_CONFIG_CONTENT) || process.env.OPENCODE_CONFIG_CONTENT;
+      var config = {};
+      if (existing) config = JSON.parse(existing);
+      var agent = Object.assign({}, config.agent || {});
+      var names = ["build", "plan"].concat(ctx.driverState.agentNames || []);
+      for (var i = 0; i < names.length; i++) {
+        agent[names[i]] = Object.assign({}, agent[names[i]] || {}, { permission: "ask" });
+      }
+      base.env = Object.assign({}, base.env || {}, {
+        OPENCODE_CONFIG_CONTENT: JSON.stringify(Object.assign({}, config, { permission: "ask", agent: agent })),
+      });
+      return base;
+    },
+    validateProcessOptions: function(ctx) {
+      var injected = ctx.initOpts && ctx.initOpts._openCodeResolvedConfig;
+      var resolved = injected
+        ? Promise.resolve(injected)
+        : fetchOpenCodeResolvedConfig(ctx.binaryPath, ctx.cwd, ctx.processOptions.env);
+      return resolved.then(function(config) {
+        validateOpenCodeConfig(config);
+      });
+    },
+    ensureSafePermissionMode: function() {
+      // OpenCode ACP modes select agents, not approval policy. The process
+      // configuration above enforces ask at both global and effective-agent levels.
+      return Promise.resolve();
+    },
+  },
+};
+
+function getAcpAgentProfile(vendor) {
+  return ACP_AGENT_PROFILES[vendor] || null;
+}
+
+function getAcpAgentDriver(vendor) {
+  return getAcpAgentProfile(vendor);
+}
+
+function findAcpAgentPath(profile) {
+  if (!profile) return null;
+  return findOnPath(profile.binaryName, profile.overrideName);
+}
+
+module.exports = {
+  ACP_AGENT_PROFILES: ACP_AGENT_PROFILES,
+  getAcpAgentProfile: getAcpAgentProfile,
+  getAcpAgentDriver: getAcpAgentDriver,
+  findAcpAgentPath: findAcpAgentPath,
+  fetchOpenCodeModels: fetchOpenCodeModels,
+  fetchOpenCodeAgentNames: fetchOpenCodeAgentNames,
+  fetchOpenCodeResolvedConfig: fetchOpenCodeResolvedConfig,
+  validateOpenCodeConfig: validateOpenCodeConfig,
+};

package/lib/yoke/acp-driver-runtime.js

@@ -0,0 +1,50 @@
+// ACP Vendor Driver Runtime
+// -------------------------
+// ACP supplies defaults. Trusted vendor drivers may extend or replace them so
+// the shared protocol never becomes the ceiling of the richer YOKE contract.
+
+function hasHook(driver, name) {
+  return !!(driver && typeof driver[name] === "function");
+}
+
+function call(driver, name, context, fallback) {
+  if (hasHook(driver, name)) return driver[name](context, fallback);
+  return fallback ? fallback() : undefined;
+}
+
+function callAsync(driver, name, context, fallback) {
+  try {
+    return Promise.resolve(call(driver, name, context, fallback));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+}
+
+function mergeCapabilities(driver, context, base) {
+  var defaults = Object.assign({}, base);
+  if (!hasHook(driver, "extendCapabilities")) return defaults;
+  var extended = driver.extendCapabilities(context, Object.assign({}, defaults));
+  return Object.assign({}, defaults, extended || {});
+}
+
+function buildParams(driver, hookName, context, base) {
+  var defaults = Object.assign({}, base);
+  if (!hasHook(driver, hookName)) return defaults;
+  var result = driver[hookName](context, Object.assign({}, defaults));
+  return result === undefined || result === null ? defaults : result;
+}
+
+function normalizeEvents(driver, context, fallback) {
+  var result = call(driver, "normalizeUpdate", context, fallback);
+  if (result === undefined || result === null) return [];
+  return Array.isArray(result) ? result : [result];
+}
+
+module.exports = {
+  hasHook: hasHook,
+  call: call,
+  callAsync: callAsync,
+  mergeCapabilities: mergeCapabilities,
+  buildParams: buildParams,
+  normalizeEvents: normalizeEvents,
+};

package/lib/yoke/acp-event-normalizer.js

@@ -0,0 +1,179 @@
+// ACP Event Normalizer
+// --------------------
+// Converts standard session/update payloads to stable YOKE events.
+
+function toolNameForKind(kind, title) {
+  switch (kind) {
+    case "execute": return "Bash";
+    case "read": return "Read";
+    case "edit": return "Edit";
+    case "delete": return "Edit";
+    case "move": return "Edit";
+    case "search": return "Grep";
+    case "fetch": return "WebFetch";
+    case "think": return "Think";
+    default: return title || "Tool";
+  }
+}
+
+function createEventState(opts) {
+  opts = opts || {};
+  return {
+    vendor: opts.vendor || "acp",
+    blockCounter: 0,
+    textBlockOpen: false,
+    textBlockId: null,
+    thinkBlockOpen: false,
+    thinkBlockId: null,
+    toolBlocks: {},
+    toolMeta: {},
+    toolContent: {},
+    lastInputTokens: null,
+    contextWindow: opts.contextWindow || null,
+    configOptions: [],
+  };
+}
+
+function extractContent(content) {
+  if (!Array.isArray(content)) return "";
+  var parts = [];
+  for (var i = 0; i < content.length; i++) {
+    var item = content[i];
+    if (!item) continue;
+    if (item.type === "content" && item.content && typeof item.content.text === "string") {
+      parts.push(item.content.text);
+    } else if (item.type === "diff") {
+      parts.push((item.path ? "--- " + item.path + "\n" : "") + (item.newText || ""));
+    } else if (typeof item.text === "string") {
+      parts.push(item.text);
+    }
+  }
+  return parts.join("\n");
+}
+
+function finalToolContent(state, callId, update) {
+  if (callId && state.toolContent[callId]) return state.toolContent[callId];
+  var direct = extractContent(update.content);
+  if (direct) return direct;
+  if (typeof update.rawOutput === "string") return update.rawOutput;
+  if (update.rawOutput && typeof update.rawOutput.output === "string") return update.rawOutput.output;
+  return "";
+}
+
+function normalizeStatus(status) {
+  if (status === "in_progress" || status === "inProgress") return "in_progress";
+  if (status === "completed") return "completed";
+  return "pending";
+}
+
+function normalizeAcpUpdate(update, state) {
+  var events = [];
+  if (!update) return events;
+  var type = update.sessionUpdate;
+
+  if (type === "agent_message_chunk") {
+    var text = update.content && typeof update.content.text === "string" ? update.content.text : "";
+    if (!state.textBlockOpen) {
+      state.textBlockOpen = true;
+      state.textBlockId = "blk_" + (++state.blockCounter);
+      events.push({ yokeType: "text_start", blockId: state.textBlockId });
+    }
+    if (text) events.push({ yokeType: "text_delta", blockId: state.textBlockId, text: text });
+    return events;
+  }
+
+  if (type === "agent_thought_chunk") {
+    var thought = update.content && typeof update.content.text === "string" ? update.content.text : "";
+    if (!state.thinkBlockOpen) {
+      state.thinkBlockOpen = true;
+      state.thinkBlockId = "blk_" + (++state.blockCounter);
+      events.push({ yokeType: "thinking_start", blockId: state.thinkBlockId });
+    }
+    if (thought) events.push({ yokeType: "thinking_delta", blockId: state.thinkBlockId, text: thought });
+    return events;
+  }
+
+  if (type === "tool_call" || type === "tool_call_update") {
+    var callId = update.toolCallId;
+    var name = toolNameForKind(update.kind, update.title);
+    if (callId && update.kind) {
+      state.toolMeta[callId] = { kind: update.kind, title: update.title, rawInput: update.rawInput || {} };
+    }
+    if (callId && !state.toolBlocks[callId]) {
+      state.toolBlocks[callId] = "blk_" + (++state.blockCounter);
+      events.push({ yokeType: "tool_start", blockId: state.toolBlocks[callId], toolId: callId, toolName: name });
+      events.push({ yokeType: "tool_executing", blockId: state.toolBlocks[callId], toolId: callId, toolName: name, input: update.rawInput || {} });
+    }
+    var chunk = extractContent(update.content);
+    if (callId && chunk) state.toolContent[callId] = (state.toolContent[callId] || "") + chunk;
+    if (update.status === "completed" || update.status === "failed") {
+      events.push({
+        yokeType: "tool_result",
+        blockId: state.toolBlocks[callId],
+        toolId: callId,
+        content: finalToolContent(state, callId, update),
+        isError: update.status === "failed",
+      });
+    }
+    return events;
+  }
+
+  if (type === "plan") {
+    var entries = Array.isArray(update.entries) ? update.entries : [];
+    events.push({
+      yokeType: "plan_updated",
+      title: "Plan",
+      explanation: "",
+      plan: entries.map(function(entry) {
+        return { step: entry.content || "", status: normalizeStatus(entry.status) };
+      }),
+    });
+    return events;
+  }
+
+  if (type === "usage_update") {
+    if (typeof update.used === "number") state.lastInputTokens = update.used;
+    if (typeof update.size === "number") state.contextWindow = update.size;
+    return events;
+  }
+
+  if (type === "config_option_update") {
+    state.configOptions = Array.isArray(update.configOptions) ? update.configOptions : [];
+    return events;
+  }
+
+  events.push({
+    yokeType: "runtime_specific",
+    vendor: state.vendor,
+    eventType: "session/update:" + type,
+    raw: update,
+  });
+  return events;
+}
+
+function closeOpenBlocks(state) {
+  var events = [];
+  if (state.thinkBlockOpen) {
+    events.push({ yokeType: "thinking_stop", blockId: state.thinkBlockId });
+    state.thinkBlockOpen = false;
+  }
+  return events;
+}
+
+function resetTurnState(state) {
+  state.textBlockOpen = false;
+  state.textBlockId = null;
+  state.thinkBlockOpen = false;
+  state.thinkBlockId = null;
+  state.toolBlocks = {};
+  state.toolMeta = {};
+  state.toolContent = {};
+}
+
+module.exports = {
+  createEventState: createEventState,
+  normalizeAcpUpdate: normalizeAcpUpdate,
+  closeOpenBlocks: closeOpenBlocks,
+  resetTurnState: resetTurnState,
+  toolNameForKind: toolNameForKind,
+};