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

package/lib/project-file-watch.js

@@ -21,12 +21,22 @@ function attachFileWatch(ctx) {
   // one browser tab silently replace another tab's live preview subscription.
   var fileWatchers = new Map();
 
+  function settleFileWatchReady(entry, ready) {
+    if (!entry || !entry.resolveReady) return;
+    var resolve = entry.resolveReady;
+    entry.resolveReady = null;
+    resolve(ready);
+  }
+
   function closeFileWatch(key) {
     var entry = fileWatchers.get(key);
     if (!entry) return;
     clearTimeout(entry.debounce);
+    if (entry.reconcile) clearImmediate(entry.reconcile);
+    if (entry.pollTimer) clearInterval(entry.pollTimer);
     try { entry.watcher.close(); } catch (e) {}
     fileWatchers.delete(key);
+    settleFileWatchReady(entry, false);
   }
 
   function sendFileChanged(client, message) {
@@ -37,6 +47,36 @@ function attachFileWatch(ctx) {
     }
   }
 
+  function readFileSnapshot(absPath) {
+    var stat = fs.statSync(absPath);
+    var ext = path.extname(absPath).toLowerCase();
+    if (stat.size > FS_MAX_SIZE || BINARY_EXTS.has(ext)) return null;
+    return { content: fs.readFileSync(absPath, "utf8"), size: stat.size };
+  }
+
+  function publishFileChanged(key, client, relPath, absPath) {
+    var latest = fileWatchers.get(key);
+    if (!latest || latest.relPath !== relPath) return;
+    try {
+      var snapshot = readFileSnapshot(absPath);
+      if (!snapshot) return;
+      if (latest.hasSnapshot && latest.content === snapshot.content && latest.size === snapshot.size) return;
+      latest.hasSnapshot = true;
+      latest.content = snapshot.content;
+      latest.size = snapshot.size;
+      sendFileChanged(client, {
+        type: "fs_file_changed",
+        path: relPath,
+        content: snapshot.content,
+        size: snapshot.size,
+      });
+    } catch (e) {
+      // Atomic saves can briefly remove the destination path between rename
+      // events. Keep the parent watcher alive for the next event.
+      if (e.code !== "ENOENT") closeFileWatch(key);
+    }
+  }
+
   function startFileWatch(client, relPath) {
     // Preserve the old single-argument API for callers outside the websocket
     // file browser. They share one legacy subscription.
@@ -45,10 +85,10 @@ function attachFileWatch(ctx) {
       client = null;
     }
     var absPath = safePath(cwd, relPath);
-    if (!absPath) return;
+    if (!absPath) return Promise.resolve(false);
     var key = client || "_legacy";
     var existing = fileWatchers.get(key);
-    if (existing && existing.relPath === relPath) return;
+    if (existing && existing.relPath === relPath) return existing.ready;
     closeFileWatch(key);
 
     // Watch the parent directory rather than the file inode. Editors and agent
@@ -56,6 +96,8 @@ function attachFileWatch(ctx) {
     // misses later edits even though the path still exists.
     var parentPath = path.dirname(absPath);
     var baseName = path.basename(absPath);
+    var initialSnapshot = null;
+    try { initialSnapshot = readFileSnapshot(absPath); } catch (e) {}
     try {
       var watcher = fs.watch(parentPath, function (eventType, filename) {
         if (filename && String(filename) !== baseName) return;
@@ -63,25 +105,44 @@ function attachFileWatch(ctx) {
         if (!active || active.relPath !== relPath) return;
         clearTimeout(active.debounce);
         active.debounce = setTimeout(function () {
-          var latest = fileWatchers.get(key);
-          if (!latest || latest.relPath !== relPath) return;
-          try {
-            var stat = fs.statSync(absPath);
-            var ext = path.extname(absPath).toLowerCase();
-            if (stat.size > FS_MAX_SIZE || BINARY_EXTS.has(ext)) return;
-            var content = fs.readFileSync(absPath, "utf8");
-            sendFileChanged(client, { type: "fs_file_changed", path: relPath, content: content, size: stat.size });
-          } catch (e) {
-            // Atomic saves can briefly remove the destination path between
-            // rename events. Keep the parent watcher alive for the next event.
-            if (e.code !== "ENOENT") closeFileWatch(key);
-          }
+          publishFileChanged(key, client, relPath, absPath);
         }, 200);
       });
-      fileWatchers.set(key, { watcher: watcher, relPath: relPath, debounce: null });
+      var resolveReady = null;
+      var ready = new Promise(function (resolve) { resolveReady = resolve; });
+      var entry = {
+        watcher: watcher,
+        relPath: relPath,
+        debounce: null,
+        reconcile: null,
+        pollTimer: null,
+        ready: ready,
+        resolveReady: resolveReady,
+        hasSnapshot: !!initialSnapshot,
+        content: initialSnapshot ? initialSnapshot.content : null,
+        size: initialSnapshot ? initialSnapshot.size : null,
+      };
+      fileWatchers.set(key, entry);
+      // Directory events are the low-latency path, but macOS can coalesce or
+      // drop them under load. Periodic content reconciliation is the source of
+      // truth and also survives atomic replacements with identical metadata.
+      entry.pollTimer = setInterval(function () {
+        publishFileChanged(key, client, relPath, absPath);
+      }, 1000);
+      // fs.watch has no readiness event. Reconcile once on the next event-loop
+      // turn so a change between the initial read and native watcher activation
+      // cannot leave the browser showing stale content.
+      entry.reconcile = setImmediate(function () {
+        var active = fileWatchers.get(key);
+        if (active) active.reconcile = null;
+        publishFileChanged(key, client, relPath, absPath);
+        if (fileWatchers.get(key) === entry) settleFileWatchReady(entry, true);
+      });
       watcher.on("error", function () { closeFileWatch(key); });
+      return ready;
     } catch (e) {
       closeFileWatch(key);
+      return Promise.resolve(false);
     }
   }
 

package/lib/public/css/input.css

@@ -799,6 +799,10 @@
 .vendor-toggle-label {
   pointer-events: none;
 }
+@media (min-width: 901px) {
+  .vendor-toggle-btn:not(.active) .vendor-toggle-label { display: none; }
+  .vendor-toggle-btn:not(.active) { padding: 0 8px; }
+}
 @media (max-width: 900px) {
   .vendor-toggle-label { display: none; }
   .vendor-toggle-btn { padding: 0 8px; }

package/lib/public/css/mates.css

@@ -682,6 +682,7 @@
 .mate-vendor-label {
   pointer-events: none;
 }
+.mate-vendor-btn:not(.active) .mate-vendor-label { display: none; }
 
 /* Collapse button inside mate header: white to match header style */
 .mate-sidebar-header .sidebar-collapse-btn {

package/lib/public/gemini-avatar.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="Gemini CLI">
+  <defs>
+    <linearGradient id="g" x1="8" y1="56" x2="56" y2="8" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#4f7cff"/>
+      <stop offset="0.5" stop-color="#9b5cff"/>
+      <stop offset="1" stop-color="#ff65b3"/>
+    </linearGradient>
+  </defs>
+  <rect width="64" height="64" rx="16" fill="#10131d"/>
+  <path d="M32 8c2.3 14.1 9.9 21.7 24 24-14.1 2.3-21.7 9.9-24 24-2.3-14.1-9.9-21.7-24-24 14.1-2.3 21.7-9.9 24-24Z" fill="url(#g)"/>
+</svg>

package/lib/public/index.html

@@ -527,6 +527,14 @@
                   <img src="/codex-avatar.png" class="vendor-toggle-icon" alt="Codex">
                   <span class="vendor-toggle-label">Codex</span>
                 </button>
+                <button id="vendor-btn-gemini" class="vendor-toggle-btn" data-vendor="gemini">
+                  <img src="/gemini-avatar.svg" class="vendor-toggle-icon" alt="Gemini">
+                  <span class="vendor-toggle-label">Gemini CLI</span>
+                </button>
+                <button id="vendor-btn-opencode" class="vendor-toggle-btn" data-vendor="opencode">
+                  <img src="/opencode-avatar.svg" class="vendor-toggle-icon" alt="OpenCode">
+                  <span class="vendor-toggle-label">OpenCode</span>
+                </button>
                 <button id="vendor-btn-kiro" class="vendor-toggle-btn" data-vendor="kiro">
                   <img src="/kiro-avatar.svg" class="vendor-toggle-icon" alt="Kiro">
                   <span class="vendor-toggle-label">Kiro CLI</span>

package/lib/public/modules/app-panels.js

@@ -89,6 +89,8 @@ var EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 var EFFORT_LEVELS_BY_VENDOR = {
   claude: ["low", "medium", "high", "xhigh", "max"],
   codex: ["minimal", "low", "medium", "high", "xhigh"],
+  gemini: [],
+  opencode: [],
   kiro: ["low", "medium", "high", "xhigh", "max"],
 };
 var THINKING_OPTIONS = ["disabled", "adaptive", "budget"];
@@ -441,8 +443,16 @@ export function initPanels() {
   var vendorToggleWrap = $("vendor-toggle-wrap");
   var vendorBtnClaude = $("vendor-btn-claude");
   var vendorBtnCodex = $("vendor-btn-codex");
+  var vendorBtnGemini = $("vendor-btn-gemini");
+  var vendorBtnOpenCode = $("vendor-btn-opencode");
   var vendorBtnKiro = $("vendor-btn-kiro");
-  var vendorBtns = { claude: vendorBtnClaude, codex: vendorBtnCodex, kiro: vendorBtnKiro };
+  var vendorBtns = {
+    claude: vendorBtnClaude,
+    codex: vendorBtnCodex,
+    gemini: vendorBtnGemini,
+    opencode: vendorBtnOpenCode,
+    kiro: vendorBtnKiro,
+  };
 
   function updateVendorToggle() {
     var installed = store.get('installedVendors') || [];
@@ -471,6 +481,8 @@ export function initPanels() {
 
   if (vendorBtnClaude) vendorBtnClaude.addEventListener("click", function() { onVendorClick("claude"); });
   if (vendorBtnCodex) vendorBtnCodex.addEventListener("click", function() { onVendorClick("codex"); });
+  if (vendorBtnGemini) vendorBtnGemini.addEventListener("click", function() { onVendorClick("gemini"); });
+  if (vendorBtnOpenCode) vendorBtnOpenCode.addEventListener("click", function() { onVendorClick("opencode"); });
   if (vendorBtnKiro) vendorBtnKiro.addEventListener("click", function() { onVendorClick("kiro"); });
 
   // --- Reactive UI sync ---

package/lib/public/modules/app-rendering.js

@@ -19,21 +19,27 @@ import { getScheduledMsgEl } from './app-rate-limit.js';
 export var VENDOR_AVATARS = {
   claude: "/claude-code-avatar.png",
   codex: "/codex-avatar.png",
+  gemini: "/gemini-avatar.svg",
+  opencode: "/opencode-avatar.svg",
   kiro: "/kiro-avatar.svg",
 };
 export var VENDOR_NAMES = {
   claude: "Claude Code",
   codex: "Codex",
+  gemini: "Gemini CLI",
+  opencode: "OpenCode",
   kiro: "Kiro CLI",
 };
 // Display order for every vendor Clay knows about, installed or not. Pickers
 // render the full list so a missing CLI reads as "not installed yet" rather
 // than "Clay doesn't support it".
-export var VENDOR_ORDER = ["claude", "codex", "kiro"];
+export var VENDOR_ORDER = ["claude", "codex", "gemini", "opencode", "kiro"];
 // Where to send the user when they pick a vendor whose CLI isn't installed.
 export var VENDOR_HOMEPAGES = {
   claude: "https://claude.com/product/claude-code",
   codex: "https://openai.com/codex/",
+  gemini: "https://github.com/google-gemini/gemini-cli",
+  opencode: "https://opencode.ai/",
   kiro: "https://kiro.dev/",
 };
 var NEW_MSG_BTN_DEFAULT = "\u2193 Latest";

package/lib/public/modules/mate-sidebar.js

@@ -149,9 +149,15 @@ export function showMateSidebar(mateId, mateData) {
   if (mateVendorWrap) {
     var available = store.get('availableVendors') || [];
     var mateVendor = mateData.vendor || "claude";
-    var vendorIcons = { claude: "/claude-code-avatar.png", codex: "/codex-avatar.png", kiro: "/kiro-avatar.svg" };
-    var vendorNames = { claude: "Claude Code", codex: "Codex", kiro: "Kiro CLI" };
-    var vendorKeys = ["claude", "codex", "kiro"];
+    var vendorIcons = {
+      claude: "/claude-code-avatar.png",
+      codex: "/codex-avatar.png",
+      gemini: "/gemini-avatar.svg",
+      opencode: "/opencode-avatar.svg",
+      kiro: "/kiro-avatar.svg",
+    };
+    var vendorNames = { claude: "Claude Code", codex: "Codex", gemini: "Gemini CLI", opencode: "OpenCode", kiro: "Kiro CLI" };
+    var vendorKeys = ["claude", "codex", "gemini", "opencode", "kiro"];
     mateVendorWrap.innerHTML = "";
     for (var vi = 0; vi < vendorKeys.length; vi++) {
       var vk = vendorKeys[vi];

package/lib/public/modules/sidebar-mates.js

@@ -457,7 +457,13 @@ export function renderUserStrip(allUsers, onlineUserIds, myUserId, dmFavorites,
       // Tooltip
       var displayName = mp.displayName || mate.name || "New Mate";
       var mateVendor = mate.vendor || "claude";
-      var vendorLabels = { claude: "Claude Code", codex: "OpenAI Codex", kiro: "Kiro CLI" };
+      var vendorLabels = {
+        claude: "Claude Code",
+        codex: "OpenAI Codex",
+        gemini: "Gemini CLI",
+        opencode: "OpenCode",
+        kiro: "Kiro CLI",
+      };
       el.addEventListener("mouseenter", function () {
         var html = '<div style="font-weight:600">' + escapeHtml(displayName);
         if (mate.primary) {

package/lib/public/modules/tools.js

@@ -814,7 +814,13 @@ function resolvePermissionIdentity(mateId, vendor) {
     }
   }
   // Project chat: use vendor name and avatar
-  var vendorAvatars = { claude: "/claude-code-avatar.png", codex: "/codex-avatar.png", kiro: "/kiro-avatar.svg" };
+  var vendorAvatars = {
+    claude: "/claude-code-avatar.png",
+    codex: "/codex-avatar.png",
+    gemini: "/gemini-avatar.svg",
+    opencode: "/opencode-avatar.svg",
+    kiro: "/kiro-avatar.svg",
+  };
   var vendorName = (vendor && VENDOR_NAMES[vendor]) || VENDOR_NAMES.claude;
   return {
     name: vendorName,

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,
+};