@jskit-ai/assistant-core 0.1.213 → 0.1.214

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

@@ -12,6 +12,8 @@ import { createCodexAppServerRunOwner, codexAppServerTurnState, codexAppServerFr
 import { createLocalConversationExecution } from "../localExecution.js";
 import { validateConversationConfiguration, validateConnectionModel } from "../configuration.js";
 import { codexCommandHookCommand } from "../commandWrapper.js";
+import { isCompletedEnvelopeTurn } from "../transcript.js";
+import { createInertCodexConversationBinding } from "../runtimeStateUpgrade.js";
 
 const hash = value => createHash("sha256").update(JSON.stringify(value)).digest("hex");
 const goalValue = goal => goal ? {
@@ -221,7 +223,7 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
       return native.runOwner.runDetachedConversation(sessionId, input, options);
     },
     async createBinding() {
-      return { threadId: "", workdir: await realpath(workdir), configRoot, executionId: "" };
+      return createInertCodexConversationBinding({ workdir: await realpath(workdir), configRoot });
     },
     async open({ binding, writeBinding, onFailure: reportFailure, conversation }) {
       const supplied = conversation?.native;
@@ -281,8 +283,29 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
       const boundedWriter = name => (id, input) => {
         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);
+        const length = input.text?.length || 0;
+        if (length <= limit) return nativeStore[name](id, input);
+        if (!name.includes("AssistantMessage") || length > maximumOutput) throw new Error("Codex output exceeded the configured limit.");
+        return nativeStore.mutateSession(id, async transaction => {
+          const { runtime: state } = await transaction.readMetadata();
+          const identity = input.nativeIdentity;
+          const run = state.binding?.codexAppServerRun;
+          if (identity?.threadId && identity.turnId && state.engine === "codex" &&
+              state.binding.threadId === identity.threadId && run?.providerThreadId === identity.threadId &&
+              run.providerTurnId === identity.turnId && run.outerTurnId) {
+            for (const turnId of (await transaction.listTurnIds()).reverse()) {
+              const turn = await transaction.readTurn(turnId);
+              if (turn?.system?.messageId !== run.outerTurnId) continue;
+              if (turn.system.origin === "application" && !turn.system.goal && isCompletedEnvelopeTurn(turn) &&
+                  turn.metadata.runtime.engine === "codex" && turn.metadata.runtime.segmentId === state.segmentId &&
+                  turn.metadata.runtime.nativeTurnId === identity.turnId) {
+                return nativeStore[name](id, input);
+              }
+              break;
+            }
+          }
+          throw new Error("Codex output exceeded the configured limit.");
+        });
       };
       const runtime = supplied ? conversation.runtime : { ...conversation.runtime, store: { ...nativeStore,
         writeConversationAssistantMessage: boundedWriter("writeConversationAssistantMessage"),
@@ -303,6 +326,7 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
         }
       } };
       const owner = supplied?.runOwner || createCodexAppServerRunOwner({
+        persistCommentary: conversation.persistCommentary,
         finalizingGraceMs: limits.codexFinalizingGraceMs,
         finalizingGraceAfterHistoryRead: limits.codexFinalizingGraceAfterHistoryRead,
         failureDetailGraceMs: limits.codexFailureDetailGraceMs,
@@ -331,6 +355,8 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
           }
         }
       });
+      // Retain this queue's exact opening namespace, never its admission grant.
+      const drainNotifications = owner.notificationQueue.captureDrain(sessionId);
       async function publishNative(event) {
         if (supplied) binding.threadId = await conversation.identity.read();
         await conversation.publish(event);
@@ -406,10 +432,11 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
         } });
       }
 
