clay-server 5.2.0-beta.1 → 5.2.0-beta.10

package/lib/yoke/adapters/codex.js

@@ -1343,6 +1343,8 @@ function createCodexQueryHandle(appServer, queryOpts) {
       return { threadId: state.threadId, revision: inputRevision };
     },
 
+    getRecoveryThreadId: function() { return state.threadId || queryOpts.resumeSessionId || null; },
+
     retireIdleForRecovery: function() {
       handle.endInput();
       return loopFinished;
@@ -1461,11 +1463,23 @@ function createCodexAdapter(opts) {
   var _refCount = 0;
   var _lastActiveAt = Date.now();
   var _shuttingDown = false;
+  var _recoveryIdleShutdown = null;
   var _activeQueries = [];
-  var _recoveryHandoff = null;
-  var _recoveryRuntimes = [];
-  var _recoveryCleanup = Promise.resolve();
-  var _recoveryCleanupTasks = [];
+  var recoveryAdmission = require("../codex-recovery-admission").attachRecoveryAdmission({
+    state: function() { return { epoch: _shutdownEpoch, shuttingDown: _shuttingDown, retiring: _recoveryIdleShutdown === _shutdownEpoch,
+      initializing: _initializing, refCount: _refCount, server: _appServer, entries: _activeQueries.slice() }; },
+    shutdownError: createShutdownError,
+    stopIdle: async function() {
+      _recoveryIdleShutdown = _shutdownEpoch;
+      try { return await adapter.shutdownIfIdle(0); }
+      finally { _recoveryIdleShutdown = null; }
+    },
+    createRuntime: function(queryOpts) {
+      return createCodexAdapter(Object.assign({}, _defaultInitOpts, {
+        recoveryRuntime: true, recoverySessionMcpServer: queryOpts.sessionMcpServer,
+      }));
+    },
+  });
 
   function scopedSkillOptions(env) {
     if (!_runtimeLinuxUser) return { env: env };
@@ -1541,102 +1555,6 @@ function createCodexAdapter(opts) {
     updateLastActiveAt();
   }
 
-  function retainRecoveryRuntime(runtime) {
-    _recoveryRuntimes.push(runtime);
-  }
-
-  function removeRecoveryRuntime(runtime) {
-    var next = [];
-    for (var i = 0; i < _recoveryRuntimes.length; i++) {
-      if (_recoveryRuntimes[i] !== runtime) next.push(_recoveryRuntimes[i]);
-    }
-    _recoveryRuntimes = next;
-  }
-
-  function cleanupRecoveryRuntime(runtime) {
-    for (var i = 0; i < _recoveryCleanupTasks.length; i++) {
-      if (_recoveryCleanupTasks[i].runtime === runtime) return _recoveryCleanupTasks[i].promise;
-    }
-    var task = { runtime: runtime, promise: null };
-    _recoveryCleanupTasks.push(task);
-    var priorCleanup = _recoveryCleanup;
-    task.promise = Promise.resolve(priorCleanup).catch(function() {
-      return null;
-    }).then(function() {
-      return runtime.shutdown();
-    }).catch(function(error) {
-      console.error("[yoke/codex] Isolated recovery runtime shutdown failed:", error.message || error);
-    }).then(function() {
-      removeRecoveryRuntime(runtime);
-      var remainingTasks = [];
-      for (var ti = 0; ti < _recoveryCleanupTasks.length; ti++) {
-        if (_recoveryCleanupTasks[ti] !== task) remainingTasks.push(_recoveryCleanupTasks[ti]);
-      }
-      _recoveryCleanupTasks = remainingTasks;
-    });
-    _recoveryCleanup = task.promise;
-    return task.promise;
-  }
-
-  function shutdownRecoveryRuntimes() {
-    var runtimes = _recoveryRuntimes.slice();
-    if (!runtimes.length) return _recoveryCleanup;
-    return Promise.all(runtimes.map(function(runtime) {
-      return cleanupRecoveryRuntime(runtime);
-    })).then(function() {
-      _recoveryRuntimes = [];
-    });
-  }
-
-  async function createIsolatedRecoveryQuery(queryOpts) {
-    var shutdownEpoch = _shutdownEpoch;
-    function checkCurrent() {
-      idleRecovery.checkAbort(queryOpts);
-      if (_shuttingDown || shutdownEpoch !== _shutdownEpoch) throw createShutdownError();
-    }
-    var releaseHandoff;
-    var priorHandoff = _recoveryHandoff;
-    var myHandoff = new Promise(function(resolve) { releaseHandoff = resolve; });
-    _recoveryHandoff = myHandoff;
-    await (priorHandoff || Promise.resolve());
-    try {
-      await _recoveryCleanup;
-      checkCurrent();
-      if (!_initializing && _refCount > 0) {
-        await idleRecovery.retireIdleQueries(_activeQueries.slice(), _appServer, checkCurrent);
-      }
-      checkCurrent();
-      if (_refCount > 0 || _initializing) {
-        throw new Error("Codex resumed-tool recovery is waiting for an active shared runtime; retry after its current queries finish.");
-      }
-      if (_appServer) {
-        var stopped = await adapter.shutdownIfIdle(0);
-        if (!stopped) throw new Error("Codex resumed-tool recovery could not safely release the shared runtime; retry after its current queries finish.");
-      }
-      checkCurrent();
-      var recoveryRuntime = createCodexAdapter(Object.assign({}, _defaultInitOpts, {
-        recoveryRuntime: true,
-        recoverySessionMcpServer: queryOpts.sessionMcpServer,
-      }));
-      retainRecoveryRuntime(recoveryRuntime);
-      var recoveryOpts = Object.assign({}, queryOpts, {
-        isolatedRecovery: true,
-        onRuntimeFinished: function() {
-          return cleanupRecoveryRuntime(recoveryRuntime);
-        },
-      });
-      try {
-        return await recoveryRuntime.createQuery(recoveryOpts);
-      } catch (error) {
-        await cleanupRecoveryRuntime(recoveryRuntime);
-        throw error;
-      }
-    } finally {
-      releaseHandoff();
-      if (_recoveryHandoff === myHandoff) _recoveryHandoff = null;
-    }
-  }
-
   function buildReadyResponse(skillNames) {
     return {
       models: _cachedModels,
@@ -1764,6 +1682,7 @@ function createCodexAdapter(opts) {
   var adapter = {
     vendor: "codex",
     queryBoundToolCapability: CODEX_QUERY_BOUND_TOOL_CAPABILITY,
+    queryContract: require("./codex-query-contract"),
     userInputCapability: { mode: "native", native: true, transport: "item/tool/requestUserInput" },
 
     init: function(initOpts) {
@@ -1777,12 +1696,14 @@ function createCodexAdapter(opts) {
       if (_runtimeLinuxUser && requestedLinuxUser && requestedLinuxUser !== _runtimeLinuxUser) {
         return Promise.reject(new Error("Codex runtime user mismatch"));
       }
-      if (_shuttingDown) {
+      if (_shuttingDown && _recoveryIdleShutdown !== _shutdownEpoch) {
         return Promise.reject(createShutdownError());
       }
-      if (_recoveryHandoff) {
+      try { recoveryAdmission.checkSharedExit(); }
+      catch (error) { return Promise.reject(error); }
+      if (recoveryAdmission.pending()) {
         var initEpoch = _shutdownEpoch;
-        return _recoveryHandoff.then(function() {
+        return recoveryAdmission.pending().then(function() {
           if (initEpoch !== _shutdownEpoch) throw createShutdownError();
           return adapter.init(initOpts);
         });
@@ -1963,6 +1884,10 @@ function createCodexAdapter(opts) {
       return null;
     },
 
+    retireIdleForRecovery: function(checkCurrent) {
+      return idleRecovery.retireIdleQueries(_activeQueries.slice(), _appServer, checkCurrent);
+    },
+
     createQuery: async function(queryOpts) {
       var requestedLinuxUser = queryOpts && queryOpts.linuxUser;
       if (!_runtimeLinuxUser && requestedLinuxUser) {
@@ -1974,28 +1899,37 @@ function createCodexAdapter(opts) {
       if (_runtimeLinuxUser && requestedLinuxUser && requestedLinuxUser !== _runtimeLinuxUser) {
         throw new Error("Codex runtime user mismatch");
       }
-      if (_shuttingDown) {
+      if (_shuttingDown && _recoveryIdleShutdown !== _shutdownEpoch) {
         throw createShutdownError();
       }
       if (queryOpts && queryOpts.sessionMcpServer && queryOpts.resumeSessionId && !queryOpts.isolatedRecovery) {
-        return createIsolatedRecoveryQuery(queryOpts);
+        return recoveryAdmission.createQuery(queryOpts);
       }
       var queryEpoch = _shutdownEpoch;
+      function checkAdmission() {
+        idleRecovery.checkAbort(queryOpts || {});
+        if ((_shuttingDown && _recoveryIdleShutdown !== _shutdownEpoch) || queryEpoch !== _shutdownEpoch) throw createShutdownError();
+      }
       // Recheck after every await: recovery may replace the runtime while an
       // ordinary start is waiting for initialization or an earlier handoff.
       while (true) {
         idleRecovery.checkAbort(queryOpts || {});
-        if (_shuttingDown || queryEpoch !== _shutdownEpoch) throw createShutdownError();
-        if (_recoveryHandoff) {
-          await _recoveryHandoff;
+        if ((_shuttingDown && _recoveryIdleShutdown !== _shutdownEpoch) || queryEpoch !== _shutdownEpoch) throw createShutdownError();
+        recoveryAdmission.checkSharedExit();
+        if (recoveryAdmission.pending()) {
+          await idleRecovery.wait(recoveryAdmission.pending(), checkAdmission);
+          continue;
+        }
+        if (queryOpts.resumeSessionId && recoveryAdmission.hasTarget(queryOpts.resumeSessionId)) {
+          await recoveryAdmission.waitForTarget(queryOpts);
           continue;
         }
         if (_initializing && _initPromise) {
-          await _initPromise;
+          await idleRecovery.wait(_initPromise, checkAdmission);
           continue;
         }
         if (!_appServer || !_appServer.started) {
-          await adapter.init(queryOpts || {});
+          await idleRecovery.wait(adapter.init(queryOpts || {}), checkAdmission);
           continue;
         }
         break;
@@ -2174,12 +2108,20 @@ function createCodexAdapter(opts) {
     },
 
     // Shutdown the app-server process
+    shutdownForRecovery: async function() {
+      var proc = _appServer && _appServer.proc;
+      await adapter.shutdown();
+      if (proc && proc.exitCode === null && proc.signalCode === null) {
+        throw new Error('Codex recovery runtime exit could not be confirmed; its thread remains reserved.');
+      }
+    },
+
     shutdown: function() {
       _shutdownEpoch++;
       return Promise.all([
         beginShutdown(true),
         shutdownUserRuntimes("shutdown"),
-        shutdownRecoveryRuntimes(),
+        recoveryAdmission.shutdown(),
       ]).then(function() { return true; });
     },
 

package/lib/yoke/adapters/kiro.js

@@ -279,7 +279,7 @@ function flattenUpdate(update, state) {
 
   // Token usage
   if (type === "usage_update") {
-    if (typeof update.used === "number") state.lastInputTokens = update.used;
+    if (typeof update.used === "number") { state.lastInputTokens = update.used; state.contextMeasurement = "observed"; }
     if (typeof update.size === "number") state.contextWindow = update.size;
     return events;
   }
@@ -294,6 +294,7 @@ function flattenUpdate(update, state) {
       if (typeof percentage !== "number") percentage = kiroMeta.usagePercentage;
       if (typeof percentage === "number" && state.contextWindow) {
         state.lastInputTokens = Math.round(state.contextWindow * percentage / 100);
+        state.contextMeasurement = "estimated";
       }
     }
     return events;
@@ -782,6 +783,7 @@ function createKiroQueryHandle(acp, queryOpts) {
     getContextUsage: function() {
       return Promise.resolve(state.lastInputTokens != null ? {
         input_tokens: state.lastInputTokens,
+        measurement: state.contextMeasurement || "observed",
         contextWindow: state.contextWindow || null,
       } : null);
     },

package/lib/yoke/adapters/muse-query-contract.js

@@ -0,0 +1,7 @@
+// Muse's sessionMcp configuration is supplied on both start and resume.
+module.exports = {
+  toolTransport: "stdio-mcp",
+  catalogLifetime: "query",
+  permissionModes: ["auto"],
+  interruptionMessage: "Interrupted · What should Muse do instead?",
+};

package/lib/yoke/adapters/muse.js

@@ -0,0 +1,122 @@
+var museQuery = require("../muse-query");
+var runtimeTools = require("../muse-runtime");
+var findMusePath = require("../providers/muse-executable").resolve;
+
+function createMuseAdapter(opts) {
+  opts = opts || {};
+  var adapter = {
+    vendor: "muse",
+    userInputCapability: { mode: "native", native: true },
+    providerContract: require("../vendor-registry").getVendorInfo("muse"),
+    queryContract: require("./muse-query-contract"),
+    cwd: opts.cwd || process.cwd(),
+    binaryPath: opts._binaryPath || null,
+    sdkPromise: null,
+    catalog: [],
+    clients: new Set(),
+    handles: new Set(),
+    shuttingDown: false,
+    requestTimeoutMs: opts._requestTimeoutMs || 9e4,
+    titleTimeoutMs: opts._titleTimeoutMs || 15e3,
+    shutdownTimeoutMs: opts._shutdownTimeoutMs == null ? 1e3 : opts._shutdownTimeoutMs
+  };
+  adapter.loadSdk = function() {
+    if (opts._sdk) return Promise.resolve(opts._sdk);
+    if (!adapter.sdkPromise) adapter.sdkPromise = import("@muse-code/sdk");
+    return adapter.sdkPromise;
+  };
+  adapter.init = async function(initOpts) {
+    if (opts.osUsers || opts.linuxUser || initOpts && (initOpts.linuxUser || initOpts.osUsers)) throw new Error("Muse Code does not support OS-owner isolation");
+    if (!adapter.binaryPath) adapter.binaryPath = findMusePath();
+    if (!adapter.binaryPath) throw new Error("Muse Code binary not found: muse. Install Muse Code or set MUSE_CODE_PATH.");
+    await adapter.loadSdk();
+    return {
+      models: [],
+      defaultModel: null,
+      skills: [],
+      slashCommands: [],
+      fastModeState: null,
+      capabilities: {
+        effort: true,
+        midSessionModelSwitch: true,
+        fork: true,
+        rollback: false,
+        sessionListing: true,
+        sessionRename: true,
+        thinking: true,
+        betas: false,
+        rewind: false,
+        sessionResume: true,
+        promptSuggestions: false,
+        elicitation: false,
+        fileCheckpointing: false,
+        contextCompacting: true,
+        queryBoundTools: {
+          mode: "stdio-mcp",
+          source: "@muse-code/sdk SessionConfig.mcpServers"
+        },
+        skillSharing: true,
+        toolPolicy: [ "ask", "allow-all" ]
+      }
+    };
+  };
+  adapter.supportedModels = async function() {
+    if (adapter.shuttingDown) throw new Error("Muse Code adapter is shutting down");
+    if (!adapter.binaryPath) await adapter.init();
+    var sdk = await adapter.loadSdk();
+    if (adapter.shuttingDown) throw new Error("Muse Code adapter is shutting down");
+    var runtime = runtimeTools.createRuntime(adapter, sdk, {
+      command: adapter.binaryPath,
+      args: [ "serve" ],
+      cwd: adapter.cwd,
+      env: Object.assign({}, process.env)
+    });
+    runtime.fail = function(error) {
+      runtime.close().catch(function(closeError) {
+        adapter.lastCloseError = closeError;
+      });
+    };
+    try {
+      var spawned = await runtime.initialize();
+      adapter.catalog = runtimeTools.normalizeCatalog(await runtime.waitRequest(spawned.connection.request("model/list", {})));
+      return adapter.catalog.slice();
+    } finally {
+      await runtime.close();
+    }
+  };
+  adapter.createToolServer = function() {
+    return null;
+  };
+  adapter.createQuery = async function(queryOpts) {
+    if (opts.osUsers || opts.linuxUser || queryOpts && queryOpts.linuxUser) throw new Error("Muse Code does not support OS-owner isolation");
+    if (!adapter.binaryPath) await adapter.init(queryOpts || {});
+    if (adapter.shuttingDown) throw new Error("Muse Code adapter is shutting down");
+    return museQuery.createMuseQueryHandle(adapter, queryOpts || {});
+  };
+  adapter.generateTitle = function(messages, titleOpts) {
+    return require("../title-query").generateTitle(adapter, messages, Object.assign({}, titleOpts, { timeoutMs: adapter.titleTimeoutMs }),
+      { skipProjectInstructions: true, skipSkills: true, adapterOptions: { MUSE: { readOnly: true, mcpServers: [] } } });
+  };
+  adapter.shutdown = async function() {
+    adapter.shuttingDown = true;
+    var results = await Promise.allSettled(Array.from(adapter.handles).map(function(handle) {
+      return handle.close();
+    }).concat(Array.from(adapter.clients).map(function(runtime) {
+      return runtime.close();
+    })));
+    var failed = results.find(function(result) {
+      return result.status === "rejected";
+    });
+    if (failed) throw failed.reason;
+    return true;
+  };
+  require("../muse-services").attach(adapter);
+  return adapter;
+}
+
+module.exports = {
+  createMuseAdapter: createMuseAdapter,
+  findMusePath: findMusePath,
+  isAuthError: runtimeTools.isAuthError,
+  chooseApprovalDecision: require("../muse-policy").chooseApprovalDecision
+};

package/lib/yoke/auth-events.js

@@ -0,0 +1,17 @@
+function loginPrompt(event, preview, provider) {
+  if (event.cost && event.cost !== 0 || String(preview || '').length >= 100) return false;
+  var text = String(preview || '').trim();
+  if (/not logged in/i.test(text) && /\/login/i.test(text)) return true;
+  var policy = require('./provider-contract').resolve(provider);
+  return typeof policy.authenticationReply === 'function' && policy.authenticationReply(text);
+}
+function authenticationReply(text) { return /^Failed to authenticate: OAuth session expired and could not be refreshed\.?$/i.test(text); }
+function isAuthenticationError(detail) {
+  var text = String(detail || '').toLowerCase();
+  return /not logged in|unauthenticated|authentication|sign in|log in|please login/.test(text);
+}
+function normalize(event, preview, provider) {
+  if (!event || event.yokeType !== "result") return event;
+  return Object.assign({}, event, { authenticationRequired: event.authenticationRequired === true || loginPrompt(event, preview, provider) });
+}
+module.exports = { normalize: normalize, loginPrompt: loginPrompt, authenticationReply: authenticationReply, isAuthenticationError: isAuthenticationError };