@jskit-ai/assistant-core 0.2.7 → 0.2.9

package/src/server/conversation/codexTurnActivity.js

@@ -0,0 +1,210 @@
+import { codexAppServerTurnStatusIsActive, codexAppServerAgentRun, codexAppServerPendingUserMessageClientIds, codexAppServerTurnOwnsActiveGoal, codexAppServerTurnCanReceiveProviderActivity, codexAppServerTurnCanAdoptSuccessor, codexAppServerTurnKey, CODEX_APP_SERVER_RUN_STATE } from "./codexTurnState.js";
+import { } from "./codexThreadSnapshot.js";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+
+/**
+ * Records the native activity the provider reports for the tracked turn: a turn that is starting or working, and
+ * the provider's own identity for it.
+ * @param {object} dependencies
+ * @param {import("./codexRunJournal.js").CodexRunJournal} dependencies.journal
+ * @param {import("./codexOutput.js").CodexAppServerOutput} dependencies.output
+ * @param {import("./codexResultSettlement.js").CodexResultSettlement} dependencies.settlement
+ * @param {import("./codexTurn.js").CodexCreateRuntime} dependencies.createRuntime
+ * @param {import("./codexTurn.js").CodexCreateStore} dependencies.createStore
+ * @param {import("./codexTurn.js").CodexDebugLog} dependencies.debugLog
+ * @param {import("./codexTurn.js").CodexTurnStateReader} dependencies.turnState
+ * @param {import("./codexTurn.js").CodexAgentRunTurnStateReader} dependencies.turnStateFromAgentRun
+ * @param {(sessionId: string, delayMs?: number) => void} dependencies.scheduleActiveRecovery
+ */
+export function createCodexTurnActivity({
+  journal,
+  output,
+  settlement,
+  createRuntime,
+  createStore,
+  debugLog,
+  turnState,
+  turnStateFromAgentRun,
+  scheduleActiveRecovery
+}) {
+
+  async function markCodexAppServerTurnActive(sessionId = "", input = {}) {
+    if (input.requireTrackedTurn === true) {
+      const runtime = await createRuntime();
+      const session = await runtime.getSession(sessionId);
+      const turn = turnState(session);
+      if (!codexAppServerTurnCanReceiveProviderActivity(turn, input.threadId, input.turnId)) {
+        debugLog("appServerTurn.active.ignored", {
+          currentState: turn.state,
+          currentStatus: turn.status,
+          currentThreadId: turn.threadId,
+          currentTurnId: turn.turnId,
+          sessionId: normalizeText(sessionId),
+          threadId: normalizeText(input.threadId),
+          turnId: normalizeText(input.turnId)
+        });
+        return {
+          ok: true,
+          processed: false,
+          reason: "untracked_terminal_turn"
+        };
+      }
+    }
+    const status = normalizeText(input.status) || "inProgress";
+    const result = await journal.publishAgentRun(sessionId, {
+      inputSource: normalizeText(input.inputSource),
+      phase: input.phase,
+      publishReason: "codex-app-server-turn-active",
+      observedRun: input.observedRun,
+      runState: status === "starting" ? CODEX_APP_SERVER_RUN_STATE.STARTING : CODEX_APP_SERVER_RUN_STATE.ACTIVE,
+      status,
+      threadId: normalizeText(input.threadId),
+      turnId: normalizeText(input.turnId)
+    });
+    if (status === "starting") {
+      scheduleActiveRecovery(sessionId);
+    } else {
+      journal.clearActiveTimer(sessionId);
+    }
+    return result;
+  }
+
+  async function markCodexAppServerProviderTurnActive(sessionId = "", input = {}) {
+    const normalizedSessionId = normalizeText(sessionId);
+    const normalizedThreadId = normalizeText(input.threadId);
+    const normalizedTurnId = normalizeText(input.turnId);
+    const requestedStatus = normalizeText(input.status) || "inProgress";
+    const store = await createStore(normalizedSessionId);
+    const persistedRun = await output.readAgentRunForSession(
+      store,
+      normalizedSessionId
+    );
+    const persistedTurn = turnStateFromAgentRun(persistedRun || {});
+    const requestedInputSource = normalizeText(input.inputSource);
+    if (
+      persistedTurn.active &&
+      persistedTurn.state === "active" &&
+      persistedTurn.threadId === normalizedThreadId &&
+      persistedTurn.turnId === normalizedTurnId &&
+      codexAppServerTurnStatusIsActive(requestedStatus) &&
+      (!requestedInputSource || requestedInputSource === persistedTurn.inputSource)
+    ) {
+      journal.clearActiveTimer(normalizedSessionId);
+      return {
+        ok: true,
+        processed: false,
+        reason: "already_active"
+      };
+    }
+    const runtime = await createRuntime();
+    let session = await runtime.getSession(normalizedSessionId);
+    let turn = turnState(session);
+    if (
+      input.observedRun &&
+      [CODEX_APP_SERVER_RUN_STATE.FAILED, CODEX_APP_SERVER_RUN_STATE.INTERRUPTED].includes(turn.runState) &&
+      turn.threadId === normalizedThreadId &&
+      turn.turnId === normalizedTurnId &&
+      !journal.turnResultWasProcessed(session, normalizedThreadId, normalizedTurnId)
+    ) {
+      const recovered = await markCodexAppServerTurnActive(normalizedSessionId, {
+        inputSource: turn.inputSource,
+        observedRun: input.observedRun,
+        status: requestedStatus,
+        threadId: normalizedThreadId,
+        turnId: normalizedTurnId
+      });
+      if (recovered.processed !== false) {
+        journal.completedTurns.delete(codexAppServerTurnKey(normalizedThreadId, normalizedTurnId));
+        output.finalizedTurns.delete(output.resultFinalizationKey(
+          normalizedSessionId, normalizedThreadId, normalizedTurnId
+        ));
+      }
+      return recovered;
+    }
+    if (journal.turnWasCompleted(session, normalizedThreadId, normalizedTurnId)) {
+      debugLog("appServerProviderTurn.completed.ignored", {
+        currentState: turn.state,
+        currentThreadId: turn.threadId,
+        currentTurnId: turn.turnId,
+        sessionId: normalizedSessionId,
+        threadId: normalizedThreadId,
+        turnId: normalizedTurnId
+      });
+      return {
+        ok: true,
+        processed: false,
+        reason: "completed_turn"
+      };
+    }
+    if (
+      turn.state === "finalizing" &&
+      codexAppServerTurnCanAdoptSuccessor(turn, normalizedThreadId, normalizedTurnId) &&
+      journal.turnResultWasProcessed(session, normalizedThreadId, turn.turnId)
+    ) {
+      await settlement.finalizeAssistantResult(
+        normalizedSessionId,
+        normalizedThreadId,
+        turn.turnId,
+        {
+          status: turn.status || "completed"
+        }
+      );
+      session = await runtime.getSession(normalizedSessionId);
+      turn = turnState(session);
+    }
+    const currentRun = codexAppServerAgentRun(session);
+    const pendingInputSource = codexAppServerPendingUserMessageClientIds(currentRun).length > 0
+      ? journal.runInputSource(currentRun)
+      : "";
+    const goalInputSource = codexAppServerTurnOwnsActiveGoal(turn, normalizedThreadId)
+      ? journal.runInputSource(currentRun)
+      : "";
+    const inputSource = normalizeText(input.inputSource) || pendingInputSource || goalInputSource;
+    if (codexAppServerTurnCanReceiveProviderActivity(turn, normalizedThreadId, normalizedTurnId)) {
+      return markCodexAppServerTurnActive(normalizedSessionId, {
+        inputSource,
+        status: requestedStatus,
+        threadId: normalizedThreadId,
+        turnId: normalizedTurnId
+      });
+    }
+    if (codexAppServerTurnCanAdoptSuccessor(turn, normalizedThreadId, normalizedTurnId)) {
+      return settlement.adoptSuccessorTurn(normalizedSessionId, {
+        previousTurnId: turn.turnId,
+        source: normalizeText(input.source) || "provider_activity",
+        status: requestedStatus,
+        threadId: normalizedThreadId,
+        turnId: normalizedTurnId
+      });
+    }
+    if (turn.active || !normalizedTurnId) {
+      debugLog("appServerProviderTurn.active.ignored", {
+        currentState: turn.state,
+        currentStatus: turn.status,
+        currentThreadId: turn.threadId,
+        currentTurnId: turn.turnId,
+        sessionId: normalizedSessionId,
+        threadId: normalizedThreadId,
+        turnId: normalizedTurnId
+      });
+      return {
+        ok: true,
+        processed: false,
+        reason: turn.active ? "active_turn_mismatch" : "missing_turn"
+      };
+    }
+    return markCodexAppServerTurnActive(normalizedSessionId, {
+      inputSource: inputSource || "terminal",
+      status: requestedStatus,
+      threadId: normalizedThreadId,
+      turnId: normalizedTurnId
+    });
+  }
+
+  return Object.freeze({
+    markTurnActive: markCodexAppServerTurnActive,
+    markProviderTurnActive: markCodexAppServerProviderTurnActive
+  });
+}
+
+/** @typedef {ReturnType<typeof createCodexTurnActivity>} CodexTurnActivity */

