@jskit-ai/assistant-core 0.1.239 → 0.1.241

package/src/server/conversation/codexConversations.js

@@ -1,9 +1,9 @@
-import { codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerThreadStatus, normalizeCodexRunText, codexAppServerErrorMessage, codexAppServerSteerFailure, codexAppServerInterruptFailure, codexAppServerConversationTurnIsActive } from "./codexTurnState.js";
+import { codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerThreadStatus, normalizeCodexRunText, codexAppServerErrorMessage, codexAppServerSteerFailure, codexAppServerInterruptFailure, codexAppServerConversationTurnIsActive, codexAppServerNativeOuterTurnId } from "./codexTurnState.js";
 import { CODEX_APP_SERVER_DETACHED_TURN_TIMEOUT_MS, createCodexAppServerDetachedTurnWatcher } from "./codexDetachedTurn.js";
 import { assertCodexAppServerHelperAccountIdentity, readCodexAppServerAccountIdentity, sendPreparedCodexAppServerHelperTurn } from "./codexHelperExecution.js";
-import { codexAppServerRequestIsInvalid, codexAppServerThreadHasReadableHistory, codexAppServerThreadIsMissing, codexLocalImageInput, sendCodexAppServerPrompt } from "./codexProvider.js";
+import { codexAppServerDeliveredTurn, codexAppServerRequestIsInvalid, codexAppServerThreadHasReadableHistory, codexAppServerThreadIsMissing, codexLocalImageInput, sendCodexAppServerPrompt } from "./codexProvider.js";
 import { codexAppServerProjectHookTrustConfig, readCodexToolFreeConfiguration } from "./codexConfiguration.js";
-import { codexAppServerAssistantItemText, codexAppServerContentText, classifyCodexAppServerEvent, codexAppServerNotificationThreadId, codexAppServerNotificationTurnId, codexAppServerNotificationTurnStatus, codexAppServerErrorText, codexAppServerThreadRawValue, codexAppServerProviderThreadAssistantSegments, codexAppServerProviderTurnId, codexAppServerProviderTurnStatus, codexAppServerProviderTurnItems, codexAppServerProviderTurnClientIds, codexAppServerThreadTurnId, codexAppServerThreadError } from "./codexEvents.js";
+import { codexAppServerAssistantItemText, codexAppServerContentText, classifyCodexAppServerEvent, codexAppServerNotificationThreadId, codexAppServerNotificationTurnId, codexAppServerNotificationTurnStatus, codexAppServerThreadRawValue, codexAppServerProviderThreadAssistantSegments, codexAppServerProviderTurnId, codexAppServerProviderTurnStatus, codexAppServerProviderTurnItems, codexAppServerProviderTurnClientIds, codexAppServerThreadTurnId, codexAppServerThreadError } from "./codexEvents.js";
 
 // Internal command facet of the original run owner; the same native conversation
 // and turn-start collections retain their original lifetime and public references.
