@jskit-ai/assistant-core 0.1.208 → 0.1.211

package/src/server/conversation/codexTurnRecovery.js

@@ -41,6 +41,9 @@ export function createCodexTurnRecovery({
   captureContext,
   runInContext,
   activeReconcileMs,
+  finalizingGraceAfterHistoryRead,
+  failureDetailGraceMs,
+  notificationQueue,
   hasRuntime,
   recoverAdmission,
   turnOutcomes,
@@ -78,6 +81,7 @@ export function createCodexTurnRecovery({
     adoptSuccessorTurn: adoptCodexAppServerSuccessorTurn
   } = settlement;
   const codexAppServerPromptDeliveries = promptDeliveries;
+  const retainFinalizingTimer = finalizingGraceAfterHistoryRead || failureDetailGraceMs > 0;
 
   function scheduleCodexAppServerActiveRecovery(sessionId = "", delayMs = activeReconcileMs) {
     const normalizedSessionId = normalizeCodexRunText(sessionId);
@@ -100,7 +104,8 @@ export function createCodexTurnRecovery({
   function scheduleCodexAppServerFinalizingRecovery(sessionId = "", threadId = "", turnId = "", {
     completedAt = "",
     status = "completed",
-    updatedAt = ""
+    updatedAt = "",
+    failureDetail = null
   } = {}) {
     const normalizedSessionId = normalizeCodexRunText(sessionId);
     const normalizedThreadId = normalizeCodexRunText(threadId);
@@ -115,30 +120,62 @@ export function createCodexTurnRecovery({
       normalizedTurnId
     );
     const projectContext = captureContext();
-    const delayMs = codexAppServerFinalizingRemainingMs({
-      completedAt,
-      state: "finalizing",
-      updatedAt
-    });
+    const delayMs = failureDetail
+      ? Math.max(0, failureDetail.expiresAt - Date.now())
+      : codexAppServerFinalizingRemainingMs({ completedAt, state: "finalizing", updatedAt });
     const timer = setTimeout(() => {
-      codexAppServerFinalizingTimers.delete(key);
-      void runInContext(
+      if (failureDetail) {
+        notificationQueue.run({ projectContext, provider: failureDetail.provider, sessionId: normalizedSessionId }, async () => {
+          if (codexAppServerFinalizingTimers.get(key) !== timer) return;
+          try {
+            return await stopCodexAppServerTurnWithProviderFailure(normalizedSessionId, normalizedThreadId, normalizedTurnId,
+              { ...failureDetail, failureDetailReady: true });
+          } finally {
+            if (codexAppServerFinalizingTimers.get(key) === timer) {
+              clearCodexAppServerFinalizingTimer(normalizedSessionId, normalizedThreadId, normalizedTurnId);
+            }
+          }
+        });
+        return;
+      }
+      // The post-read policy keeps its first clock while expiry rereads history.
+      if (!retainFinalizingTimer) codexAppServerFinalizingTimers.delete(key);
+      const recovery = runInContext(
         projectContext,
         () => recoverCodexAppServerFinalizingTurn(
           normalizedSessionId,
           normalizedThreadId,
           normalizedTurnId,
-          { status }
+          { status, timerRecovery: finalizingGraceAfterHistoryRead }
         )
       );
+      if (retainFinalizingTimer) {
+        timer.finalizingRecovery = recovery;
+        void recovery.then(
+          () => { if (timer.finalizingRecovery === recovery) delete timer.finalizingRecovery; },
+          error => {
+            if (timer.finalizingRecovery === recovery) delete timer.finalizingRecovery;
+            debugLog("appServerFinalizingRecovery.error", {
+              error: debugError(error), sessionId: normalizedSessionId,
+              threadId: normalizedThreadId, turnId: normalizedTurnId
+            });
+          }
+        );
+      } else {
+        void recovery;
+      }
     }, delayMs);
+    if (failureDetailGraceMs > 0) timer.finalizingExpiresAt = Date.now() + delayMs;
+    if (failureDetail) timer.failureDetail = failureDetail;
+    else if (finalizingGraceAfterHistoryRead) timer.finalizingStartedAt = completedAt;
     timer.unref?.();
     codexAppServerFinalizingTimers.set(key, timer);
   }
 
   async function reconcileCodexAppServerActiveTurn(session = {}, {
     provider: suppliedProvider = null,
-    runtime = null
+    runtime = null,
+    providerError = null
   } = {}) {
     const sessionId = normalizeCodexRunText(session.sessionId);
     const trackedTurn = turnState(session);
@@ -307,8 +344,10 @@ export function createCodexTurnRecovery({
       turnId: completedTurnId
     });
     if (codexAppServerTurnStatusIsProviderFailure(status)) {
+      const exactError = providerError?.threadId === currentTurn.threadId && providerError?.turnId === completedTurnId;
       await stopCodexAppServerTurnWithProviderFailure(sessionId, currentTurn.threadId, completedTurnId, {
-        error: codexAppServerThreadError(thread),
+        error: exactError ? providerError.error : codexAppServerThreadError(thread),
+        failureDetailReady: exactError,
         provider,
         status
       });
@@ -556,11 +595,14 @@ export function createCodexTurnRecovery({
   }
 
   async function recoverCodexAppServerFinalizingTurn(sessionId = "", threadId = "", turnId = "", {
-    status = "completed"
+    status = "completed", timerRecovery = false
   } = {}) {
     const normalizedSessionId = normalizeCodexRunText(sessionId);
     const normalizedThreadId = normalizeCodexRunText(threadId);
     const normalizedTurnId = normalizeCodexRunText(turnId);
+    const key = codexAppServerResultFinalizationKey(normalizedSessionId, normalizedThreadId, normalizedTurnId);
+    const priorTimer = retainFinalizingTimer ? codexAppServerFinalizingTimers.get(key) : null;
+    if (!timerRecovery && priorTimer?.finalizingRecovery) return priorTimer.finalizingRecovery;
     const runtime = await createRuntime();
     const session = await runtime.getSession(normalizedSessionId);
     const turn = turnState(session);
@@ -588,11 +630,35 @@ export function createCodexTurnRecovery({
     if (result?.processed) {
       return result;
     }
-    if (!codexAppServerFinalizingExpired(turn)) {
+    // A later failure owns the same first deadline, even when this successful
+    // history read was already in flight under the completion-based clock.
+    const currentTimer = codexAppServerFinalizingTimers.get(key);
+    if (currentTimer?.failureDetail) return result;
+    if (retainFinalizingTimer && priorTimer && !currentTimer) return result;
+    let graceTurn = turn;
+    if (finalizingGraceAfterHistoryRead) {
+      const readReturnedAt = new Date().toISOString();
+      const currentTurn = turnState(await runtime.getSession(normalizedSessionId));
+      const timer = codexAppServerFinalizingTimers.get(key);
+      if (timer?.failureDetail || (priorTimer && !timer)) return result;
+      if (currentTurn.state !== "finalizing" || currentTurn.threadId !== normalizedThreadId ||
+          currentTurn.turnId !== normalizedTurnId) {
+        clearCodexAppServerFinalizingTimer(normalizedSessionId, normalizedThreadId, normalizedTurnId);
+        return { ...result, reason: "stale_turn_state" };
+      }
+      if (codexAppServerTurnOwnsActiveGoal(currentTurn, normalizedThreadId)) {
+        clearCodexAppServerFinalizingTimer(normalizedSessionId, normalizedThreadId, normalizedTurnId);
+        return { ok: true, processed: false, reason: "goal_continuation_pending" };
+      }
+      if (!timerRecovery && timer?.finalizingRecovery) return timer.finalizingRecovery;
+      // This local clock never changes the native completion timestamp.
+      graceTurn = { ...currentTurn, completedAt: timer?.finalizingStartedAt || readReturnedAt };
+    }
+    if (!codexAppServerFinalizingExpired(graceTurn)) {
       scheduleCodexAppServerFinalizingRecovery(normalizedSessionId, normalizedThreadId, normalizedTurnId, {
-        completedAt: turn.completedAt,
+        completedAt: graceTurn.completedAt,
         status,
-        updatedAt: turn.updatedAt
+        updatedAt: graceTurn.updatedAt
       });
       return result;
     }
@@ -611,7 +677,8 @@ export function createCodexTurnRecovery({
   async function recoverCodexAppServerActiveTurn(sessionId = "", {
     provider = null,
     retryOnError = true,
-    runtime: suppliedRuntime = null
+    runtime: suppliedRuntime = null,
+    providerError = null
   } = {}) {
     const normalizedSessionId = normalizeCodexRunText(sessionId);
     if (!normalizedSessionId) {
@@ -639,7 +706,8 @@ export function createCodexTurnRecovery({
       }
       const reconciledSession = await reconcileCodexAppServerActiveTurn(session, {
         provider,
-        runtime
+        runtime,
+        providerError
       });
       const currentTurn = turnState(reconciledSession);
       if (currentTurn.state === "starting" && currentTurn.threadId) {
@@ -831,8 +899,11 @@ export function createCodexTurnRecovery({
     provider = null,
     status = "failed",
     usageLimitExceeded = false,
-    verifyInactive = true
+    verifyInactive = true,
+    deferFailureDetails = false,
+    failureDetailReady = false
   } = {}) {
+    const observedAt = Date.now();
     const normalizedSessionId = normalizeCodexRunText(sessionId);
     const normalizedThreadId = normalizeCodexRunText(threadId);
     const normalizedTurnId = normalizeCodexRunText(turnId);
@@ -867,6 +938,21 @@ export function createCodexTurnRecovery({
         reason: "stale_turn_state"
       };
     }
+    const key = codexAppServerResultFinalizationKey(normalizedSessionId, normalizedThreadId, normalizedTurnId);
+    const pendingTimer = codexAppServerFinalizingTimers.get(key);
+    const pendingDetail = pendingTimer?.failureDetail;
+    if (failureDetailGraceMs > 0 && !failureDetailReady && (deferFailureDetails || pendingDetail) &&
+        ![turnOutcomes.USER_CANCELLED, turnOutcomes.CONTROL_RECONFIGURATION].includes(resolvedOutcome)) {
+      if (!pendingDetail) {
+        scheduleCodexAppServerFinalizingRecovery(normalizedSessionId, normalizedThreadId, normalizedTurnId, {
+          failureDetail: { error, ok, outcome: resolvedOutcome, provider, status: normalizedStatus,
+            usageLimitExceeded, verifyInactive,
+            expiresAt: Math.min(observedAt + failureDetailGraceMs,
+              pendingTimer?.finalizingExpiresAt ?? Infinity) }
+        });
+      }
+      return { ok: true, processed: false, reason: "failure_detail_pending", status: normalizedStatus };
+    }
     const recovered = await recoverCodexAppServerFinalResponseBeforeOutcome(
       normalizedSessionId,
       normalizedThreadId,

package/src/server/conversation/continuity.js

@@ -142,6 +142,7 @@ export function createConversationChangeover({ state, transcript, agent, identit
       await transcript.writeUserMessage({
         text: pending.displayMessage, messageId: pending.messageId,
         attachments: pending.displayAttachments,
+        ...(pending.data !== undefined ? { data: pending.data } : {}),
         turnMetadata: { ...pending.turnMetadata, ...turnMetadata }
       });
       await markDelivered(pending.seen);
@@ -198,6 +199,7 @@ export function createConversationChangeover({ state, transcript, agent, identit
         displayMessage: String(input.displayMessage || input.message || ""),
         displayAttachments: input.displayAttachments || input.attachments || [],
         attachmentIds: input.attachmentIds || [],
+        ...(input.data !== undefined ? { data: structuredClone(input.data) } : {}),
         seen: snapshot, attempted: false,
         ...(captureContext ? {
           contextText: preamble.slice(0, preamble.length - String(input.message || "").length - "\n\nUser's message:\n".length),
@@ -213,6 +215,7 @@ export function createConversationChangeover({ state, transcript, agent, identit
     const delivered = await agent.sendMessage(pending ? {
       ...input, message: pending.message, displayMessage: pending.displayMessage,
       displayAttachments: pending.displayAttachments, attachmentIds: pending.attachmentIds,
+      data: pending.data,
       ...(captureContext ? { contextText: pending.contextText, contextAttachments: pending.contextAttachments } : {}),
       onPromptSending: async ({ threadId, displayAttachments, turnMetadata }) => {
         const replacement = value.replacement;

package/src/server/conversation/openCodeRuntime.js

@@ -921,6 +921,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
       if (message.summary === true) continue;
       const assistantText = assistantMessageText(message);
       const messageId = assistantText ? projection.messageId(message.id, "assistant") : "";
+      const outputId = assistantText ? projection.outputId?.(message.id, "assistant") : "";
       const inFlight = streaming && index === rows.length - 1;
       const reasoning = (message.content || []).filter((part) => part.type === "reasoning" && text(part.text))
         .map((part) => ({
@@ -939,6 +940,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
         // superseded narration never evaporates from the transcript.
         const turn = await projection.store.writeConversationAssistantMessage(sessionId, {
           messageId,
+          ...(outputId ? { outputId } : {}),
           text: assistantText
         });
         projection.store.completeConversationStreamMessage(sessionId, messageId);
@@ -949,6 +951,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
         const conversationStream = projection.store.updateConversationStream(sessionId, {
           turnId: inputMessageId,
           messageId,
+          ...(outputId ? { outputId } : {}),
           text: assistantText
         });
         if (conversationStream) {
@@ -959,6 +962,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
       if (assistantText && !streaming) {
         const turn = await projection.store.writeConversationAssistantMessage(sessionId, {
           messageId,
+          ...(outputId ? { outputId } : {}),
           text: assistantText
         });
         projection.store.completeConversationStreamMessage(sessionId, messageId);

package/src/server/conversation/providers/codexDriver.js

@@ -3,7 +3,8 @@ import { homedir, tmpdir } from "node:os";
 import path from "node:path";
 import { open, realpath } from "node:fs/promises";
 import { createCodexAppServerRuntime } from "../codexProcess.js";
-import { CodexAppServerAgentProvider, codexLocalImageInput, ensureCodexAppServerThread, inspectCodexAppServerMessageAdmission, retireCodexConversationHistory } from "../codexProvider.js";
+import { CodexAppServerAgentProvider, codexLocalImageInput, ensureCodexAppServerThread, codexApplicationToolConfiguration,
+  assertCodexApplicationToolSchemaIdentity, inspectCodexAppServerMessageAdmission, retireCodexConversationHistory } from "../codexProvider.js";
 import { createCodexAppServerProviderOwner } from "../codexProviderOwner.js";
 import { codexAuthOutputRequiresReconnect, codexProviderConfiguration, codexToolFreeConfiguration } from "../codexConfiguration.js";
 import { nativeAiProvider, nativeAiModel } from "../../../shared/nativeProviders.js";
@@ -46,6 +47,8 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
   }
   const nativeTools = host.nativeTools === true;
   const maximumOutput = limits.maxOutputCharacters ?? 64_000;
+  const maximumFinalReply = limits.maxFinalReplyCharacters ?? maximumOutput;
+  if (!Number.isSafeInteger(maximumFinalReply) || maximumFinalReply < 1) throw new TypeError("Invalid Codex final reply limit.");
   if (!Number.isSafeInteger(maximumOutput) || maximumOutput < 1) throw new TypeError("Invalid Codex output limit.");
 
   async function accountRecord() {
@@ -276,7 +279,8 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
       const sessionId = conversation.sessionId;
       const nativeStore = conversation.runtime.store;
       const boundedWriter = name => (id, input) => {
-        const limit = name === "writeConversationThinkingMessage" ? 4 * 1024 * 1024 : maximumOutput;
+        const limit = name === "writeConversationThinkingMessage" ? 4 * 1024 * 1024
+          : name.includes("AssistantMessage") ? Math.min(maximumOutput, maximumFinalReply) : maximumOutput;
         if ((input.text?.length || 0) > limit) throw new Error("Codex output exceeded the configured limit.");
         return nativeStore[name](id, input);
       };
@@ -299,12 +303,33 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
         }
       } };
       const owner = supplied?.runOwner || createCodexAppServerRunOwner({
+        finalizingGraceMs: limits.codexFinalizingGraceMs,
+        finalizingGraceAfterHistoryRead: limits.codexFinalizingGraceAfterHistoryRead,
+        failureDetailGraceMs: limits.codexFailureDetailGraceMs,
         createRuntime: async () => runtime,
         createStore: async () => runtime.store,
         acquireProvider: async () => native,
         hasRuntime: () => Boolean(binding.threadId),
         publish: (_id, event) => publishNative(event),
-        checkpoint: (_id, input) => conversation.checkpoint(input)
+        checkpoint: (_id, input) => conversation.checkpoint({ ...input,
+          status: input.turnOutcome === "response_delivery_failure" ? "failed" : input.status }),
+        async onNotificationSignal(kind, { threadId, turnId, provider, error }) {
+          const active = current;
+          if (kind !== "provider_error" || !active?.dispatched || active.finished || provider !== native ||
+              threadId !== binding.threadId || !turnId || active.turnId && active.turnId !== turnId) return;
+          const tracked = codexAppServerTurnState(await runtime.getSession(sessionId));
+          if (tracked.threadId !== threadId || tracked.turnId !== turnId) return;
+          // The original detached waiter recovered only this admitted turn.
+          // Keep native activity truthful; run's existing cleanup owns Stop.
+          await owner.recoverActiveTurn(sessionId, { provider, retryOnError: false, providerError: { threadId, turnId, error } });
+          if (current !== active || active.finished || active.turnId !== turnId ||
+              provider !== native || threadId !== binding.threadId) return;
+          const result = await owner.stopTurnWithProviderFailure(sessionId, threadId, turnId, { provider, error, failureDetailReady: true });
+          if (current === active && active.turnId === turnId && provider === native &&
+              threadId === binding.threadId && result.reason === "provider_still_active") {
+            active.completion.reject(Object.assign(new Error(error), { status: "failed" }));
+          }
+        }
       });
       async function publishNative(event) {
         if (supplied) binding.threadId = await conversation.identity.read();
@@ -330,8 +355,9 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
         }
         if (!turn.active && event.reason === "codex-app-server-turn-idle") {
           current.finished = true;
-          if (["failed", "interrupted"].includes(turn.status) && !current.signal.aborted) {
-            current.completion.reject(Object.assign(new Error(turn.error || `Codex turn ${turn.status}.`), { status: turn.status }));
+          if ((["failed", "interrupted"].includes(turn.status) || !supplied && turn.error) && !current.signal.aborted) {
+            current.completion.reject(Object.assign(new Error(turn.error || `Codex turn ${turn.status}.`), {
+              status: turn.status === "completed" ? "failed" : turn.status }));
           } else current.completion.resolve();
         }
       }
@@ -548,13 +574,8 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
       }
 
       async function prepareConfiguration(configuration, context, signal, tools) {
-        const dynamicTools = (tools?.schemas || []).map(({ function: tool }) => ({
-          type: "function", name: tool.name, description: tool.description, inputSchema: tool.parameters
-        }));
-        const toolSchemaIdentity = hash(dynamicTools);
-        if (binding.threadId && (binding.toolSchemaIdentity || hash([])) !== toolSchemaIdentity) {
-          throw new Error("This Codex conversation was created with different application tool entry points. Start a new conversation to enable or remove application tools.");
-        }
+        const { dynamicTools, toolSchemaIdentity } = codexApplicationToolConfiguration(tools);
+        assertCodexApplicationToolSchemaIdentity(binding.threadId, binding.toolSchemaIdentity, toolSchemaIdentity);
         const selected = await selection(configuration, context, signal);
         await connect(signal, selected);
         const [configResult, hookResult] = await Promise.all([
@@ -648,7 +669,8 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
       }
 
       function messagePreparation(configuration, context, signal, tools) {
-        if (supplied) return supplied.messagePreparation;
+        if (supplied) return tools ? { ...supplied.messagePreparation, applicationTools: tools,
+          providerReady: current.providerReady } : supplied.messagePreparation;
         return {
           async readContext() {
             const session = await runtime.getSession(sessionId);
@@ -912,7 +934,7 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
           const request = JSON.parse(await runtime.store.readMetadataValue(sessionId, "assistant_delivery")).engines.codex.pending;
           if (request?.messageId === messageId) await owner.writeDeliveredUserMessage(runtime, sessionId,
             request.displayMessage, messageId, request.turnMetadata, request.displayAttachments,
-            { threadId: binding.threadId, turnId: acceptedTurn?.id || "" });
+            { threadId: binding.threadId, turnId: acceptedTurn?.id || "" }, request.data);
           let recoveryLimitation;
           if (!stored.agentRuns.length) {
             recoveryLimitation = "Delivery is confirmed, but this older binding has no original native run record. Stored history is preserved; output recovery cannot be proven.";
@@ -956,6 +978,72 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
           let waitForTurn = false;
           let executingProvider;
           const toolCalls = new Set();
+          const toolRegistrations = new Map();
+          function toolHandler(provider, threadId, isRegistered = () => true) {
+            return async ({ method, params }) => {
+              if (method !== "item/tool/call" || !tools || params?.threadId !== (threadId || binding.threadId) || params.namespace ||
+                  supplied && (disposed || current !== active || active.finished || signal.aborted || owner.runtimeLifecycle?.closing === true || !isRegistered())) {
+                throw new Error("This conversation does not authorize that native tool request.");
+              }
+              let owned = !supplied;
+              const operation = (async () => {
+                await active.inputReady;
+                if (supplied && owner.runtimeLifecycle?.closing === true) {
+                  throw new Error("This conversation does not authorize that native tool request.");
+                }
+                const ownership = Promise.withResolvers();
+                owner.notificationQueue.run({ sessionId, provider }, () => {
+                  if (supplied && (params.turnId !== active.turnId || disposed || current !== active || active.finished ||
+                      signal.aborted || !isRegistered())) {
+                    ownership.resolve(false);
+                    return;
+                  }
+                  owned = true;
+                  const failure = provider.observationFailure;
+                  if (failure) ownership.reject(failure.cause || failure);
+                  else ownership.resolve(params.turnId === active.turnId);
+                });
+                if (!await ownership.promise || supplied && (disposed || current !== active || active.finished || signal.aborted || !isRegistered())) {
+                  owned = false;
+                  throw new Error("This application tool call belongs to another turn.");
+                }
+                const result = await tools.execute({ id: params.callId, name: params.tool, arguments: JSON.stringify(params.arguments) });
+                return { success: result.ok, contentItems: [{ type: "inputText", text: JSON.stringify(result) }] };
+              })();
+              toolCalls.add(operation);
+              try { return await operation; }
+              catch (error) {
+                if (!supplied || owned && current === active && params.turnId === active.turnId && isRegistered()) {
+                  if (supplied) active.toolFailure = error;
+                  active.completion.reject(error);
+                }
+                throw error;
+              }
+              finally { toolCalls.delete(operation); }
+            };
+          }
+          active.providerReady = async ({ provider, threadId }) => {
+            signal.throwIfAborted();
+            if (!threadId) return;
+            if (typeof conversation.identity?.readToolSchemaIdentity !== "function") {
+              throw new TypeError("Bound Codex application tools require the original schema identity reader and writer.");
+            }
+            if (await conversation.identity.read() !== threadId) throw new Error("The native application tool thread changed before dispatch.");
+            assertCodexApplicationToolSchemaIdentity(threadId, await conversation.identity.readToolSchemaIdentity(),
+              codexApplicationToolConfiguration(tools).toolSchemaIdentity);
+            signal.throwIfAborted();
+            if (disposed || current !== active) throw new Error("This conversation handle is closed.");
+            for (const [previous, owned] of toolRegistrations) {
+              if (previous === provider && owned.threadId === threadId && owned.client === provider.client && owned.registration.isCurrent()) return;
+              owned.registration.release();
+              toolRegistrations.delete(previous);
+            }
+            const client = provider.client;
+            let registration;
+            registration = provider.registerThreadRequestHandler(threadId, toolHandler(provider, threadId,
+              () => registration?.isCurrent() === true && provider.client === client));
+            toolRegistrations.set(provider, { threadId, client, registration });
+          };
           function abort() {
             if (cancellation) return;
             cancellation = interrupt();
@@ -981,27 +1069,7 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
               await connect(signal, selected);
               executingProvider = native;
             }
-            if (!supplied) native.setServerRequestHandler(async ({ method, params }) => {
-              if (method !== "item/tool/call" || !tools || params?.threadId !== binding.threadId || params.namespace) {
-                throw new Error("This conversation does not authorize that native tool request.");
-              }
-              const operation = (async () => {
-                await active.inputReady;
-                const ownership = Promise.withResolvers();
-                owner.notificationQueue.run({ sessionId, provider: executingProvider }, () => {
-                  const failure = executingProvider.observationFailure;
-                  if (failure) ownership.reject(failure.cause || failure);
-                  else ownership.resolve(params.turnId === active.turnId);
-                });
-                if (!await ownership.promise) throw new Error("This application tool call belongs to another turn.");
-                const result = await tools.execute({ id: params.callId, name: params.tool, arguments: JSON.stringify(params.arguments) });
-                return { success: result.ok, contentItems: [{ type: "inputText", text: JSON.stringify(result) }] };
-              })();
-              toolCalls.add(operation);
-              try { return await operation; }
-              catch (error) { active.completion.reject(error); throw error; }
-              finally { toolCalls.delete(operation); }
-            });
+            if (!supplied) native.setServerRequestHandler(toolHandler(executingProvider));
             const command = { input, beforeDispatch, accept };
             delivered = await sendMessage(command, configuration, context, signal, tools);
             waitForTurn = !supplied || delivered.value?.delivered === true;
@@ -1032,7 +1100,7 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
           try {
             // Account invalidation already owns this stop attempt. Its failed
             // proof stays available for explicit cleanup through the same owner.
-            if ((!supplied && problem || signal.aborted) && problem?.code !== "codex_runtime_invalidated") {
+            if ((!supplied && problem || supplied && active.toolFailure || signal.aborted) && problem?.code !== "codex_runtime_invalidated") {
               await (cancellation || interrupt());
             }
           } catch (error) { problem = error; }
@@ -1043,6 +1111,8 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
             if (!supplied) await providerOwner.pendingRecovery(providerKey, executingProvider);
           } catch (error) { problem = error; }
           finally {
+            for (const owned of toolRegistrations.values()) owned.registration.release();
+            toolRegistrations.clear();
             await Promise.allSettled([...toolCalls]);
             if (!supplied) {
               native?.setServerRequestHandler(null);