-      async function completeObservation({ provider, error, sharedStop }) {
+      async function completeObservation({ provider, error, sharedStop, threadIds }) {
+        if (threadIds && !threadIds.includes(binding.threadId)) return;
         await updateBinding({ observationLoss: { ...binding.observationLoss, stopped: true },
           ...(sharedStop ? { executionId: "" } : {}) });
-        await observation.complete({ provider, error, sharedStop });
+        await observation.complete({ provider, error, sharedStop, threadIds });
         observationError = null;
         await reportFailure(error, { recovered: true });
         current?.completion.reject(error);
@@ -469,6 +496,7 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
           create: onObservationLost => new CodexAppServerAgentProvider({ ...providerOptions, onObservationLost }, facilities),
           observation: {
             async prepare(input) {
+              if (input.threadIds && !input.threadIds.includes(binding.threadId)) return new Map();
               observationError = input.error;
               await reportFailure(input.error);
               const threads = await observation.prepare(input);
@@ -476,6 +504,7 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
               return threads;
             },
             async barrier(input) {
+              if (input.threadIds && !input.threadIds.includes(binding.threadId)) return;
               await observation.barrier(input);
               await recordObservationBarrier(input);
             },
@@ -514,8 +543,14 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
         return stopping;
       }
 
-      async function selection(configuration, context, signal) {
-        if (!configuration.integrationId) return { model: configuration.model, providerId: "openai" };
+      async function selection(configuration, context, signal, requireBound = false, receiptBinding) {
+        if (!configuration.integrationId) {
+          if (requireBound && !receiptBinding?.accountIdentity) throw new Error("The completed Codex response has no saved native account fingerprint.");
+          if (requireBound && binding.accountIdentity !== receiptBinding.accountIdentity) {
+            throw new Error("The completed Codex response belongs to a different native account binding.");
+          }
+          return { model: configuration.model, providerId: "openai" };
+        }
         const connection = await connections.resolve({ context, integrationId: configuration.integrationId });
         signal.throwIfAborted();
         const provider = nativeAiProvider(connection.providerId);
@@ -525,6 +560,11 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
         if (configuration.effort && !model.variants.includes(configuration.effort)) throw new Error("The selected Codex model does not support this reasoning effort.");
         const identity = hash([provider.id, provider.baseUrl, connection.apiKey]);
         const previous = binding.connectionIdentities?.[provider.id];
+        const expected = receiptBinding?.connectionIdentities?.[provider.id];
+        if (requireBound && !expected) throw new Error("The completed Codex response has no saved provider account fingerprint.");
+        if (requireBound && (previous !== expected || identity !== expected)) {
+          throw new Error("The completed Codex response belongs to a different provider account binding.");
+        }
         if (previous && previous !== identity) throw new Error("This conversation belongs to another Codex provider account. Restore that connection or start a new conversation.");
         if (!previous) await updateBinding({ connectionIdentities: { ...binding.connectionIdentities, [provider.id]: identity } });
         return { model: model.id, providerId: provider.id, accountIdentity: identity, config: codexProviderConfiguration(provider, connection.apiKey) };
@@ -832,6 +872,13 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
             await native.ensureAvailable();
             return native;
           }
+        }).catch(error => {
+          // A thrown control error also leaves this native owner unconfirmed.
+          if (error === current?.toolFailure && !current.signal.aborted && !error.cleanupFailed) {
+            current.toolFailureCleanup = error;
+          }
+          error.cleanupFailed = true;
+          throw error;
         });
         if (result.value?.ok === false) throw Object.assign(new Error(result.value.error || "Codex could not confirm that work stopped."), { cleanupFailed: true });
         return result.value;
@@ -901,7 +948,7 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
           if (result.ok === false) throw new Error(result.error);
           return goalValue(result.goal);
         },
-        async inspectAdmission({ messageId, threadId, nativeTurnId, configuration, context, goal: command, representation }) {
+        async inspectAdmission({ messageId, threadId, nativeTurnId, configuration, context, goal: command, representation, verifyAccount = false, receiptBinding }) {
           if (supplied) {
             const prepared = await supplied.inspectionPreparation({ messageId, threadId }, context);
             if (prepared.ok === false) return representation === "native" ? prepared : { accepted: false, ...prepared };
@@ -915,9 +962,13 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
             // cannot certify the authored delivery invented by that adapter.
             return { accepted: false, recoveryLimitation: "This older goal-message record requires offline inspection. Its saved history and delivery evidence were preserved." };
           }
+          if (verifyAccount === true && (!receiptBinding || threadId !== binding.threadId || receiptBinding.threadId !== binding.threadId ||
+              receiptBinding.workdir !== binding.workdir || receiptBinding.configRoot !== binding.configRoot)) {
+            throw new Error("The completed Codex response belongs to a different native conversation or host scope.");
+          }
           if (!binding.threadId) return { accepted: false };
           const signal = AbortSignal.timeout(30_000);
-          await connect(signal, await selection(configuration, context, signal));
+          await connect(signal, await selection(configuration, context, signal, verifyAccount === true, receiptBinding));
           let acceptedTurn;
           let cursor;
           do {
@@ -973,6 +1024,7 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
             onEvent, onNativeTurn, signal, completion, admission, inputReady: admission.promise, finishIfCurrent,
             admitted: false, dispatched: false, turnId: "" };
           let cancellation;
+          let toolFailureRecovery;
           let problem;
           let delivered;
           let waitForTurn = false;
@@ -1007,7 +1059,15 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
                   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) });