package/src/server/conversation/codexTurnControl.js

@@ -1,19 +1,23 @@
-import {
-  codexAppServerTurnStatusIsComplete,
-  codexAppServerTurnStatusIsProviderFailure,
-  codexAppServerThreadStatus,
-  codexAppServerReadThreadStatus,
-  normalizeCodexRunText,
-  codexAppServerTurnCanAdoptSuccessor,
-  codexAppServerInterruptFailure,
-  codexAppServerInterruptUnavailableResponse,
-  codexAppServerFrozenTurnInterruptResponse
-} from "./codexTurnState.js";
-import { codexAppServerRequestIsInvalid } from "./codexProvider.js";
-import { codexAppServerThreadTurnId } from "./codexEvents.js";
+import { codexAppServerTurnStatusIsComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerThreadStatus, codexAppServerReadThreadStatus, codexAppServerTurnCanAdoptSuccessor, codexAppServerInterruptFailure, codexAppServerInterruptUnavailableResponse, codexAppServerFrozenTurnInterruptResponse } from "./codexTurnState.js";
+import { codexAppServerRequestIsInvalid } from "./codexProviderThreads.js";
+import { codexAppServerThreadTurnId } from "./codexThreadSnapshot.js";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 
-// Original user Stop control, including preflight and bounded successor races.
-// Existing journal, recovery and status owners retain their state.
+/**
+ * The person's Stop of a running turn, including its preflight and bounded successor races. The journal, recovery and
+ * status owners keep their state.
+ * @param {object} dependencies
+ * @param {import("./codexRunJournal.js").CodexRunJournal} dependencies.journal
+ * @param {import("./codexResultSettlement.js").CodexResultSettlement} dependencies.settlement
+ * @param {import("./codexTurnRecovery.js").CodexTurnRecovery} dependencies.recovery
+ * @param {import("./codexThreadStatus.js").CodexThreadStatus} dependencies.threadStatus
+ * @param {import("./codexTurn.js").CodexDebugError} dependencies.debugError
+ * @param {import("./codexTurn.js").CodexDebugLog} dependencies.debugLog
+ * @param {string} dependencies.errorPrefix
+ * @param {string} dependencies.interruptFailedCode
+ * @param {import("./codexTurn.js").CodexTurnOutcomes} dependencies.turnOutcomes
+ * @param {import("./codexTurn.js").CodexTurnStateReader} dependencies.turnState
+ */
 export function createCodexTurnControl({
   journal,
   settlement,
@@ -26,23 +30,13 @@ export function createCodexTurnControl({
   turnOutcomes,
   turnState
 }) {
-  const { turnResultWasProcessed: codexAppServerTurnResultWasProcessed } = journal;
-  const {
-    adoptSuccessorTurn: adoptCodexAppServerSuccessorTurn,
-    finalizeAssistantResult: finalizeCodexAppServerAssistantResult
-  } = settlement;
-  const {
-    stopTurnWithProviderFailure: stopCodexAppServerTurnWithProviderFailure,
-    completeTurn: completeCodexAppServerTurn
-  } = recovery;
-  const { reconcileThreadStatus: reconcileCodexAppServerThreadStatus } = threadStatus;
 
-  async function interruptCodexAppServerTurn(sessionId, input = {}, context = {}) {
+  async function interruptCodexAppServerTurn(sessionId, input, context = {}) {
     const { runtime } = context;
-    const controlRequestId = normalizeCodexRunText(input?.controlRequestId);
+    const controlRequestId = normalizeText(input?.controlRequestId);
     let currentSession = await runtime.getSession(sessionId);
     let currentTurn = turnState(currentSession);
-    let threadId = normalizeCodexRunText(currentTurn.threadId) ||
+    let threadId = normalizeText(currentTurn.threadId) ||
       context.threadId(currentSession);
     let provider = null;
     let providerPreflight = null;
@@ -72,13 +66,13 @@ export function createCodexTurnControl({
         providerPreflight = {
           status: providerStatus,
           threadId,
-          turnId: providerTurnId || normalizeCodexRunText(currentTurn.turnId)
+          turnId: providerTurnId || normalizeText(currentTurn.turnId)
         };
         if (
           providerTurnId &&
           codexAppServerTurnCanAdoptSuccessor(currentTurn, threadId, providerTurnId)
         ) {
-          await adoptCodexAppServerSuccessorTurn(sessionId, {
+          await settlement.adoptSuccessorTurn(sessionId, {
             previousTurnId: currentTurn.turnId,
             source: "interrupt_preflight",
             status: "inProgress",
@@ -100,15 +94,15 @@ export function createCodexTurnControl({
     for (let attempt = 0; attempt < 3; attempt += 1) {
       currentSession = await runtime.getSession(sessionId);
       currentTurn = turnState(currentSession);
-      threadId = normalizeCodexRunText(currentTurn.threadId) ||
+      threadId = normalizeText(currentTurn.threadId) ||
         context.threadId(currentSession);
-      const turnId = normalizeCodexRunText(currentTurn.turnId);
+      const turnId = normalizeText(currentTurn.turnId);
       if (context.admissionError()) {
         return { value: codexAppServerFrozenTurnInterruptResponse({ threadId, turnId }) };
       }
       if (currentTurn.state === "finalizing" && threadId) {
-        if (codexAppServerTurnResultWasProcessed(currentSession, threadId, turnId)) {
-          await finalizeCodexAppServerAssistantResult(sessionId, threadId, turnId, {
+        if (journal.turnResultWasProcessed(currentSession, threadId, turnId)) {
+          await settlement.finalizeAssistantResult(sessionId, threadId, turnId, {
             status: currentTurn.status || "completed"
           });
           currentSession = await runtime.getSession(sessionId);
@@ -123,9 +117,9 @@ export function createCodexTurnControl({
             turnId
           }, session: currentSession };
         }
-        const stoppedThreadId = normalizeCodexRunText(currentTurn.threadId) || threadId;
-        const stoppedTurnId = normalizeCodexRunText(currentTurn.turnId) || turnId;
-        const stopped = await stopCodexAppServerTurnWithProviderFailure(
+        const stoppedThreadId = normalizeText(currentTurn.threadId) || threadId;
+        const stoppedTurnId = normalizeText(currentTurn.turnId) || turnId;
+        const stopped = await recovery.stopTurnWithProviderFailure(
           sessionId,
           stoppedThreadId,
           stoppedTurnId,
@@ -202,12 +196,12 @@ export function createCodexTurnControl({
           codexAppServerTurnStatusIsComplete(providerPreflight.status)
         ) {
           if (codexAppServerTurnStatusIsProviderFailure(providerPreflight.status)) {
-            await stopCodexAppServerTurnWithProviderFailure(sessionId, threadId, turnId, {
+            await recovery.stopTurnWithProviderFailure(sessionId, threadId, turnId, {
               status: providerPreflight.status,
               verifyInactive: false
             });
           } else {
-            await completeCodexAppServerTurn(sessionId, threadId, turnId, {
+            await recovery.completeTurn(sessionId, threadId, turnId, {
               status: providerPreflight.status,
               verifyInactive: false
             });
@@ -222,22 +216,22 @@ export function createCodexTurnControl({
           }, session: settledSession };
         }
         providerPreflight = null;
-        await reconcileCodexAppServerThreadStatus(sessionId, provider, threadId, {
+        await threadStatus.reconcileThreadStatus(sessionId, provider, threadId, {
           source: "interrupt_race"
         }).catch(() => null);
         const reconciledSession = await runtime.getSession(sessionId);
         const reconciledTurn = turnState(reconciledSession);
         const successorIsActive = reconciledTurn.active === true &&
-          normalizeCodexRunText(reconciledTurn.threadId) === threadId &&
-          Boolean(normalizeCodexRunText(reconciledTurn.turnId)) &&
-          normalizeCodexRunText(reconciledTurn.turnId) !== turnId;
+          normalizeText(reconciledTurn.threadId) === threadId &&
+          Boolean(normalizeText(reconciledTurn.turnId)) &&
+          normalizeText(reconciledTurn.turnId) !== turnId;
         if (successorIsActive && attempt < 2) {
           continue;
         }
         const sameTurnIsActive = reconciledTurn.state === "active" &&
           reconciledTurn.active === true &&
-          normalizeCodexRunText(reconciledTurn.threadId) === threadId &&
-          normalizeCodexRunText(reconciledTurn.turnId) === turnId;
+          normalizeText(reconciledTurn.threadId) === threadId &&
+          normalizeText(reconciledTurn.turnId) === turnId;
         if (!sameTurnIsActive) {
           debugLog("appServerInterrupt.alreadyIdle", {
             controlRequestId,
@@ -278,7 +272,7 @@ export function createCodexTurnControl({
           turnId
         } };
       }
-      const stopped = await stopCodexAppServerTurnWithProviderFailure(sessionId, threadId, turnId, {
+      const stopped = await recovery.stopTurnWithProviderFailure(sessionId, threadId, turnId, {
         error: "Stopped by user.",
         ok: true,
         outcome: turnOutcomes.USER_CANCELLED,
@@ -286,7 +280,7 @@ export function createCodexTurnControl({
         verifyInactive: false
       });
       if (stopped?.reason === "stale_turn_state" && attempt < 2) {
-        await reconcileCodexAppServerThreadStatus(sessionId, provider, threadId, {
+        await threadStatus.reconcileThreadStatus(sessionId, provider, threadId, {
           source: "interrupt_settlement_race"
         }).catch(() => null);
         continue;
@@ -314,5 +308,7 @@ export function createCodexTurnControl({
     }, interruptFailedCode) };
   }
 
-  return { interruptTurn: interruptCodexAppServerTurn };
+  return Object.freeze({ interruptTurn: interruptCodexAppServerTurn });
 }
+
+/** @typedef {ReturnType<typeof createCodexTurnControl>} CodexTurnControl */