@@ -19,7 +19,10 @@ export function createCodexConversationCommands({
   interruptFailedCode,
   namespace,
   providerSessions,
-  steerFailedCode
+  sessionConnection,
+  ensureSessionProvider,
+  steerFailedCode,
+  turnOutcomes
 }) {
   const codexAppServerConversations = new Map();
   const codexAppServerConversationTurnStarts = new Map();
@@ -68,7 +71,7 @@ export function createCodexConversationCommands({
     let state = conversations.get(conversationId);
     if (state?.provider === provider && state.unsubscribe) return state;
     state?.unsubscribe?.();
-    state = { conversationId, provider, persistent: true, status: "ready", runId: "", error: "" };
+    state = { conversationId, provider, persistent: true, status: "ready", runId: "", error: "", turnOutcome: "" };
     state.unsubscribe = provider.subscribe((notification) => {
       if (codexAppServerNotificationThreadId(notification) !== conversationId) return;
       const turnId = codexAppServerNotificationTurnId(notification);
@@ -91,11 +94,15 @@ export function createCodexConversationCommands({
         state.onEvent = null;
         const completedTurnId = state.runId;
         const completedStatus = state.status;
+        // A turn the person stopped reaches the checkpoint as cancelled, as Main turns do.
+        const completedOutcome = state.turnOutcome;
+        state.turnOutcome = "";
         void checkpoint(sessionId, {
-          outerTurnId: `codex:${conversationId}:${completedTurnId}`,
+          outerTurnId: codexAppServerNativeOuterTurnId(conversationId, completedTurnId),
           threadId: conversationId,
           turnId: completedTurnId,
-          status: completedStatus
+          status: completedStatus,
+          turnOutcome: completedOutcome
         }).catch(() => {});
       }
     });
@@ -229,9 +236,7 @@ export function createCodexConversationCommands({
     const { context } = prepared;
     if (context.assistantScope) {
       const providerOptions = prepared.providerOptions;
-      const provider = await providerSessions.owner.ensureSession(
-        providerSessions.context(normalizeCodexRunText(sessionId), providerOptions)
-      );
+      const provider = await ensureSessionProvider(sessionId, providerOptions);
       const result = prepared.project(provider);
       result.isolationConfig = await readCodexToolFreeConfiguration(
         provider, context.workdir, conversationPreparation.isolation.assertCompatibility
@@ -251,21 +256,19 @@ export function createCodexConversationCommands({
       }
     }
     const managedIdentity = prepared.managedIdentity;
-    const restoredAdmissionError = conversationPreparation.admissionError(sessionId);
-    if (restoredAdmissionError) throw restoredAdmissionError;
+    const assertAdmitted = () => {
+      const error = conversationPreparation.admissionError(sessionId);
+      if (error) throw error;
+    };
+    assertAdmitted();
     const activeProvider = prepared.helperTurn
       ? null
       : await ensureCodexAppServerProviderForActiveTurn(context.session, managedIdentity);
-    const activeProviderAdmissionError = conversationPreparation.admissionError(sessionId);
-    if (activeProviderAdmissionError) throw activeProviderAdmissionError;
+    assertAdmitted();
     const providerOptions = activeProvider ? null : await prepared.providerOptions;
-    const providerOptionsAdmissionError = conversationPreparation.admissionError(sessionId);
-    if (providerOptionsAdmissionError) throw providerOptionsAdmissionError;
-    const provider = activeProvider?.provider || await providerSessions.owner.ensureSession(
-      providerSessions.context(normalizeCodexRunText(sessionId), providerOptions)
-    );
-    const providerAdmissionError = conversationPreparation.admissionError(sessionId);
-    if (providerAdmissionError) throw providerAdmissionError;
+    assertAdmitted();
+    const provider = activeProvider?.provider || await ensureSessionProvider(sessionId, providerOptions);
+    assertAdmitted();
     return prepared.project(provider, activeProvider?.providerOptions || providerOptions, helperRestore);
   }
 
@@ -369,11 +372,6 @@ export function createCodexConversationCommands({
         if (helperTurn) {
           try {
             await assertCodexAppServerHelperAccountIdentity(provider, input.expectedAccountIdentitySignature, helperOwnershipError);
-          } catch (error) {
-            await helper.discard();
-            throw error;
-          }
-          try {
             execution.validateOutput(result.text);
           } catch (error) {
             await helper.discard();
@@ -516,7 +514,9 @@ export function createCodexConversationCommands({
     });
   }
 
-  async function stopCodexAppServerConversation(sessionId, input = {}, options = {}) {
+  async function stopCodexAppServerConversation(sessionId, input = {}, options = {}, {
+    turnOutcome = turnOutcomes.USER_CANCELLED
+  } = {}) {
     const conversationId = normalizeCodexRunText(input.conversationId);
     const conversationState = codexAppServerConversation(sessionId, conversationId);
     if (conversationState?.provider.observationFailure) {
@@ -541,7 +541,8 @@ export function createCodexConversationCommands({
       return stopPersistentCodexConversation({
         conversationId,
         conversationState,
-        provider: context.provider
+        provider: context.provider,
+        turnOutcome
       });
     }
     const result = await interruptDetachedCodexAppServerConversationTurn(sessionId, {
@@ -586,7 +587,7 @@ export function createCodexConversationCommands({
       if (context.ok === false) {
         return context;
       }
-      const connection = providerSessions.context(normalizeCodexRunText(sessionId), context.providerOptions);
+      const connection = sessionConnection(sessionId, context.providerOptions);
       providerExit = await providerSessions.owner.stopProvider(connection.providerKey, context.providerOptions, {
         preserveProcessExitProof: false,
         requireStopped: true,
@@ -605,7 +606,9 @@ export function createCodexConversationCommands({
     const key = namespace(sessionId);
     for (const state of codexAppServerConversations.get(key)?.values() || []) {
       if (state.persistent) {
-        await stopCodexAppServerConversation(sessionId, { conversationId: state.conversationId, persistent: true });
+        // Closing is not the person stopping the turn; its status alone decides the outcome.
+        await stopCodexAppServerConversation(sessionId, { conversationId: state.conversationId, persistent: true },
+          {}, { turnOutcome: "" });
         state.unsubscribe?.();
       } else {
         await deleteScopedCodexAppServerConversation(sessionId, { conversationId: state.conversationId }).catch(() => null);
@@ -771,9 +774,7 @@ export function createCodexConversationCommands({
 
   async function dispatchCodexAppServerDetachedTurn({ provider, prompt, threadId }, authorized) {
     const delivery = await sendCodexAppServerPrompt({ provider, prompt, threadId }, authorized);
-    const turnId = normalizeCodexRunText(delivery.turn?.id);
-    const status = normalizeCodexRunText(delivery.turn?.status || delivery.turn?.raw?.status);
-    return { delivery, status, turnId };
+    return { delivery, ...codexAppServerDeliveredTurn(delivery) };
   }
 
   async function runDetachedCodexAppServerTurn({
@@ -819,12 +820,7 @@ export function createCodexConversationCommands({
       type: "turn"
     });
     if (codexAppServerTurnStatusIsProviderFailure(status)) {
-      const providerError = codexAppServerErrorText(
-        delivery.turn?.raw?.error ||
-        delivery.turn?.response?.turn?.error ||
-        delivery.turn?.error
-      );
-      const error = new Error(providerError || `Codex app-server turn ${status}.`);
+      const error = new Error(codexAppServerDeliveredTurn(delivery).error || `Codex app-server turn ${status}.`);
       await throwWatcherFailure(error, status, {
         waitForDetail: true
       });
@@ -915,7 +911,7 @@ export function createCodexConversationCommands({
       conversationState.watcher = watcher;
     }
     let delivery = null;
-    if (input.persistent && conversationState) conversationState.onEvent = onEvent;
+    if (input.persistent && conversationState) Object.assign(conversationState, { onEvent, turnOutcome: "" });
     try {
       await input.onPromptSending?.({ threadId: conversationId });
       if (executionProfile) {
@@ -945,8 +941,7 @@ export function createCodexConversationCommands({
       }
       throw error;
     }
-    const runId = normalizeCodexRunText(delivery.turn?.id);
-    const status = normalizeCodexRunText(delivery.turn?.status || delivery.turn?.raw?.status);
+    const { turnId: runId, status } = codexAppServerDeliveredTurn(delivery);
     if (!runId) {
       watcher?.failNow(new Error("Codex app-server accepted a conversation turn without returning its id."));
       await waitForResult?.catch(() => null);
@@ -1083,13 +1078,21 @@ export function createCodexConversationCommands({
   async function stopPersistentCodexConversation({
     conversationId,
     conversationState,
-    provider
+    provider,
+    turnOutcome = ""
   } = {}) {
+    // Set before stopping: the provider can report turn/completed while it stops.
+    if (conversationState && codexAppServerConversationTurnIsActive(conversationState.status)) {
+      conversationState.turnOutcome = turnOutcome;
+    }
     try {
       await provider.readThreadStatus(conversationId);
       await provider.stopThreadForObservationLoss(conversationId, "");
     } catch (error) {
-      if (!codexAppServerThreadIsMissing(error, conversationId) || error.message.toLowerCase().startsWith("thread not loaded:")) throw error;
+      if (!codexAppServerThreadIsMissing(error, conversationId) || error.message.toLowerCase().startsWith("thread not loaded:")) {
+        if (conversationState) conversationState.turnOutcome = "";
+        throw error;
+      }
     }
     if (conversationState) {
       conversationState.status = "interrupted";

package/src/server/conversation/codexDetachedTurn.js

@@ -1,4 +1,5 @@
-import { normalizeText, isPlainObject } from "./normalize.js";
+import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
+import { normalizeNullableText } from "./normalize.js";
 import { classifyCodexAppServerEvent, codexAppServerNotificationParams, codexAppServerNotificationThreadId, codexAppServerNotificationTurnId, codexAppServerNotificationTurnStatus, codexAppServerNotificationError, codexAppServerStatusFromValue, codexAppServerProviderThreadAssistantSegments, codexAppServerProviderTurnId, codexAppServerProviderTurnStatus, codexAppServerProviderTurnForOperation, codexAppServerProviderTurnText, codexAppServerProviderTurnError } from "./codexEvents.js";
 import { codexAppServerTurnStatusIsProviderFailure, codexAppServerTurnStatusIsSuccessfulComplete } from "./codexTurnState.js";
 
@@ -6,12 +7,12 @@ const CODEX_APP_SERVER_DETACHED_TURN_TIMEOUT_MS = 180_000;
 const CODEX_APP_SERVER_DETACHED_FAILURE_DETAIL_GRACE_MS = 500;
 
 function codexAppServerTurnTokenUsage(notification = {}) {
-  if (normalizeText(notification.method) !== "thread/tokenUsage/updated") {
+  if (normalizeNullableText(notification.method) !== "thread/tokenUsage/updated") {
     return null;
   }
   const params = codexAppServerNotificationParams(notification);
-  const tokenUsage = isPlainObject(params.tokenUsage) ? params.tokenUsage : {};
-  const turnUsage = isPlainObject(tokenUsage.last) ? tokenUsage.last : tokenUsage;
+  const tokenUsage = isRecord(params.tokenUsage) ? params.tokenUsage : {};
+  const turnUsage = isRecord(tokenUsage.last) ? tokenUsage.last : tokenUsage;
   const snapshot = {};
   for (const field of [
     "cachedInputTokens",
@@ -35,7 +36,7 @@ function createCodexAppServerDetachedTurnWatcher(provider = null, threadId = "",
   onEvent = null,
   timeoutMs = CODEX_APP_SERVER_DETACHED_TURN_TIMEOUT_MS
 } = {}) {
-  const normalizedThreadId = normalizeText(threadId);
+  const normalizedThreadId = normalizeNullableText(threadId);
   let targetTurnId = "";
   let finalText = "";
   let usage = null;
@@ -106,7 +107,7 @@ function createCodexAppServerDetachedTurnWatcher(provider = null, threadId = "",
     const rawStatus = thread.raw?.status || thread.response?.thread?.status;
     return {
       status: codexAppServerStatusFromValue(rawStatus),
-      statusType: normalizeText(typeof rawStatus === "string" ? rawStatus : rawStatus?.type),
+      statusType: normalizeNullableText(typeof rawStatus === "string" ? rawStatus : rawStatus?.type),
       text: codexAppServerProviderThreadAssistantSegments(thread, targetTurnId)
         .map((segment) => segment.text)
         .join("\n\n")
@@ -126,7 +127,7 @@ function createCodexAppServerDetachedTurnWatcher(provider = null, threadId = "",
   async function finishFromCompletion(status = "completed") {
     try {
       if (!targetTurnId) {
-        pendingCompletionStatus = normalizeText(status) || "completed";
+        pendingCompletionStatus = normalizeNullableText(status) || "completed";
         return;
       }
       const authoritative = await resultFromThread().catch(() => ({
@@ -136,7 +137,7 @@ function createCodexAppServerDetachedTurnWatcher(provider = null, threadId = "",
       }));
       finalText = authoritative.text || finalText;
       if (!finalText && !allowEmptyResponse) {
-        pendingCompletionStatus = normalizeText(status) || "completed";
+        pendingCompletionStatus = normalizeNullableText(status) || "completed";
         const systemError = authoritative.statusType === "systemError" || authoritative.status === "failed";
         failAfterDetailGrace(new Error(systemError
           ? "Codex app-server thread entered a system error before producing an assistant response."
@@ -175,7 +176,7 @@ function createCodexAppServerDetachedTurnWatcher(provider = null, threadId = "",
       failAfterDetailGrace(error);
     },
     setTurnId(turnId = "") {
-      targetTurnId = normalizeText(turnId);
+      targetTurnId = normalizeNullableText(turnId);
       if (pendingFailure) {
         failAfterDetailGrace(pendingFailure);
         return;
@@ -240,7 +241,7 @@ function createCodexAppServerDetachedTurnWatcher(provider = null, threadId = "",
                   void finishFromCompletion(status);
                 }
               }
-              const method = normalizeText(notification.method);
+              const method = normalizeNullableText(notification.method);
               if (method !== "turn/completed" && method !== "thread/status/changed") {
                 return;
               }
@@ -279,7 +280,7 @@ async function waitForCodexAppServerTurn(provider, threadId = "", turn = null, {
   timeoutMs = CODEX_APP_SERVER_DETACHED_TURN_TIMEOUT_MS,
   createError = codexAppServerTurnError
 } = {}) {
-  const normalizedThreadId = normalizeText(threadId || "");
+  const normalizedThreadId = normalizeNullableText(threadId || "");
   const turnId = codexAppServerProviderTurnId(turn || {});
   const status = codexAppServerProviderTurnStatus(turn || {});
   if (!normalizedThreadId || !turnId) {