+                let result;
+                try {
+                  result = await tools.execute({ id: params.callId, name: params.tool, arguments: JSON.stringify(params.arguments) });
+                } catch (error) {
+                  if (!supplied && owned && current === active && !disposed && !signal.aborted &&
+                      provider === executingProvider && provider === native &&
+                      params.threadId === binding.threadId && params.turnId === active.turnId) active.toolFailure ||= error;
+                  throw error;
+                }
                 return { success: result.ok, contentItems: [{ type: "inputText", text: JSON.stringify(result) }] };
               })();
               toolCalls.add(operation);
@@ -1075,7 +1135,7 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
             waitForTurn = !supplied || delivered.value?.delivered === true;
             if (!finishIfCurrent && waitForTurn) {
               await completion.promise;
-              await owner.notificationQueue.drain(sessionId);
+              await drainNotifications();
             }
           } catch (error) { problem = error; }
           if (finishIfCurrent) {
@@ -1092,23 +1152,41 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
                 problem = undefined;
                 waitForTurn = true;
               }
-              if (!problem && waitForTurn) await owner.notificationQueue.drain(sessionId);
+              if (!problem && waitForTurn) await drainNotifications();
             } catch (error) { problem = error; }
           }
           signal.removeEventListener("abort", abort);
           admission.reject(problem || signal.reason);
