clay-server 4.7.0-beta.2 → 4.7.0-beta.4

package/lib/yoke/adapters/kiro.js

@@ -12,6 +12,7 @@
 //        session/request_permission requests for tool approvals.
 //   session/cancel (notif) -> interrupt the active turn
 
+var queryAbort = require("../query-abort");
 var { execFile } = require("child_process");
 var { KiroAcpServer, findKiroPath } = require("../kiro-acp-server");
 var INITIALIZE_TIMEOUT_MS = require("../interface").INITIALIZE_TIMEOUT_MS;
@@ -398,6 +399,12 @@ function createEventState(opts) {
 
 function createKiroQueryHandle(acp, queryOpts) {
   var abortController = queryOpts.abortController;
+  var cancellation = queryAbort.createAbortScope();
+  var removeAbort = function () {};
+  function send(method, params, timeout) {
+    cancellation.check();
+    return cancellation.wait(acp.send(method, params, timeout, cancellation.signal));
+  }
   var promptParts = [queryOpts.systemPrompt, queryOpts.appendSystemPrompt].filter(function (part) { return !!part; });
   var systemPrompt = promptParts.join("\n\n");
   var canUseTool = queryOpts.canUseTool || null;
@@ -436,6 +443,7 @@ function createKiroQueryHandle(acp, queryOpts) {
 
   function endIterator() {
     iteratorDone = true;
+    removeAbort();
     if (eventWaiting) {
       var resolve = eventWaiting;
       eventWaiting = null;
@@ -506,9 +514,10 @@ function createKiroQueryHandle(acp, queryOpts) {
         var meta = (tc.toolCallId && state.toolMeta[tc.toolCallId]) || {};
         var toolName = toolNameForKind(tc.kind || meta.kind, tc.title || meta.title);
         var toolInput = tc.rawInput || meta.rawInput || { title: tc.title || meta.title };
-        canUseTool(toolName, toolInput, {}).then(function(decision) {
-          acp.respond(msg.id, { outcome: { outcome: "selected", optionId: isApproved(decision) ? allowId : rejectId } });
+        cancellation.wait(Promise.resolve().then(function () { cancellation.check(); return canUseTool(toolName, toolInput, { signal: cancellation.signal }); })).then(function(decision) {
+          acp.respond(msg.id, isCancelled() ? { outcome: { outcome: "cancelled" } } : { outcome: { outcome: "selected", optionId: isApproved(decision) ? allowId : rejectId } });
         }).catch(function(err) {
+          if (isCancelled()) { acp.respond(msg.id, { outcome: { outcome: "cancelled" } }); return; }
           console.error("[yoke/kiro] canUseTool error:", err.message);
           acp.respond(msg.id, { outcome: { outcome: "selected", optionId: rejectId } });
         });
@@ -592,13 +601,13 @@ function createKiroQueryHandle(acp, queryOpts) {
   function setSessionModel(model) {
     if (!state.sessionId || !acp.started) return Promise.resolve();
     if (state.engine === "v3") {
-      return acp.send("session/set_config_option", {
+      return send("session/set_config_option", {
         sessionId: state.sessionId,
         configId: "model",
         value: model,
       }, 15000);
     }
-    return acp.send("session/set_model", { sessionId: state.sessionId, modelId: model }, 15000);
+    return send("session/set_model", { sessionId: state.sessionId, modelId: model }, 15000);
   }
 
   // --- Main query loop ---
@@ -638,12 +647,13 @@ function createKiroQueryHandle(acp, queryOpts) {
         handlerEntry.sessionId = state.sessionId;
         state.loadingSession = true;
         try {
-          await acp.send("session/load", {
+          await send("session/load", {
             sessionId: state.sessionId,
             cwd: queryOpts.cwd,
             mcpServers: queryOpts.mcpServers || [],
           }, 60000);
         } catch (e) {
+          if (isCancelled()) throw e;
           // If load fails (unknown session), fall back to a fresh session.
           console.warn("[yoke/kiro] session/load failed, starting fresh:", e.message);
           state.sessionId = null;
@@ -653,7 +663,7 @@ function createKiroQueryHandle(acp, queryOpts) {
         }
       }
       if (!state.sessionId) {
-        var newResult = await acp.send("session/new", {
+        var newResult = await send("session/new", {
           cwd: queryOpts.cwd,
           mcpServers: queryOpts.mcpServers || [],
         }, 60000);
@@ -664,7 +674,7 @@ function createKiroQueryHandle(acp, queryOpts) {
       // Kiro v3 defaults to autopilot, which bypasses permission requests.
       // Supervised mode is mandatory so every tool call reaches canUseTool.
       if (state.engine === "v3") {
-        await acp.send("session/set_config_option", {
+        await send("session/set_config_option", {
           sessionId: state.sessionId,
           configId: "autopilot",
           value: "off",
@@ -676,7 +686,7 @@ function createKiroQueryHandle(acp, queryOpts) {
         await setSessionModel(queryOpts.model).catch(function() {});
       }
       if (queryOpts.mode) {
-        await acp.send("session/set_mode", { sessionId: state.sessionId, modeId: queryOpts.mode }, 15000).catch(function() {});
+        await send("session/set_mode", { sessionId: state.sessionId, modeId: queryOpts.mode }, 15000).catch(function() {});
       }
 
       while (!isCancelled()) {
@@ -690,7 +700,7 @@ function createKiroQueryHandle(acp, queryOpts) {
         // Emit turn_start so the UI records a user turn boundary.
         pushEvent({ yokeType: "turn_start", uuid: generateUuid(), messageType: "user" });
 
-        var promptResult = await acp.send("session/prompt", {
+        var promptResult = await send("session/prompt", {
           sessionId: state.sessionId,
           prompt: input,
         }, 30 * 60 * 1000);
@@ -779,11 +789,17 @@ function createKiroQueryHandle(acp, queryOpts) {
 
     abort: function() {
       console.log("[yoke/kiro] handle.abort() sessionId=" + state.sessionId + " already=" + state.aborted);
+      if (state.aborted || iteratorDone) return;
       state.aborted = true;
-      if (state.sessionId && acp.started) {
-        // ACP cancellation is a notification; the in-flight session/prompt will
-        // resolve with stopReason "cancelled".
-        acp.notify("session/cancel", { sessionId: state.sessionId });
+      cancellation.stop();
+      handle.endInput();
+      messageQueue = [];
+      try {
+        if (state.sessionId && (!acp.started || acp.notify("session/cancel", { sessionId: state.sessionId }) === false)) {
+          throw new Error("ACP transport is disconnected");
+        }
+      } catch (error) {
+        pushEvent({ yokeType: "error", text: "Kiro cancellation could not be delivered: " + error.message });
       }
       endIterator();
     },
@@ -808,12 +824,7 @@ function createKiroQueryHandle(acp, queryOpts) {
     },
   };
 
-  if (abortController && abortController.signal) {
-    abortController.signal.addEventListener("abort", function() {
-      if (!state.aborted) handle.abort();
-    }, { once: true });
-  }
-
+  removeAbort = queryAbort.bindAbort(abortController, function () { handle.abort(); });
   return handle;
 }
 

package/lib/yoke/codex-turn-events.js

@@ -0,0 +1,32 @@
+// A resumed thread can still deliver notifications from its previous turn.
+// Only turn/start's response authorizes tagged output for this query's turn.
+function createTurnEvents(deliver) {
+  var active = false;
+  var starting = false;
+  var turnId = null;
+  var pending = [];
+  function idOf(message) {
+    var params = message.params || {};
+    return params.turnId || params.turn_id || (params.turn && params.turn.id) || null;
+  }
+  return {
+    begin: function () { active = true; starting = true; turnId = null; pending = []; },
+    accept: function (message) {
+      var id = idOf(message);
+      var scoped = id || /^(turn\/|item\/)/.test(message.method || '');
+      if (!scoped) return true;
+      if (!active) return false;
+      if (starting && id) { pending.push(message); return false; }
+      return !id || !turnId || id === turnId;
+    },
+    ready: function (id) {
+      turnId = id;
+      starting = false;
+      var buffered = pending;
+      pending = [];
+      buffered.forEach(function (message) { deliver(message); });
+    },
+    finish: function () { active = false; starting = false; pending = []; },
+  };
+}
+module.exports = { createTurnEvents: createTurnEvents };

package/lib/yoke/codex-turn-stop.js

@@ -0,0 +1,59 @@
+// Stop only the turn owned by this query, including an in-flight turn/start.
+function createTurnStop(server, onError) {
+  var turnId = null;
+  var threadId = null;
+  var starting = false;
+  var completed = false;
+  var stopped = false;
+  var sent = false;
+  var resolveStop = null;
+  var stopPromise = null;
+
+  function settle() {
+    if (resolveStop) { var resolve = resolveStop; resolveStop = null; resolve(); }
+  }
+
+  function interrupt() {
+    if (!stopped || sent) return;
+    if (!turnId) { if (!starting) settle(); return; }
+    sent = true;
+    var target = { threadId: threadId, turnId: turnId };
+    Promise.resolve().then(function () {
+      if (!server.started) throw new Error('Codex is disconnected; cancellation could not be confirmed.');
+      return server.send('turn/interrupt', target, 5000);
+    }).catch(function (error) {
+      onError(error);
+    }).finally(settle);
+  }
+
+  return {
+    begin: function (id) { threadId = id; turnId = null; starting = true; completed = false; sent = false; },
+    started: function (id) {
+      if (!id || turnId || completed) return;
+      turnId = id;
+      starting = false;
+      interrupt();
+    },
+    startSettled: function (id) {
+      starting = false;
+      if (id && !turnId && !completed) turnId = id;
+      interrupt();
+    },
+    completed: function (id) {
+      if (id && turnId && id !== turnId) return;
+      turnId = null;
+      completed = true;
+      starting = false;
+      if (!sent) settle();
+    },
+    abort: function () {
+      if (stopPromise) return stopPromise;
+      stopped = true;
+      stopPromise = new Promise(function (resolve) { resolveStop = resolve; });
+      interrupt();
+      return stopPromise;
+    },
+  };
+}
+
+module.exports = { createTurnStop: createTurnStop };

package/lib/yoke/query-abort.js

@@ -0,0 +1,40 @@
+// Query-local cancellation. Never terminates a shared provider process.
+function bindAbort(controller, abort) {
+  var signal = controller && controller.signal;
+  if (!signal) return function () {};
+  if (signal.aborted) { abort(); return function () {}; }
+  signal.addEventListener('abort', abort, { once: true });
+  return function () { signal.removeEventListener('abort', abort); };
+}
+
+function createAbortScope() {
+  var stopped = false;
+  var controller = new AbortController();
+  var waiting = new Set();
+  function error() { var err = new Error('Query cancelled'); err.name = 'AbortError'; return err; }
+  return {
+    signal: controller.signal,
+    stopped: function () { return stopped; },
+    wait: function (promise) {
+      return new Promise(function (resolve, reject) {
+        function cancel() { reject(error()); }
+        if (stopped) cancel();
+        else waiting.add(cancel);
+        Promise.resolve(promise).then(function (value) {
+          waiting.delete(cancel);
+          if (stopped) cancel(); else resolve(value);
+        }, function (err) { waiting.delete(cancel); reject(err); });
+      });
+    },
+    stop: function () {
+      if (stopped) return;
+      stopped = true;
+      controller.abort();
+      waiting.forEach(function (cancel) { cancel(); });
+      waiting.clear();
+    },
+    check: function () { if (stopped) throw error(); },
+  };
+}
+
+module.exports = { bindAbort: bindAbort, createAbortScope: createAbortScope };

package/lib/yoke/user-input-guidance.js

@@ -0,0 +1,11 @@
+// Required decisions use Clay's blocking question lifecycle in every Codex mode.
+function codexQuestionGuidance() {
+  return [
+    "When clarification materially changes task scope, targets, or intended behavior, use Clay's ask_user_questions tool (or its available MCP-qualified equivalent).",
+    "Present the question as a structured input card, not a question followed by bullet choices in ordinary chat. Await the tool result before work that depends on the answer.",
+    "Call the blocking question tool by itself; do not batch dependent actions alongside it or detach it into background work. request_user_input may be unavailable outside Plan mode, so use ask_user_questions in that case.",
+    "A cancelled, skipped, empty, or failed question is not an answer or approval. Do not infer a choice; leave dependent work pending and explain what answer is needed.",
+    "Do not ask again when the user has already answered or authorized the work. This question tool does not replace tool-permission enforcement."
+  ].join(" ");
+}
+module.exports = { codexQuestionGuidance: codexQuestionGuidance };

package/lib/yoke/user-input.js

@@ -219,7 +219,7 @@ function fallbackToolDefs(handler, options) {
     queryBound: true,
     description: initialLimit === 1
       ? "Ask the user exactly one structured question, wait for the answer, then call again if another question is needed. Use zero options for freeform or 2-6 options for choices; never one option."
-      : "Ask the user 1-3 structured questions. Use zero options for freeform or 2-6 options for choices; never one option.",
+      : "Ask the user 1-3 structured questions and wait for their answers before continuing dependent work. Use this for scope or target decisions; do not substitute prose questions or asynchronous notifications. A cancelled or skipped question is not an answer. Use zero options for freeform or 2-6 options for choices; never one option.",
     inputSchema: buildQuestionShape(initialLimit),
     handler: function (input) {
       if (questionLimit(options) === 1 && input && Array.isArray(input.questions) && input.questions.length !== 1) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clay-server",
-  "version": "4.7.0-beta.2",
+  "version": "4.7.0-beta.4",
   "description": "Self-hosted team workspace for Claude Code and Codex. Multi-user, browser-based, with persistent AI mates.",
   "bin": {
     "clay-server": "./bin/cli.js"