@jskit-ai/assistant-core 0.2.7 → 0.2.9

package/src/server/conversation/codexRenewalThreads.js

@@ -1,10 +1,7 @@
 import { normalizeNullableText as normalizeAgentText } from "./normalize.js";
 import { codexAppServerProjectHookTrustConfig, codexAppServerTextHasControlCharacters } from "./codexConfiguration.js";
-import {
-  codexAppServerRequestIsInvalid,
-  CODEX_APP_SERVER_THREAD_INVENTORY_ID_MAX_LENGTH,
-  CODEX_APP_SERVER_THREAD_INVENTORY_MAX_COUNT
-} from "./codexProvider.js";
+import { codexAppServerRequestIsInvalid } from "./codexProviderThreads.js";
+import { CODEX_APP_SERVER_THREAD_INVENTORY_ID_MAX_LENGTH, CODEX_APP_SERVER_THREAD_INVENTORY_MAX_COUNT } from "./codexProviderInventories.js";
 
 // Renewal thread operations: resume the exact retained thread, or prove a
 // genuinely fresh successor thread for one renewal operation.
@@ -41,7 +38,7 @@ export function defineCodexRenewalThreadIds(value = [], {
 }
 
 async function listCodexRenewalThreadIds(provider, workdir, errorCode) {
-  if (typeof provider?.listAppServerThreadsForCwd !== "function") {
+  if (!provider) {
     throw codexRenewalThreadError(
       errorCode,
       "The assistant provider cannot inventory the successor's exact session threads."
@@ -118,10 +115,7 @@ async function readCodexRenewalSuccessorThreadSnapshot({
       { threadId, workdir, errorCode }
     );
   } catch (error) {
-    if (
-      !codexRenewalThreadNeedsStatusRead(error, threadId) ||
-      typeof provider?.readThreadStatus !== "function"
-    ) {
+    if (!codexRenewalThreadNeedsStatusRead(error, threadId)) {
       throw error;
     }
     return assertCodexRenewalThreadSnapshot(
@@ -163,11 +157,7 @@ export async function resumeExactCodexAppServerThread({
 } = {}) {
   const normalizedWorkdir = normalizeAgentText(workdir);
   const normalizedExpectedThreadId = normalizeAgentText(expectedThreadId);
-  if (
-    typeof provider?.ensureRuntime !== "function" ||
-    typeof provider?.resumeThread !== "function" ||
-    typeof provider?.readThread !== "function"
-  ) {
+  if (!provider) {
     throw codexRenewalThreadError(
       errorCode,
       "The old assistant provider cannot read its exact main thread.",
@@ -224,7 +214,7 @@ export async function resumeExactCodexAppServerThread({
   });
 }
 
-/** Preserve the original baseline → create/adopt → durable identity → first-read order. */
+/** Starts a thread in order: baseline, create or adopt, durable identity, first read. */
 export async function startFreshCodexAppServerThread({
   provider,
   settings,
@@ -247,12 +237,7 @@ export async function startFreshCodexAppServerThread({
       { forbiddenThreadId: normalizedForbiddenThreadId }
     );
   }
-  if (
-    typeof provider?.ensureRuntime !== "function" ||
-    typeof provider?.resumeThread !== "function" ||
-    typeof provider?.readThread !== "function" ||
-    typeof provider?.startThread !== "function"
-  ) {
+  if (!provider) {
     throw codexRenewalThreadError(
       errorCode,
       "The assistant provider cannot prove a genuinely fresh renewal thread."

package/src/server/conversation/codexResultSettlement.js

@@ -1,49 +1,29 @@
-import {
-  normalizeCodexRunText,
-  CODEX_APP_SERVER_AGENT_RUN_ID,
-  CODEX_APP_SERVER_RESULT_PROCESSED_EVENT,
-  codexAppServerTurnCanReceiveProviderCompletion,
-  codexAppServerProcessedResultEvent,
-  codexAppServerTurnAwaitsProviderIdentity,
-  codexAppServerTurnCanAdoptSuccessor,
-  codexAppServerAgentRun,
-  CODEX_APP_SERVER_RUN_STATE,
-  codexAppServerTurnKey
-} from "./codexTurnState.js";
+import { CODEX_APP_SERVER_AGENT_RUN_ID, CODEX_APP_SERVER_RESULT_PROCESSED_EVENT, codexAppServerTurnCanReceiveProviderCompletion, codexAppServerProcessedResultEvent, codexAppServerTurnAwaitsProviderIdentity, codexAppServerTurnCanAdoptSuccessor, codexAppServerAgentRun, CODEX_APP_SERVER_RUN_STATE, codexAppServerTurnKey } from "./codexTurnState.js";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 
-// Original result settlement and successor adoption for one retained run owner.
-// Journal/output collections remain with their owners and are shared by reference.
+/**
+ * Result settlement and successor adoption for one retained run owner. Journal and output collections remain with
+ * their owners and are shared by reference.
+ * @param {object} dependencies
+ * @param {import("./codexRunJournal.js").CodexRunJournal} dependencies.journal
+ * @param {import("./codexOutput.js").CodexAppServerOutput} dependencies.output
+ * @param {import("./codexTurn.js").CodexCreateRuntime} dependencies.createRuntime
+ * @param {import("./codexTurn.js").CodexPublish} dependencies.publish
+ * @param {import("./codexTurn.js").CodexDebugLog} dependencies.debugLog
+ * @param {import("./codexTurn.js").CodexDebugError} dependencies.debugError
+ * @param {import("./codexTurn.js").CodexTurnStateReader} dependencies.turnState
+ */
 export function createCodexResultSettlement({ journal, output, createRuntime, publish, debugLog, debugError, turnState }) {
-  const {
-    processedTurns: codexAppServerProcessedTurns,
-    completedTurns: codexAppServerCompletedTurns,
-    agentRunPatch,
-    markTurnIdle: markCodexAppServerTurnIdle,
-    turnResultWasProcessed: codexAppServerTurnResultWasProcessed,
-    turnWasCompleted: codexAppServerTurnWasCompleted,
-    runInputSource: codexAppServerRunInputSource,
-    clearFinalizingTimer: clearCodexAppServerFinalizingTimer,
-    agentRunRealtimePayload: codexAppServerAgentRunRealtimePayload,
-    clearActiveTimer: clearCodexAppServerActiveTimer
-  } = journal;
-  const {
-    finalizedTurns: codexAppServerFinalizedTurns,
-    resultFinalizationKey: codexAppServerResultFinalizationKey,
-    cleanupUntrackedTurn: cleanupCodexAppServerUntrackedTurn,
-    submitAssistantResult: submitCodexAppServerAssistantResult,
-    flushReasoningPersist: flushCodexAppServerReasoningPersist,
-    readFinalAssistantResult: readCodexAppServerFinalAssistantResult,
-    persistAssistantReply: persistCodexAppServerAssistantReply
-  } = output;
+  const { agentRunPatch } = journal;
   const codexAppServerResultFinalizations = new Map();
 
   async function recordCodexAppServerProcessedResult(runtime, sessionId = "", threadId = "", turnId = "", result = {}) {
     await runtime.store.writeAgentRunEvent(sessionId, CODEX_APP_SERVER_AGENT_RUN_ID, {
       event: {
         kind: CODEX_APP_SERVER_RESULT_PROCESSED_EVENT,
-        providerThreadId: normalizeCodexRunText(threadId),
-        providerTurnId: normalizeCodexRunText(turnId),
-        resultReason: normalizeCodexRunText(result.reason)
+        providerThreadId: normalizeText(threadId),
+        providerTurnId: normalizeText(turnId),
+        resultReason: normalizeText(result.reason)
       },
       patch: {}
     });
@@ -57,17 +37,17 @@ export function createCodexResultSettlement({ journal, output, createRuntime, pu
     },
     status = "completed"
   } = {}) {
-    const normalizedSessionId = normalizeCodexRunText(sessionId);
-    const normalizedThreadId = normalizeCodexRunText(threadId);
-    const normalizedTurnId = normalizeCodexRunText(turnId);
-    const key = codexAppServerResultFinalizationKey(normalizedSessionId, normalizedThreadId, normalizedTurnId);
+    const normalizedSessionId = normalizeText(sessionId);
+    const normalizedThreadId = normalizeText(threadId);
+    const normalizedTurnId = normalizeText(turnId);
+    const key = output.resultFinalizationKey(normalizedSessionId, normalizedThreadId, normalizedTurnId);
     const runtime = await createRuntime();
     const session = await runtime.getSession(normalizedSessionId);
     const turn = turnState(session);
     if (!codexAppServerTurnCanReceiveProviderCompletion(turn, normalizedThreadId, normalizedTurnId)) {
-      codexAppServerProcessedTurns.delete(key);
-      codexAppServerFinalizedTurns.add(key);
-      cleanupCodexAppServerUntrackedTurn(normalizedThreadId, normalizedTurnId);
+      journal.processedTurns.delete(key);
+      output.finalizedTurns.add(key);
+      output.cleanupUntrackedTurn(normalizedThreadId, normalizedTurnId);
       debugLog("appServerAgentResult.processedSettlementStale", {
         currentState: turn.state,
         currentStatus: turn.status,
@@ -82,14 +62,14 @@ export function createCodexResultSettlement({ journal, output, createRuntime, pu
         reason: "stale_turn_state"
       };
     }
-    await markCodexAppServerTurnIdle(normalizedSessionId, {
+    await journal.markTurnIdle(normalizedSessionId, {
       status,
       threadId: normalizedThreadId,
       turnId: normalizedTurnId
     });
-    codexAppServerProcessedTurns.delete(key);
-    codexAppServerFinalizedTurns.add(key);
-    cleanupCodexAppServerUntrackedTurn(normalizedThreadId, normalizedTurnId);
+    journal.processedTurns.delete(key);
+    output.finalizedTurns.add(key);
+    output.cleanupUntrackedTurn(normalizedThreadId, normalizedTurnId);
     return result;
   }
 
@@ -97,10 +77,10 @@ export function createCodexResultSettlement({ journal, output, createRuntime, pu
     recoverFromProvider = false,
     status = "completed"
   } = {}) {
-    const normalizedSessionId = normalizeCodexRunText(sessionId);
-    const normalizedThreadId = normalizeCodexRunText(threadId);
-    const normalizedTurnId = normalizeCodexRunText(turnId);
-    const key = codexAppServerResultFinalizationKey(normalizedSessionId, normalizedThreadId, normalizedTurnId);
+    const normalizedSessionId = normalizeText(sessionId);
+    const normalizedThreadId = normalizeText(threadId);
+    const normalizedTurnId = normalizeText(turnId);
+    const key = output.resultFinalizationKey(normalizedSessionId, normalizedThreadId, normalizedTurnId);
     if (!normalizedSessionId || !normalizedThreadId || !normalizedTurnId) {
       return {
         ok: false,
@@ -108,7 +88,7 @@ export function createCodexResultSettlement({ journal, output, createRuntime, pu
         reason: "missing_turn"
       };
     }
-    if (codexAppServerProcessedTurns.has(key)) {
+    if (journal.processedTurns.has(key)) {
       return settleCodexAppServerProcessedTurn(
         normalizedSessionId,
         normalizedThreadId,
@@ -118,7 +98,7 @@ export function createCodexResultSettlement({ journal, output, createRuntime, pu
         }
       );
     }
-    if (codexAppServerFinalizedTurns.has(key)) {
+    if (output.finalizedTurns.has(key)) {
       return {
         ok: true,
         processed: true,
@@ -139,7 +119,7 @@ export function createCodexResultSettlement({ journal, output, createRuntime, pu
         normalizedTurnId
       );
       if (processedEvent) {
-        codexAppServerProcessedTurns.add(key);
+        journal.processedTurns.add(key);
         return settleCodexAppServerProcessedTurn(
           normalizedSessionId,
           normalizedThreadId,
@@ -148,7 +128,7 @@ export function createCodexResultSettlement({ journal, output, createRuntime, pu
             result: {
               ok: true,
               processed: true,
-              reason: normalizeCodexRunText(processedEvent.resultReason) || "already_processed"
+              reason: normalizeText(processedEvent.resultReason) || "already_processed"
             },
             status
           }
@@ -162,8 +142,8 @@ export function createCodexResultSettlement({ journal, output, createRuntime, pu
         };
       }
       if (!codexAppServerTurnCanReceiveProviderCompletion(turn, normalizedThreadId, normalizedTurnId)) {
-        codexAppServerFinalizedTurns.add(key);
-        cleanupCodexAppServerUntrackedTurn(normalizedThreadId, normalizedTurnId);
+        output.finalizedTurns.add(key);
+        output.cleanupUntrackedTurn(normalizedThreadId, normalizedTurnId);
         debugLog("appServerAgentResult.stale", {
           currentState: turn.state,
           currentStatus: turn.status,
@@ -179,7 +159,7 @@ export function createCodexResultSettlement({ journal, output, createRuntime, pu
           reason: "stale_turn_state"
         };
       }
-      const result = await submitCodexAppServerAssistantResult(
+      const result = await output.submitAssistantResult(
         normalizedSessionId,
         normalizedThreadId,
         normalizedTurnId,
@@ -188,7 +168,7 @@ export function createCodexResultSettlement({ journal, output, createRuntime, pu
         }
       );
       if (result?.processed) {
-        codexAppServerProcessedTurns.add(key);
+        journal.processedTurns.add(key);
         await recordCodexAppServerProcessedResult(
           runtime,
           normalizedSessionId,
@@ -237,7 +217,7 @@ export function createCodexResultSettlement({ journal, output, createRuntime, pu
     }
     const runtime = await createRuntime();
     const session = await runtime.getSession(sessionId);
-    return codexAppServerTurnResultWasProcessed(session, threadId, turnId)
+    return journal.turnResultWasProcessed(session, threadId, turnId)
       ? result
       : {
           ...result,
@@ -247,10 +227,10 @@ export function createCodexResultSettlement({ journal, output, createRuntime, pu
   }
 
   async function adoptCodexAppServerSuccessorTurn(sessionId = "", input = {}) {
-    const normalizedSessionId = normalizeCodexRunText(sessionId);
-    const normalizedThreadId = normalizeCodexRunText(input.threadId);
-    const normalizedTurnId = normalizeCodexRunText(input.turnId);
-    const expectedPreviousTurnId = normalizeCodexRunText(input.previousTurnId);
+    const normalizedSessionId = normalizeText(sessionId);
+    const normalizedThreadId = normalizeText(input.threadId);
+    const normalizedTurnId = normalizeText(input.turnId);
+    const expectedPreviousTurnId = normalizeText(input.previousTurnId);
     if (!normalizedSessionId || !normalizedThreadId || !normalizedTurnId || !expectedPreviousTurnId) {
       return {
         ok: true,
@@ -270,8 +250,8 @@ export function createCodexResultSettlement({ journal, output, createRuntime, pu
       const currentSession = await runtime.getSession(normalizedSessionId);
       const currentTurn = turnState(currentSession);
       if (
-        normalizeCodexRunText(currentTurn.threadId) === normalizedThreadId &&
-        normalizeCodexRunText(currentTurn.turnId) === normalizedTurnId
+        normalizeText(currentTurn.threadId) === normalizedThreadId &&
+        normalizeText(currentTurn.turnId) === normalizedTurnId
       ) {
         outcome = {
           ok: true,
@@ -280,7 +260,7 @@ export function createCodexResultSettlement({ journal, output, createRuntime, pu
         };
         return currentSession;
       }
-      if (codexAppServerTurnWasCompleted(currentSession, normalizedThreadId, normalizedTurnId)) {
+      if (journal.turnWasCompleted(currentSession, normalizedThreadId, normalizedTurnId)) {
         outcome = {
           ok: true,
           processed: false,
@@ -289,7 +269,7 @@ export function createCodexResultSettlement({ journal, output, createRuntime, pu
         return currentSession;
       }
       if (
-        normalizeCodexRunText(currentTurn.turnId) !== expectedPreviousTurnId ||
+        normalizeText(currentTurn.turnId) !== expectedPreviousTurnId ||
         !codexAppServerTurnCanAdoptSuccessor(currentTurn, normalizedThreadId, normalizedTurnId)
       ) {
         outcome = {
@@ -299,17 +279,17 @@ export function createCodexResultSettlement({ journal, output, createRuntime, pu
         };
         return currentSession;
       }
-      previousTurnId = normalizeCodexRunText(currentTurn.turnId);
+      previousTurnId = normalizeText(currentTurn.turnId);
       const updatedAt = new Date().toISOString();
       runPatch = agentRunPatch({
         runState: CODEX_APP_SERVER_RUN_STATE.ACTIVE,
         session: currentSession,
-        status: normalizeCodexRunText(input.status) || "inProgress",
+        status: normalizeText(input.status) || "inProgress",
         threadId: normalizedThreadId,
         turnId: normalizedTurnId,
         updatedAt
       });
-      const currentInputSource = codexAppServerRunInputSource(codexAppServerAgentRun(currentSession));
+      const currentInputSource = journal.runInputSource(codexAppServerAgentRun(currentSession));
       if (currentInputSource) {
         runPatch.inputSource = currentInputSource;
       }
@@ -321,7 +301,7 @@ export function createCodexResultSettlement({ journal, output, createRuntime, pu
           previousProviderTurnId: previousTurnId,
           providerThreadId: normalizedThreadId,
           providerTurnId: normalizedTurnId,
-          source: normalizeCodexRunText(input.source),
+          source: normalizeText(input.source),
           state: runPatch.state
         },
         patch: runPatch
@@ -340,35 +320,35 @@ export function createCodexResultSettlement({ journal, output, createRuntime, pu
       return outcome;
     }
 
-    clearCodexAppServerFinalizingTimer(
+    journal.clearFinalizingTimer(
       normalizedSessionId,
       normalizedThreadId,
       previousTurnId
     );
-    codexAppServerCompletedTurns.add(codexAppServerTurnKey(
+    journal.completedTurns.add(codexAppServerTurnKey(
       normalizedThreadId,
       previousTurnId
     ));
-    const previousResultKey = codexAppServerResultFinalizationKey(
+    const previousResultKey = output.resultFinalizationKey(
       normalizedSessionId,
       normalizedThreadId,
       previousTurnId
     );
-    codexAppServerProcessedTurns.delete(previousResultKey);
-    codexAppServerFinalizedTurns.add(previousResultKey);
+    journal.processedTurns.delete(previousResultKey);
+    output.finalizedTurns.add(previousResultKey);
     try {
-      await flushCodexAppServerReasoningPersist(
+      await output.flushReasoningPersist(
         normalizedSessionId,
         normalizedThreadId,
         previousTurnId
       );
-      const previousAssistantResult = readCodexAppServerFinalAssistantResult(
+      const previousAssistantResult = output.readFinalAssistantResult(
         normalizedSessionId,
         normalizedThreadId,
         previousTurnId
       );
       if (previousAssistantResult?.text) {
-        await persistCodexAppServerAssistantReply(
+        await output.persistAssistantReply(
           runtime,
           normalizedSessionId,
           previousAssistantResult
@@ -383,27 +363,29 @@ export function createCodexResultSettlement({ journal, output, createRuntime, pu
         turnId: normalizedTurnId
       });
     }
-    cleanupCodexAppServerUntrackedTurn(normalizedThreadId, previousTurnId);
+    output.cleanupUntrackedTurn(normalizedThreadId, previousTurnId);
     await publish(normalizedSessionId, {
-      payload: codexAppServerAgentRunRealtimePayload(runPatch),
+      payload: journal.agentRunRealtimePayload(runPatch),
       reason: "codex-app-server-turn-active",
       session: updatedSession
     });
     debugLog("appServerTurn.continued", {
       previousTurnId,
       sessionId: normalizedSessionId,
-      source: normalizeCodexRunText(input.source),
+      source: normalizeText(input.source),
       threadId: normalizedThreadId,
       turnId: normalizedTurnId
     });
-    clearCodexAppServerActiveTimer(normalizedSessionId);
+    journal.clearActiveTimer(normalizedSessionId);
     return outcome;
   }
 
-  return {
+  return Object.freeze({
     resultFinalizations: codexAppServerResultFinalizations,
     finalizeAssistantResult: finalizeCodexAppServerAssistantResult,
     recoverFinalResponseBeforeOutcome: recoverCodexAppServerFinalResponseBeforeOutcome,
     adoptSuccessorTurn: adoptCodexAppServerSuccessorTurn
-  };
+  });
 }
+
+/** @typedef {ReturnType<typeof createCodexResultSettlement>} CodexResultSettlement */