+          const failureThreadId = binding.threadId;
+          const failureTurnId = active.turnId;
           try {
             // Account invalidation already owns this stop attempt. Its failed
             // proof stays available for explicit cleanup through the same owner.
             if ((!supplied && problem || supplied && active.toolFailure || signal.aborted) && problem?.code !== "codex_runtime_invalidated") {
               await (cancellation || interrupt());
             }
-          } catch (error) { problem = error; }
+          } catch (error) {
+            problem = error;
+            // A direct Stop checkpoint can throw before its native completion
+            // reaches the queue. Keep the same admitted tool failure with the
+            // original observation-stop owner until its pending recovery joins.
+            if (!supplied && error === active.toolFailure && current === active && !disposed && !signal.aborted &&
+                executingProvider && executingProvider === native && binding.threadId === failureThreadId &&
+                active.turnId === failureTurnId && error.code !== "codex_runtime_invalidated") {
+              toolFailureRecovery = executingProvider.failObservation(error);
+            }
+          }
           try {
-            await owner.notificationQueue.drain(sessionId);
+            await drainNotifications();
             // The original queue starts observation recovery without awaiting
             // it. Join only this provider's existing attempt before settling.
             if (!supplied) await providerOwner.pendingRecovery(providerKey, executingProvider);
+            if (toolFailureRecovery) {
+              await toolFailureRecovery;
+              if (problem === active.toolFailureCleanup && current === active && !disposed && !signal.aborted &&
+                  executingProvider === native && binding.threadId === failureThreadId && active.turnId === failureTurnId &&
+                  !observationError && binding.observationLoss?.stopped === true) delete problem.cleanupFailed;
+            }
           } catch (error) { problem = error; }
           finally {
             for (const owned of toolRegistrations.values()) owned.registration.release();

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

@@ -234,7 +234,7 @@ export function createOpenCodeConversationDriver({ connections, host = {}, limit
               maxArgumentBytes: active.tools.maximumArgumentBytes, execute(input, signal) {
                 const turn = supplied.owner.turns.get(acquired.key);
                 const target = supplied.owner.processes.get(acquired.key);
-                return executeOpenCodeApplicationTool({ active: current, turn, target,
+                const execute = () => executeOpenCodeApplicationTool({ active: current, turn, target,
                   sessionId: target?.upstreamSessionId,
                   assertCurrent(throwFailure = true, authored) {
                     const owned = !disposed && current === active && active.turn === turn && turn?.active &&
@@ -244,6 +244,7 @@ export function createOpenCodeConversationDriver({ connections, host = {}, limit
                     return owned;
                   }
                 }, input, signal);
+                return typeof acquired.runInContext === "function" ? acquired.runInContext(execute) : execute();
               }
             });
           }
@@ -417,23 +418,39 @@ export function createOpenCodeConversationDriver({ connections, host = {}, limit
         }).finally(() => { stopping = null; });
         return stopping;
       }
-      async function resolvePreparation(configuration, context, signal) {
+      async function resolvePreparation(configuration, context, signal, requireBound = false, receiptBinding, authoredPreparation = false) {
         const connection = await connections.resolve({ context, integrationId: configuration.integrationId });
         signal.throwIfAborted();
         validateConnectionModel(configuration, connection);
         const identity = hash([connection.providerId, connection.baseURL || "", connection.apiKey]);
-        if (binding.accountIdentity && identity !== binding.accountIdentity) {
+        if (requireBound && !receiptBinding?.accountIdentity) throw new Error("The completed OpenCode response has no saved account fingerprint.");
+        if (requireBound && (binding.accountIdentity !== receiptBinding.accountIdentity || identity !== receiptBinding.accountIdentity)) {
+          throw new Error("The completed OpenCode response belongs to a different account binding.");
+        }
+        // The existing managed host reauthorizes its own connection on every preparation.
+        // A key change can rotate an authored run only inside the same native storage/runtime scope.
+        const preparedFacilities = host.opencode ? await host.opencode({ connection, context }) : facilities;
+        signal.throwIfAborted();
+        if (host.opencode && (
+          binding.databasePath && binding.databasePath !== preparedFacilities.databasePath ||
+          binding.runtimeDirectory && binding.runtimeDirectory !== preparedFacilities.runtimeDirectory ||
+          facilities && facilities.runtime !== preparedFacilities.runtime
+        )) {
+          throw new Error("This OpenCode conversation belongs to another native history store or runtime. Restore its original host configuration.");
+        }
+        const allowCredentialRefresh = authoredPreparation && host.opencode && preparedFacilities.allowCredentialRefresh === true;
+        if (binding.accountIdentity && identity !== binding.accountIdentity && !allowCredentialRefresh) {
           throw new Error("This conversation belongs to another OpenCode account. Restore that connection or start a new conversation.");
         }
-        if (!binding.accountIdentity) await updateBinding({ accountIdentity: identity });
+        if (binding.accountIdentity !== identity) await updateBinding({ accountIdentity: identity });
         const model = { providerID: connection.providerId, id: connection.model };
         const agent = openCodeConversationAgent({ nativeTools, tools: Boolean(current?.tools) });
         if (current) current.agent = agent;
         if (binding.sessionId && !binding.databasePath) {
           throw new Error("This OpenCode conversation uses the earlier private native history layout. Run the offline native-history upgrade before continuing; no history was changed.");
         }
-        if (!facilities) {
-          if (host.opencode) facilities = await host.opencode({ connection, context });
+        if (!facilities || host.opencode) {
+          if (host.opencode) facilities = preparedFacilities;
           else {
             const runtimeDirectory = path.join(stateDirectory, "shared", hash([identity, host.commands?.opencode || "opencode"]));
             const selected = { modelProviderId: connection.providerId, canonicalUrl: connection.baseURL || "",
@@ -649,9 +666,14 @@ export function createOpenCodeConversationDriver({ connections, host = {}, limit
       }
 
       return Object.freeze({
-        async inspectAdmission({ messageId, configuration, context }) {
+        async inspectAdmission({ messageId, threadId, configuration, context, verifyAccount = false, receiptBinding }) {
+          if (verifyAccount === true && (!receiptBinding || threadId !== binding.sessionId || receiptBinding.sessionId !== binding.sessionId ||
+              receiptBinding.workdir !== binding.workdir || receiptBinding.directory !== binding.directory ||
+              receiptBinding.databasePath !== binding.databasePath || receiptBinding.runtimeDirectory !== binding.runtimeDirectory)) {
+            throw new Error("The completed OpenCode response belongs to a different native conversation or host scope.");
+          }
           if (!binding.sessionId) return { accepted: false, messages: [] };
-          const prepared = await prepare(await resolvePreparation(configuration, context, AbortSignal.timeout(120_000)));
+          const prepared = await prepare(await resolvePreparation(configuration, context, AbortSignal.timeout(120_000), verifyAccount === true, receiptBinding));
           await ensureOpenCodeSession(prepared.target, prepared.session);
           const id = nativeMessageId(messageId);
           const { accepted = false, messages = [] } = await inspectOpenCodeMessageAdmission(native.server.client, binding.sessionId, id) || {};
@@ -671,7 +693,7 @@ export function createOpenCodeConversationDriver({ connections, host = {}, limit
           let problem;
           try {
             active.resolved = await resolvePreparation(command.configuration, command.context,
-              AbortSignal.any([command.signal, AbortSignal.timeout(120_000)]));
+              AbortSignal.any([command.signal, AbortSignal.timeout(120_000)]), false, undefined, true);
             let dispatchFailure;
             try { await send(command); }
             catch (error) { dispatchFailure = error; }