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

package/lib/yoke/acp-query-handle.js

@@ -1,29 +1,33 @@
 // Shared ACP Query Handle
 // -----------------------
 // Implements the YOKE QueryHandle contract with standard ACP session methods.
-
 var normalizer = require("./acp-event-normalizer");
 var driverRuntime = require("./acp-driver-runtime");
-
+var queryAbort = require("./query-abort");
 var uuidCounter = 0;
 function generateUuid(vendor) {
   uuidCounter++;
   return (vendor || "acp") + "-" + Date.now().toString(36) + "-" + uuidCounter.toString(36);
 }
-
 function isAuthError(value) {
   return /not logged in|sign in|log ?in|authenticate|authentication|credentials|unauthorized|forbidden|\b401\b/i.test(String(value || ""));
 }
-
 function isApproved(decision) {
   return decision === true || (decision && decision.behavior === "allow");
 }
-
 function createAcpQueryHandle(acp, queryOpts) {
   queryOpts = queryOpts || {};
   var vendor = queryOpts.vendor || "acp";
   var driver = queryOpts.driver || null;
   var abortController = queryOpts.abortController;
+  var cancellation = queryAbort.createAbortScope();
+  var removeAbort = function () {};
+  var pendingPermissions = new Set();
+  var stopDelivery = Promise.resolve();
+  function send(method, params, timeout) {
+    cancellation.check();
+    return cancellation.wait(acp.send(method, params, timeout, cancellation.signal));
+  }
   var canUseTool = queryOpts.canUseTool || null;
   var state = normalizer.createEventState({ vendor: vendor, contextWindow: queryOpts.contextWindow });
   state.sessionId = queryOpts.resumeSessionId || null;
@@ -76,6 +80,7 @@ function createAcpQueryHandle(acp, queryOpts) {
   function endIterator() {
     if (iteratorDone) return;
     iteratorDone = true;
+    removeAbort();
     if (eventWaiting) {
       var resolve = eventWaiting;
       eventWaiting = null;
@@ -128,7 +133,19 @@ function createAcpQueryHandle(acp, queryOpts) {
       return;
     }
 
+    var answered = false;
+    function cancelPermission() {
+      if (answered) return;
+      answered = true;
+      pendingPermissions.delete(cancelPermission);
+      acp.respond(msg.id, { outcome: { outcome: "cancelled" } });
+    }
+    pendingPermissions.add(cancelPermission);
     function respond(allowed) {
+      if (answered) return;
+      if (isCancelled()) { cancelPermission(); return; }
+      answered = true;
+      pendingPermissions.delete(cancelPermission);
       var optionId = allowed ? allowId : rejectId;
       if (!optionId) {
         acp.respond(msg.id, { outcome: { outcome: "cancelled" } });
@@ -160,7 +177,7 @@ function createAcpQueryHandle(acp, queryOpts) {
       input: input,
       options: options,
     }), function() { return { toolName: toolName, input: input }; }) || { toolName: toolName, input: input };
-    Promise.resolve(canUseTool(permission.toolName || toolName, permission.input || input, {})).then(function(decision) {
+    Promise.resolve(canUseTool(permission.toolName || toolName, permission.input || input, { signal: cancellation.signal })).then(function(decision) {
       respond(isApproved(decision));
     }).catch(function(err) {
       console.error("[yoke/" + vendor + "] canUseTool error:", err.message || err);
@@ -193,7 +210,7 @@ function createAcpQueryHandle(acp, queryOpts) {
     if (!state.sessionId || !acp.started || value === undefined || value === null) return Promise.resolve();
     var option = configOptionFor(category, fallbackId);
     if (option) {
-      return acp.send("session/set_config_option", {
+      return send("session/set_config_option", {
         sessionId: state.sessionId,
         configId: option.id,
         value: value,
@@ -202,7 +219,7 @@ function createAcpQueryHandle(acp, queryOpts) {
       });
     }
     if (category === "mode") {
-      return acp.send("session/set_mode", { sessionId: state.sessionId, modeId: value }, 15000);
+      return send("session/set_mode", { sessionId: state.sessionId, modeId: value }, 15000);
     }
     return Promise.reject(new Error("ACP session does not expose configuration option: " + fallbackId));
   }
@@ -230,7 +247,7 @@ function createAcpQueryHandle(acp, queryOpts) {
       if (safeModeValue([modes.currentModeId])) return Promise.resolve();
       var safeMode = safeModeValue(modes.availableModes || []);
       if (!safeMode) return Promise.reject(new Error("ACP agent started in an unsafe permission mode and exposed no supervised mode"));
-      return acp.send("session/set_mode", { sessionId: state.sessionId, modeId: safeMode }, 15000);
+      return send("session/set_mode", { sessionId: state.sessionId, modeId: safeMode }, 15000);
     }
     if (driver && driver.permissionModeGuaranteed === true) return Promise.resolve();
     return Promise.reject(new Error("ACP agent did not expose a verifiable supervised permission mode"));
@@ -302,6 +319,7 @@ function createAcpQueryHandle(acp, queryOpts) {
   }
 
   function applySessionResult(result) {
+    cancellation.check();
     result = result || {};
     if (result.sessionId) state.sessionId = result.sessionId;
     if (Array.isArray(result.configOptions)) state.configOptions = result.configOptions;
@@ -313,7 +331,7 @@ function createAcpQueryHandle(acp, queryOpts) {
   async function openDefaultSession(handlerEntry) {
     if (state.sessionId && queryOpts.canResumeSession) {
       handlerEntry.sessionId = state.sessionId;
-      var resumed = await acp.send("session/resume", buildSessionParams("resume", {
+      var resumed = await send("session/resume", buildSessionParams("resume", {
         sessionId: state.sessionId,
         cwd: queryOpts.cwd,
         mcpServers: queryOpts.mcpServers || [],
@@ -324,7 +342,7 @@ function createAcpQueryHandle(acp, queryOpts) {
       handlerEntry.sessionId = state.sessionId;
       state.loadingSession = true;
       try {
-        var loaded = await acp.send("session/load", buildSessionParams("load", {
+        var loaded = await send("session/load", buildSessionParams("load", {
           sessionId: state.sessionId,
           cwd: queryOpts.cwd,
           mcpServers: queryOpts.mcpServers || [],
@@ -336,7 +354,7 @@ function createAcpQueryHandle(acp, queryOpts) {
     }
 
     state.sessionId = null;
-    var result = await acp.send("session/new", buildSessionParams("new", {
+    var result = await send("session/new", buildSessionParams("new", {
       cwd: queryOpts.cwd,
       mcpServers: queryOpts.mcpServers || [],
     }), 60000);
@@ -355,7 +373,7 @@ function createAcpQueryHandle(acp, queryOpts) {
         sessionId: state.sessionId,
         prompt: asPrompt(message),
       });
-      return acp.send("session/prompt", params, 30 * 60 * 1000);
+      return send("session/prompt", params, 30 * 60 * 1000);
     });
   }
 
@@ -363,17 +381,17 @@ function createAcpQueryHandle(acp, queryOpts) {
     var currentMessage = prependSystemPrompt(initialMessage);
     var handlerEntry = acp.addHandler(handleServerEvent);
     try {
-      var sessionResult = await openSession(handlerEntry);
+      var sessionResult = await cancellation.wait(openSession(handlerEntry));
       handlerEntry.sessionId = state.sessionId;
-      await driverRuntime.callAsync(driver, "afterSessionOpen", driverContext({ sessionResult: sessionResult }), function() {});
-      await ensureSafePermissionMode();
+      await cancellation.wait(driverRuntime.callAsync(driver, "afterSessionOpen", driverContext({ sessionResult: sessionResult }), function() {}));
+      await cancellation.wait(ensureSafePermissionMode());
       if (state.model && state.model !== "auto") await setModel(state.model);
       if (queryOpts.mode) await setConfig("mode", "mode", queryOpts.mode);
 
       while (!isCancelled()) {
         normalizer.resetTurnState(state);
         pushEvent({ yokeType: "turn_start", uuid: generateUuid(vendor), messageType: "user" });
-        var result = await prompt(currentMessage);
+        var result = await cancellation.wait(prompt(currentMessage));
         var closing = normalizer.closeOpenBlocks(state);
         for (var i = 0; i < closing.length; i++) pushEvent(closing[i]);
         if (isCancelled() || (result && result.stopReason === "cancelled")) {
@@ -395,6 +413,7 @@ function createAcpQueryHandle(acp, queryOpts) {
           : { yokeType: "error", text: message });
       }
     } finally {
+      await stopDelivery;
       acp.removeHandler(handlerEntry);
       state.done = true;
       endIterator();
@@ -448,36 +467,29 @@ function createAcpQueryHandle(acp, queryOpts) {
       }; });
     },
     abort: function() {
+      if (state.aborted || iteratorDone) return;
       state.aborted = true;
-      driverRuntime.call(driver, "cancel", driverContext(), function() {
-        if (state.sessionId && acp.started) acp.notify("session/cancel", { sessionId: state.sessionId });
-      });
-      endIterator();
-    },
-    close: function() {
-      messageQueueEnded = true;
-      if (messageWaiting) {
-        var resolve = messageWaiting;
-        messageWaiting = null;
-        resolve(null);
-      }
-      endIterator();
+      cancellation.stop();
+      handle.endInput();
+      messageQueue = [];
+      pendingPermissions.forEach(function (cancel) { try { cancel(); } catch (e) {} });
+      stopDelivery = driverRuntime.callAsync(driver, "cancel", driverContext(), function() {
+        if (state.sessionId && (!acp.started || acp.notify("session/cancel", { sessionId: state.sessionId }) === false)) {
+          throw new Error("ACP transport is disconnected");
+        }
+      }).catch(function (error) {
+        pushEvent({ yokeType: "error", text: "Cancellation could not be delivered: " + error.message });
+      }).finally(endIterator);
+      return stopDelivery;
     },
+    close: function() { handle.endInput(); endIterator(); },
     endInput: function() {
       messageQueueEnded = true;
-      if (messageWaiting) {
-        var resolve = messageWaiting;
-        messageWaiting = null;
-        resolve(null);
-      }
+      if (messageWaiting) { var resolve = messageWaiting; messageWaiting = null; resolve(null); }
     },
   };
 
-  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/adapters/antigravity.js

@@ -1,3 +1,4 @@
+var bindAbort = require("../query-abort").bindAbort;
 var childProcess = require("child_process");
 var readline = require("readline");
 var skillDiscovery = require("../skill-discovery");
@@ -75,6 +76,9 @@ function toolName(name) {
 
 function createAntigravityQueryHandle(binaryPath, queryOpts, onFinished) {
   var processHandle = null;
+  var removeAbort = function () {};
+  var killTimer = null;
+  var processExited = false;
   var outputReader = null;
   var events = [];
   var eventWaiter = null;
@@ -115,6 +119,7 @@ function createAntigravityQueryHandle(binaryPath, queryOpts, onFinished) {
   function endEvents() {
     if (ended) return;
     ended = true;
+    removeAbort();
     if (eventWaiter) {
       var resolve = eventWaiter;
       eventWaiter = null;
@@ -252,6 +257,8 @@ function createAntigravityQueryHandle(binaryPath, queryOpts, onFinished) {
       endEvents();
     });
     processHandle.on("exit", function(code, signal) {
+      processExited = true;
+      if (killTimer) clearTimeout(killTimer);
       if (!ended && activeTurn) {
         var message = stderr.trim() || "Antigravity CLI exited before completing the turn";
         pushEvent(isAuthError(message)
@@ -309,8 +316,24 @@ function createAntigravityQueryHandle(binaryPath, queryOpts, onFinished) {
     },
     abort: function() {
       if (ended) return;
+      inputEnded = true;
+      messages = [];
       pushEvent({ yokeType: "interrupted" });
-      if (processHandle) processHandle.kill("SIGINT");
+      if (processHandle && !processExited) {
+        try { processHandle.kill("SIGINT"); } catch (error) {
+          pushEvent({ yokeType: "error", text: "Could not interrupt Antigravity: " + error.message });
+        }
+        if (!processExited) {
+          killTimer = setTimeout(function () {
+            if (!processExited) {
+              try { processHandle.kill("SIGKILL"); } catch (error) {
+                console.error("[yoke/antigravity] Could not terminate stopped query:", error.message);
+              }
+            }
+          }, 5000);
+          killTimer.unref();
+        }
+      }
       endEvents();
     },
     close: function() {
@@ -319,6 +342,7 @@ function createAntigravityQueryHandle(binaryPath, queryOpts, onFinished) {
       endEvents();
     },
   };
+  removeAbort = bindAbort(queryOpts.abortController, function () { handle.abort(); });
   return handle;
 }
 

package/lib/yoke/adapters/claude.js

@@ -4,6 +4,7 @@
 // This is the ONLY file (besides claude-worker.js) that imports the SDK.
 // Also manages worker processes for OS-level user isolation.
 
+var bindQueryAbort = require("../query-abort").bindAbort;
 var path = require("path");
 var fs = require("fs");
 var os = require("os");
@@ -576,6 +577,7 @@ function normalizeBackgroundTasks(tasks) {
 function createQueryHandle(rawQuery, messageQueue, abortController) {
   var correlation = claudeCorrelation.createCorrelation();
   var closed = false;
+  var removeAbort = function () {};
   var handle = {
     // Opaque adapter state (null for in-process queries)
     _adapterState: null,
@@ -586,11 +588,12 @@ function createQueryHandle(rawQuery, messageQueue, abortController) {
       return {
         next: function() {
           return rawIter.next().then(function(result) {
-            if (result.done) closed = true;
+            if (result.done) { closed = true; removeAbort(); }
             if (result.done) return result;
             return { value: correlation.result(result.value, flattenEvent(result.value)), done: false };
           }, function(err) {
             closed = true;
+            removeAbort();
             throw err;
           });
         },
@@ -684,6 +687,7 @@ function createQueryHandle(rawQuery, messageQueue, abortController) {
 
     abort: function() {
       closed = true;
+      try { messageQueue.end(); } catch (e) {}
       if (abortController) {
         try { abortController.abort(); } catch (e) {}
       }
@@ -691,6 +695,7 @@ function createQueryHandle(rawQuery, messageQueue, abortController) {
 
     close: function() {
       closed = true;
+      removeAbort();
       try { messageQueue.end(); } catch (e) {}
       if (rawQuery && typeof rawQuery.close === "function") {
         try { rawQuery.close(); } catch (e) {}
@@ -712,6 +717,10 @@ function createQueryHandle(rawQuery, messageQueue, abortController) {
     },
   };
 
+  removeAbort = bindQueryAbort(abortController, function () {
+    closed = true;
+    try { messageQueue.end(); } catch (e) {}
+  });
   return handle;
 }
 
@@ -1043,6 +1052,7 @@ function serializeWorkerValue(value, seen) {
 // query identically to an in-process query.
 
 function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool, onUserDialog, onUserInputRequest, onModelSwitch, preToolUsePolicy) {
+  var interactionAbort = new AbortController();
   var contextRequests = claudeContextUsage.createRequests(worker);
   var correlation = claudeCorrelation.createCorrelation();
   // Async iterable state
@@ -1085,6 +1095,7 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
   }
 
   function endIter() {
+    interactionAbort.abort();
     contextRequests.close();
     if (iterEnded) return;
     iterEnded = true;
@@ -1096,6 +1107,7 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
   }
 
   function errorIter(err) {
+    interactionAbort.abort();
     contextRequests.close();
     if (iterEnded) return;
     iterEnded = true;
@@ -1122,8 +1134,9 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
             decisionReason: msg.decisionReason,
             defaultToNo: msg.defaultToNo === true,
             suppressAlwaysAllowRule: msg.suppressAlwaysAllowRule === true,
-            signal: { addEventListener: function() {} },
+            signal: interactionAbort.signal,
           }).then(function(result) {
+            if (interactionAbort.signal.aborted) result = { behavior: "deny", message: "Query cancelled" };
             worker.send({ type: "permission_response", requestId: msg.requestId, result: result });
           }).catch(function(e) {
             console.error("[yoke/claude] permission_response send failed:", e.message || e);
@@ -1149,8 +1162,9 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
         if (onUserInputRequest) {
           claudeUserInput.ask(onUserInputRequest, msg.input, {
             toolUseID: msg.toolUseId,
-            signal: { addEventListener: function() {} },
+            signal: interactionAbort.signal,
           }).then(function(result) {
+            if (interactionAbort.signal.aborted) return;
             worker.send({ type: "ask_user_response", toolUseId: msg.toolUseId, result: result });
           }).catch(function(e) {
             console.error("[yoke/claude] ask_user_response send failed:", e.message || e);
@@ -1171,12 +1185,13 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
           var workerElicitation = onUserInputRequest
             ? claudeUserInput.elicitation(onUserInputRequest, workerElicitationRequest, {
               requestId: msg.requestId,
-              signal: { addEventListener: function() {} },
+              signal: interactionAbort.signal,
             })
             : onElicitation(workerElicitationRequest, {
-            signal: { addEventListener: function() {} },
+            signal: interactionAbort.signal,
           });
           workerElicitation.then(function(result) {
+            if (interactionAbort.signal.aborted) return;
             worker.send({ type: "elicitation_response", requestId: msg.requestId, result: result });
           }).catch(function(e) {
             console.error("[yoke/claude] elicitation_response send failed:", e.message || e);
@@ -1191,8 +1206,9 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
             payload: msg.payload || {},
             toolUseID: msg.toolUseId || undefined,
           }, {
-            signal: { addEventListener: function() {} },
+            signal: interactionAbort.signal,
           }).then(function(result) {
+            if (interactionAbort.signal.aborted) return;
             worker.send({ type: "user_dialog_response", requestId: msg.requestId, result: result });
           }).catch(function(e) {
             console.error("[yoke/claude] user_dialog_response send failed:", e.message || e);
@@ -1327,7 +1343,7 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
     getSubmittedMessageCount: correlation.submitted,
 
     pushMessage: function(text, images) {
-      if (iterEnded || (worker.process && (worker.process.killed || worker.process.exitCode != null))) return false;
+      if (iterEnded || worker._abortSent || (worker.process && (worker.process.killed || worker.process.exitCode != null))) return false;
       var content = [];
       if (images && images.length > 0) {
         for (var i = 0; i < images.length; i++) {
@@ -1417,8 +1433,10 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
     },
 
     abort: function() {
+      if (iterEnded || worker._abortSent) return;
       console.log("[yoke/claude] ABORT sent to worker pid=" + (worker.process ? worker.process.pid : "?"));
       worker._abortSent = true;
+      interactionAbort.abort();
       try { worker.send({ type: "abort" }); } catch (e) {}
       // If the worker doesn't finish within 5s (e.g. subagent stuck), force-kill it.
       // The worker exit handler will dispatch a fallback query_error and send done.

package/lib/yoke/adapters/codex.js

@@ -3,6 +3,8 @@
 // Implements the YOKE interface using codex app-server protocol.
 // Bidirectional JSON-RPC over stdin/stdout enables interactive approval flows.
 
+var createTurnEvents = require("../codex-turn-events").createTurnEvents;
+var bindQueryAbort = require("../query-abort").bindAbort;
 var path = require("path");
 var fs = require("fs");
 var { CodexAppServer } = require("../codex-app-server");
@@ -11,6 +13,7 @@ var skillDiscovery = require("../skill-discovery");
 var { resolveOsUserInfo } = require("../../os-users");
 var backgroundTasks = require("../codex-background-tasks");
 var codexUserInput = require("../codex-user-input");
+var createTurnStop = require("../codex-turn-stop").createTurnStop;
 
 // --- Reasoning defaults ---
 // Reasoning summaries are the only readable thinking channel Codex offers:
@@ -812,6 +815,7 @@ function createEventState(model) {
 
 function createCodexQueryHandle(appServer, queryOpts) {
   var abortController = queryOpts.abortController;
+  var removeAbort = function () {};
   var promptParts = [queryOpts.systemPrompt, queryOpts.appendSystemPrompt].filter(function (part) { return !!part; });
   var systemPrompt = promptParts.join("\n\n");
   var canUseTool = queryOpts.canUseTool || null;
@@ -826,6 +830,11 @@ function createCodexQueryHandle(appServer, queryOpts) {
   }
 
   var state = createEventState(queryOpts.model);
+  var turnEvents = createTurnEvents(handleServerEvent);
+  var turnStop = createTurnStop(appServer, function (error) {
+    console.error("[yoke/codex] turn interrupt failed:", error.message || error);
+    pushEvent({ yokeType: "error", text: "Codex cancellation could not be confirmed. The remote turn may still be running." });
+  });
 
   // Internal event buffer for async iterator
   var eventBuffer = [];
@@ -864,6 +873,7 @@ function createCodexQueryHandle(appServer, queryOpts) {
   }
 
   function endIterator() {
+    removeAbort();
     iteratorDone = true;
     if (eventWaiting) {
       var resolve = eventWaiting;
@@ -912,6 +922,13 @@ function createCodexQueryHandle(appServer, queryOpts) {
     // Ignore events from other threads (app-server is shared across sessions)
     if (params.threadId && state.threadId && params.threadId !== state.threadId) return;
 
+    if (!turnEvents.accept(msg)) return;
+
+    // Capture cancellation identity even if Stop arrived before turn/start replied.
+    var eventTurnId = params.turnId || params.turn_id || (params.turn && params.turn.id);
+    if (method === "turn/started") turnStop.started(eventTurnId);
+    if (method === "turn/completed" || method === "turn/failed") turnStop.completed(eventTurnId);
+
     // After abort, only let turn-ending events through
     if (isCancelled() && method !== "turn/completed" && method !== "turn/failed" && method !== "serverRequest/resolved" && method !== "thread/status/changed") return;
 
@@ -1089,6 +1106,7 @@ function createCodexQueryHandle(appServer, queryOpts) {
 
     // Resolve turn promise when turn ends
     if (method === "turn/completed" || method === "turn/failed") {
+      turnEvents.finish();
       if (turnResolve) {
         var resolve = turnResolve;
         turnResolve = null;
@@ -1204,6 +1222,7 @@ function createCodexQueryHandle(appServer, queryOpts) {
       while (!isCancelled()) {
         // Reset per-turn state
         state.turnStarted = false;
+        state.currentTurnId = null;
         state.textBlocks = {};
         state.textLengths = {};
         state.thinkingBlocks = {};
@@ -1243,11 +1262,22 @@ function createCodexQueryHandle(appServer, queryOpts) {
           input = input.concat(skillItemsToInject);
         }
 
-        await appServer.send("turn/start", {
-          threadId: state.threadId,
-          input: input,
-          model: state.model,
-        }, 60000);
+        turnStop.begin(state.threadId);
+        turnEvents.begin();
+        try {
+          var turnResult = await appServer.send("turn/start", {
+            threadId: state.threadId,
+            input: input,
+            model: state.model,
+          }, 60000);
+          var startedTurnId = turnResult && turnResult.turn && turnResult.turn.id;
+          turnStop.startSettled(startedTurnId);
+          turnEvents.ready(startedTurnId);
+        } catch (startError) {
+          turnEvents.finish();
+          turnStop.startSettled(null);
+          throw startError;
+        }
 
         // Wait for turn to complete
         await turnPromise;
@@ -1348,19 +1378,23 @@ function createCodexQueryHandle(appServer, queryOpts) {
     abort: function() {
       console.log("[yoke/codex] handle.abort() called, threadId=" + state.threadId + " already aborted=" + state.aborted);
       state.aborted = true;
-      // Send turn/interrupt to stop the server-side turn
-      if (state.threadId && appServer.started) {
-        appServer.send("turn/interrupt", { threadId: state.threadId }, 5000).catch(function() {});
-      }
-      // End iterator immediately. sdk-bridge's post-loop code checks
-      // session.taskStopRequested and sends the interrupted message + done.
-      // This matches Claude's abort pattern.
-      if (turnResolve) {
-        var resolve = turnResolve;
-        turnResolve = null;
-        resolve();
-      }
-      endIterator();
+      messageQueueEnded = true;
+      messageQueue = [];
+      if (messageWaiting) {
+        var releaseMessage = messageWaiting;
+        messageWaiting = null;
+        releaseMessage(null);
+      }
+      // Keep the iterator alive until the exact interrupt settles so failures
+      // reach the transcript instead of being silently reported as a stop.
+      return turnStop.abort().then(function () {
+        if (turnResolve) {
+          var resolve = turnResolve;
+          turnResolve = null;
+          resolve();
+        }
+        endIterator();
+      });
     },
 
     close: function() {
@@ -1383,12 +1417,9 @@ function createCodexQueryHandle(appServer, queryOpts) {
     },
   };
 
-  // Listen for external abort (sdk-bridge's stopTask calls session.abortController.abort())
-  if (abortController && abortController.signal) {
-    abortController.signal.addEventListener("abort", function() {
-      if (!state.aborted) handle.abort();
-    }, { once: true });
-  }
+  removeAbort = bindQueryAbort(abortController, function () {
+    if (!state.aborted) handle.abort();
+  });
 
   return handle;
 }