@jskit-ai/assistant-core 0.2.7 → 0.2.9

package/src/server/conversation/codexMessageCommands.js

@@ -1,28 +1,37 @@
+import { codexAppServerErrorMessage, codexAppServerMessageRequiresNewTurn, codexAppServerMessageText, codexAppServerMessageDisplayText, codexPromptInputFromRequest } from "./codexTurnState.js";
 import {
-  codexAppServerTurnStatusIsSuccessfulComplete,
-  codexAppServerTurnStatusIsProviderFailure,
-  normalizeCodexRunText,
-  codexAppServerErrorMessage,
-  codexAppServerSteerFailure,
-  codexAppServerMessageRequiresNewTurn,
-  codexAppServerMessageDeferred,
-  codexAppServerMessageText,
-  codexAppServerMessageDisplayText,
-  codexPromptInputFromRequest
-} from "./codexTurnState.js";
-import {
-  codexAppServerRequestIsInvalid,
   codexAppServerThreadIsMissing,
-  codexLocalImageInput,
-  ensureCodexAppServerThread,
-  codexAppServerDeliveredTurn,
-  sendCodexAppServerPrompt
-} from "./codexProvider.js";
+  ensureCodexAppServerThread
+} from "./codexProviderThreads.js";
 import crypto from "node:crypto";
-import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
+import { isRecord, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 
-// Original Main message admission, preparation, dispatch and steering.
-// Prompt delivery and receipt state remain the same run-owner references.
+/**
+ * Main message admission, preparation and dispatch. Prompt delivery and receipt state remain the same run-owner
+ * references.
+ * @param {object} dependencies
+ * @param {import("./codexOutput.js").CodexAppServerOutput} dependencies.output
+ * @param {import("./codexRunJournal.js").CodexRunJournal} dependencies.journal
+ * @param {import("./codexTurnRecovery.js").CodexTurnRecovery} dependencies.recovery
+ * @param {import("./codexThreadStatus.js").CodexThreadStatus} dependencies.threadStatus
+ * @param {import("./codexProviderSelection.js").CodexProviderSelection} dependencies.selection
+ * @param {import("./codexNotificationObserver.js").CodexNotificationObserver} dependencies.observer
+ * @param {import("./codexMessageDelivery.js").CodexAppServerMessageDelivery} dependencies.delivery
+ * @param {import("./codexPromptDispatch.js").CodexPromptDispatch} dependencies.promptDispatch
+ * @param {Set<string>} dependencies.promptDeliveries
+ * @param {import("./codexTurn.js").CodexCreateRuntime} dependencies.createRuntime
+ * @param {import("./codexTurn.js").CodexDebugError} dependencies.debugError
+ * @param {import("./codexTurn.js").CodexDebugLog} dependencies.debugLog
+ * @param {string} dependencies.errorPrefix
+ * @param {string} dependencies.messageIdPrefix
+ * @param {import("./codexTurn.js").CodexMessageMetadataHooks} dependencies.messageMetadata
+ * @param {import("./codexTurn.js").CodexSessionNamespace} dependencies.namespace
+ * @param {import("./codexTurn.js").CodexProviderSessions} [dependencies.providerSessions]
+ * @param {import("./codexTurn.js").CodexAdmissionRecovery} dependencies.recoverAdmission
+ * @param {string} dependencies.steerFailedCode
+ * @param {string} dependencies.turnAlreadyRunningError
+ * @param {import("./codexTurn.js").CodexTurnStateReader} dependencies.turnState
+ */
 export function createCodexMessageCommands({
   output,
   journal,
@@ -31,7 +40,8 @@ export function createCodexMessageCommands({
   selection,
   observer,
   delivery,
-  promptDeliveries: codexAppServerPromptDeliveries,
+  promptDispatch,
+  promptDeliveries,
   createRuntime,
   debugError,
   debugLog,
@@ -45,37 +55,12 @@ export function createCodexMessageCommands({
   turnAlreadyRunningError,
   turnState
 }) {
-  const {
-    submitAssistantResult: submitCodexAppServerAssistantResult,
-    splitReasoningTurn: splitCodexAppServerReasoningTurn
-  } = output;
-  const {
-    recoverAbandonedPromptClaim: recoverAbandonedCodexAppServerPromptClaim,
-    claimMessageStart: claimCodexAppServerMessageStart,
-    markTurnIdle: markCodexAppServerTurnIdle,
-    writeUserMessageOwnership: writeCodexAppServerUserMessageOwnership
-  } = journal;
-  const {
-    stopTurnWithProviderFailure: stopCodexAppServerTurnWithProviderFailure,
-    completeTurn: completeCodexAppServerTurn,
-    markTurnActive: markCodexAppServerTurnActive
-  } = recovery;
-  const {
-    reconcileThreadStatus: reconcileCodexAppServerThreadStatus
-  } = threadStatus;
   const {
     codexAppServerMessageContext,
     codexAppServerSessionObserverOptions,
     sessionConnection,
     rememberManagedSession
   } = selection;
-  const {
-    subscribeEvents: subscribeCodexAppServerEvents
-  } = observer;
-  const {
-    writeDeliveredUserMessage: writeCodexAppServerDeliveredUserMessage,
-    pendingUserMessage: pendingCodexAppServerUserMessage
-  } = delivery;
 
   async function selectCodexAppServerMessageTurn(sessionId, { messageId = "", startedAt = Date.now() } = {}, context = {}) {
     if (providerSessions) context = codexAppServerMessageContext(sessionId, context);
@@ -85,9 +70,9 @@ export function createCodexMessageCommands({
     if (
       turn.state === "starting" &&
       !turn.turnId &&
-      !codexAppServerPromptDeliveries.has(namespace(sessionId))
+      !promptDeliveries.has(namespace(sessionId))
     ) {
-      const abandonedClaim = await (recoverAdmission || recoverAbandonedCodexAppServerPromptClaim)(
+      const abandonedClaim = await recoverAdmission(
         runtime,
         currentSession,
         { promptDeliveryActive: false }
@@ -101,11 +86,11 @@ export function createCodexMessageCommands({
           code: `${errorPrefix}codex_observation_lost`
         });
       }
-      const recovered = await submitCodexAppServerAssistantResult(sessionId, turn.threadId, turn.turnId, { recoverFromProvider: true });
+      const recovered = await output.submitAssistantResult(sessionId, turn.threadId, turn.turnId, { recoverFromProvider: true });
       if (recovered.reason === "error") throw new Error(recovered.error);
       return { value: codexAppServerMessageRequiresNewTurn({ reason: "observation_lost", threadId: turn.threadId, turnId: turn.turnId }), session: currentSession };
     }
-    const threadId = normalizeCodexRunText(turn.threadId) || context.threadId(currentSession);
+    const threadId = normalizeText(turn.threadId) || context.threadId(currentSession);
     if (!threadId) {
       debugLog("appServerMessage.newTurn", {
         messageId,
@@ -125,7 +110,7 @@ export function createCodexMessageCommands({
         messageId,
         sessionId,
         threadId,
-        turnId: normalizeCodexRunText(turn.turnId)
+        turnId: normalizeText(turn.turnId)
       });
     }
     const providerReadyAt = Date.now();
@@ -135,7 +120,7 @@ export function createCodexMessageCommands({
       sessionId
     });
     try {
-      await reconcileCodexAppServerThreadStatus(sessionId, provider, threadId, {
+      await threadStatus.reconcileThreadStatus(sessionId, provider, threadId, {
         source: "message_delivery"
       });
     } catch (error) {
@@ -148,12 +133,12 @@ export function createCodexMessageCommands({
         reason: "provider_thread_missing",
         sessionId,
         threadId,
-        turnId: normalizeCodexRunText(turn.turnId)
+        turnId: normalizeText(turn.turnId)
       });
       return { value: codexAppServerMessageRequiresNewTurn({
         reason: "provider_thread_missing",
         threadId,
-        turnId: normalizeCodexRunText(turn.turnId)
+        turnId: normalizeText(turn.turnId)
       }), session: currentSession };
     }
     debugLog("appServerMessage.reconciled", {
@@ -163,7 +148,7 @@ export function createCodexMessageCommands({
     });
     currentSession = await runtime.getSession(sessionId);
     turn = turnState(currentSession);
-    const turnId = normalizeCodexRunText(turn.turnId);
+    const turnId = normalizeText(turn.turnId);
     const goalAwaitingTurn = !turn.active && turn.goalStatus === "active" && turn.goalThreadId === threadId;
     if (!turn.active && !goalAwaitingTurn) {
       debugLog("appServerMessage.newTurn", {
@@ -205,7 +190,7 @@ export function createCodexMessageCommands({
       const connection = source.provider ? null : sessionConnection(sessionId, source.providerOptions);
       const providerAlreadyAvailable = source.provider
         ? source.providerAlreadyAvailable
-        : providerSessions.owner.providers.get(connection.providerKey)?.isAvailable?.() === true;
+        : providerSessions.owner.providers.get(connection.providerKey)?.isAvailable() === true;
       if (!providerAlreadyAvailable && facility.running) await facility.running();
       let stageStartedAt = Date.now();
       const provider = source.provider || await providerSessions.owner.ensureSession(connection, source.mainThreadId);
@@ -217,7 +202,7 @@ export function createCodexMessageCommands({
       const thread = await ensureCodexAppServerThread({
         ...(source.preparation || facility.preparation(currentSession)),
         ...(preparation.applicationTools ? { applicationTools: preparation.applicationTools, providerReady: preparation.providerReady } : {}),
-        observeThread: threadId => subscribeCodexAppServerEvents(sessionId, provider, threadId, observerOptions),
+        observeThread: threadId => observer.subscribeEvents(sessionId, provider, threadId, observerOptions),
         provider,
         workdir: source.workdir ?? workdir
       });
@@ -241,7 +226,7 @@ export function createCodexMessageCommands({
         durationMs: Date.now() - startedAt, messageId, sessionId, stage: "startup-ready"
       });
       if (!Object.hasOwn(facility, "failureThreadId")) prepared.activeThreadId = thread.threadId;
-      subscribeCodexAppServerEvents(sessionId, provider, thread.threadId, observerOptions);
+      observer.subscribeEvents(sessionId, provider, thread.threadId, observerOptions);
       if (connection) {
         rememberManagedSession(sessionId, providerOptions, {
           executionRoot: prepared.executionRoot, workdir: prepared.workdir, threadId: thread.threadId
@@ -250,8 +235,8 @@ export function createCodexMessageCommands({
       if (facility.ready) await facility.ready();
       return { preparedSession, provider, providerAlreadyAvailable, providerOptions, thread, ...settings };
     } finally {
-      // Standalone preparation historically retained the exact binding on
-      // failure as well as success; Main records it after the startup gate.
+      // Standalone preparation keeps the exact binding on failure as well as
+      // success; Main records it after the startup gate.
       if (Object.hasOwn(facility, "failureThreadId")) prepared.activeThreadId = facility.failureThreadId;
     }
   }
@@ -262,7 +247,7 @@ export function createCodexMessageCommands({
       ? options.agentSettings
       : isRecord(input.agentSettings) ? input.agentSettings : {};
     const actorContext = options.actorContext || null;
-    const messageId = normalizeCodexRunText(input.messageId) ||
+    const messageId = normalizeText(input.messageId) ||
       `${messageIdPrefix}${crypto.randomUUID()}`;
     const userRequest = codexPromptInputFromRequest(input);
     if (!userRequest && options.preparedInput === undefined) {
@@ -279,14 +264,14 @@ export function createCodexMessageCommands({
       return { value: context };
     }
     const { runtime } = context;
-    const turnMetadata = { ...input.turnMetadata, ...await messageMetadata.actor?.(actorContext) };
+    const turnMetadata = { ...input.turnMetadata, ...await messageMetadata.actor(actorContext) };
     debugLog("appServerPrompt.start", {
       durationMs: Date.now() - startedAt,
       messageId,
       sessionId
     });
 
-    const claim = await claimCodexAppServerMessageStart(runtime, sessionId, messageId);
+    const claim = await journal.claimCodexAppServerMessageStart(runtime, sessionId, messageId);
     if (!claim?.claimed) {
       debugLog("appServerPrompt.claimObserved", {
         code: String(claim?.response?.value?.code || ""),
@@ -300,9 +285,9 @@ export function createCodexMessageCommands({
       } };
     }
 
-    const normalizedSessionId = normalizeCodexRunText(sessionId);
+    const normalizedSessionId = normalizeText(sessionId);
     const promptDeliveryKey = namespace(normalizedSessionId);
-    codexAppServerPromptDeliveries.add(promptDeliveryKey);
+    promptDeliveries.add(promptDeliveryKey);
     const prepared = {
       ...context, agentSettings, actorContext, messageId, userRequest, startedAt,
       activeThreadId: ""
@@ -312,12 +297,12 @@ export function createCodexMessageCommands({
     try {
       Object.assign(prepared, await prepareCodexAppServerMessageThread(sessionId, input, prepared, prepare));
       const { provider, providerAlreadyAvailable, thread } = prepared;
-      await markCodexAppServerTurnActive(sessionId, {
+      await recovery.markTurnActive(sessionId, {
         status: "starting",
         threadId: thread.threadId
       });
       const prompt = await prepare.prepareMessage(input, prepared, { starting: true });
-      const started = await startCodexAppServerTurn(sessionId, input, {
+      const started = await promptDispatch.startTurn(sessionId, input, {
         runtime, provider, threadId: thread.threadId, messageId, renderedPrompt: prompt.renderedPrompt, turnMetadata,
         preparedInput: options.preparedInput,
         get turnSettings() { return prompt.turnSettings; }
@@ -345,7 +330,7 @@ export function createCodexMessageCommands({
       }, session: currentSession, nativeIdentity: { threadId: thread.threadId, turnId: deliveredTurnId } };
     } catch (error) {
       if (!turnFailureHandled) {
-        await markCodexAppServerTurnIdle(sessionId, {
+        await journal.markTurnIdle(sessionId, {
           error: codexAppServerErrorMessage(error, "Codex app-server prompt delivery failed."),
           status: "failed",
           threadId: prepared.activeThreadId
@@ -353,16 +338,16 @@ export function createCodexMessageCommands({
       }
       return await prepare.finishMessage(input, prepared, { error });
     } finally {
-      codexAppServerPromptDeliveries.delete(promptDeliveryKey);
+      promptDeliveries.delete(promptDeliveryKey);
     }
   }
 
-  async function sendCodexAppServerMessage(sessionId, input = {}, options = {}, prepare) {
+  async function sendCodexAppServerMessage(sessionId, input, options = {}, prepare) {
     const startedAt = Date.now();
     const turnOwnership = options.turnOwnership || null;
     const message = codexAppServerMessageText(input);
     const displayMessage = codexAppServerMessageDisplayText(input, message);
-    const messageId = normalizeCodexRunText(input?.messageId);
+    const messageId = normalizeText(input?.messageId);
     if (!message && options.preparedInput === undefined) {
       return { value: {
         code: steerFailedCode,
@@ -381,7 +366,6 @@ export function createCodexMessageCommands({
     const { runtime, session } = context;
     if (
       messageId &&
-      typeof runtime.store.conversationMessageIdExists === "function" &&
       await runtime.store.conversationMessageIdExists(sessionId, messageId)
     ) {
       return { value: {
@@ -392,7 +376,7 @@ export function createCodexMessageCommands({
       }, session };
     }
     const actorContext = options.actorContext || null;
-    const turnMetadata = { ...input.turnMetadata, ...await messageMetadata.actor?.(actorContext) };
+    const turnMetadata = { ...input.turnMetadata, ...await messageMetadata.actor(actorContext) };
     debugLog("appServerMessage.contextReady", {
       durationMs: Date.now() - startedAt,
       messageId,
@@ -406,7 +390,7 @@ export function createCodexMessageCommands({
     const policy = await prepare.prepareMessage(input, prepared, { starting: false, selected });
     if (policy) return policy;
     const clientUserMessageId = messageId || `${messageIdPrefix}${crypto.randomUUID()}`;
-    return steerCodexAppServerTurn(sessionId, input, {
+    return promptDispatch.steerTurn(sessionId, input, {
       runtime, provider, threadId, turnId, message, displayMessage, messageId, clientUserMessageId, turnMetadata,
       preparedInput: options.preparedInput
     });
@@ -418,7 +402,7 @@ export function createCodexMessageCommands({
       return result;
     }
     const message = codexAppServerMessageText(input);
-    const messageId = normalizeCodexRunText(input?.messageId) ||
+    const messageId = normalizeText(input.messageId) ||
       `${messageIdPrefix}${crypto.randomUUID()}`;
     const started = await startCodexAppServerMessage(sessionId, isRecord(input) ? {
       ...input,
@@ -428,27 +412,27 @@ export function createCodexMessageCommands({
       message,
       messageId
     }, {
-      agentSettings: input?.agentSettings || {},
+      agentSettings: input.agentSettings || {},
       runtime: options.runtime || null,
       session: options.session || null,
       actorContext: options.actorContext || null,
       preparedInput: options.preparedInput
     }, prepare);
-    // The original unavailable-worktree return starts its policy operation,
-    // releases the prompt marker in finally, then awaits the returned value.
+    // An unavailable-worktree result starts its policy operation, releases
+    // the prompt marker in finally, and then this awaits the returned value.
     started.value = await started.value;
     if (started.value?.ok === false || started.value?.delivered === false) {
       return started;
     }
     const runtime = await createRuntime(sessionId);
     const displayMessage = codexAppServerMessageDisplayText(input, message);
-    const conversationTurn = await writeCodexAppServerDeliveredUserMessage(
+    const conversationTurn = await delivery.writeDeliveredUserMessage(
       runtime,
       sessionId,
       displayMessage || message,
       messageId,
       started.value.turnMetadata || null,
-      input?.displayAttachments,
+      input.displayAttachments,
       started.nativeIdentity
     );
     return {
@@ -464,210 +448,8 @@ export function createCodexMessageCommands({
     };
   }
 
-  async function startCodexAppServerTurn(sessionId, input = {}, context = {}) {
-    const { runtime, provider, threadId, messageId, renderedPrompt, turnMetadata } = context;
-    let providerFailure = "";
-    let delivery = null;
-    const promptSessionId = normalizeCodexRunText(sessionId);
-    const clientUserMessageId = messageId;
-    await writeCodexAppServerUserMessageOwnership(runtime.store, sessionId, clientUserMessageId, {
-      eventKind: "codex-app-server-user-message-owned",
-      owned: true
-    });
-    try {
-      await input.onPromptSending?.({ threadId: threadId, displayAttachments: input.displayAttachments, turnMetadata });
-      const response = sendCodexAppServerPrompt({
-        clientUserMessageId,
-        prompt: renderedPrompt,
-        attachments: input.attachments,
-        provider,
-        threadId
-      }, context);
-      const receipt = pendingCodexAppServerUserMessage(promptSessionId, clientUserMessageId)?.receipt;
-      // An exact, persisted user-message receipt confirms delivery too.
-      // Finish bookkeeping once; a late RPC reply must not hold admission
-      // or change a turn that has already continued or completed.
-      delivery = receipt
-        ? await Promise.race([response, receipt.promise.then((turn) => ({ turn }))])
-        : await response;
-    } catch (error) {
-      if (Number.isInteger(error?.code) && error.code < 0) await input.onPromptRejected?.();
-      await writeCodexAppServerUserMessageOwnership(runtime.store, sessionId, clientUserMessageId, {
-        eventKind: "codex-app-server-user-message-released",
-        owned: false
-      });
-      await markCodexAppServerTurnIdle(sessionId, {
-        error: codexAppServerErrorMessage(error, "Codex app-server prompt delivery failed."),
-        status: "failed",
-        threadId: threadId
-      });
-      return { error, turnFailureHandled: true };
-    }
-    const { turnId: deliveredTurnId, status: deliveredTurnStatus } = codexAppServerDeliveredTurn(delivery);
-    if (!deliveredTurnId) {
-      throw new Error("Codex app-server accepted the prompt without returning a turn id.");
-    }
-    pendingCodexAppServerUserMessage(promptSessionId, clientUserMessageId)?.onNativeReceipt?.();
-    await markCodexAppServerTurnActive(sessionId, {
-      requireTrackedTurn: true,
-      status: "inProgress",
-      threadId: threadId,
-      turnId: deliveredTurnId
-    });
-    if (codexAppServerTurnStatusIsProviderFailure(deliveredTurnStatus)) {
-      providerFailure = `Codex turn ${deliveredTurnStatus}.`;
-      await stopCodexAppServerTurnWithProviderFailure(sessionId, threadId, deliveredTurnId, {
-        provider,
-        status: deliveredTurnStatus
-      });
-    } else if (codexAppServerTurnStatusIsSuccessfulComplete(deliveredTurnStatus)) {
-      const completion = await completeCodexAppServerTurn(sessionId, threadId, deliveredTurnId, {
-        provider,
-        status: deliveredTurnStatus
-      });
-      if (completion?.ok === false) {
-        providerFailure = normalizeCodexRunText(completion.error) || "Codex completed, but its response could not be processed.";
-      }
-    }
-    return { delivery, deliveredTurnId, providerFailure };
-  }
-
-  async function steerCodexAppServerTurn(sessionId, input = {}, context = {}) {
-    const { runtime, provider, threadId, turnId, message, displayMessage, messageId, clientUserMessageId, turnMetadata } = context;
-    let currentSession;
-    await writeCodexAppServerUserMessageOwnership(runtime.store, sessionId, clientUserMessageId, {
-      eventKind: "codex-app-server-user-message-owned",
-      owned: true
-    });
-    debugLog("appServerMessage.activeTurn.start", {
-      messageId,
-      sessionId,
-      threadId,
-      turnId
-    });
-    async function recoverAfterSteerFailure(error = null) {
-      await writeCodexAppServerUserMessageOwnership(runtime.store, sessionId, clientUserMessageId, {
-        eventKind: "codex-app-server-user-message-released",
-        owned: false
-      });
-      await reconcileCodexAppServerThreadStatus(sessionId, provider, threadId, {
-        source: "message_delivery_steer_race"
-      }).catch(() => null);
-      currentSession = await runtime.getSession(sessionId);
-      const currentTurn = turnState(currentSession);
-      const sameTurnIsActive = currentTurn.active === true &&
-        normalizeCodexRunText(currentTurn.threadId) === threadId &&
-        normalizeCodexRunText(currentTurn.turnId) === turnId &&
-        currentTurn.state !== "finalizing";
-      if (sameTurnIsActive) {
-        return codexAppServerRequestIsInvalid(error, "turn/steer")
-          ? { value: codexAppServerMessageDeferred({ threadId, turnId }, steerFailedCode), session: currentSession }
-          : null;
-      }
-      debugLog("appServerMessage.newTurn", {
-        error: debugError(error),
-        messageId,
-        reason: "active_turn_completed_before_delivery",
-        sessionId,
-        threadId,
-        turnId
-      });
-      return { value: codexAppServerMessageRequiresNewTurn({
-        reason: "active_turn_completed_before_delivery",
-        threadId,
-        turnId
-      }), session: currentSession };
-    }
-    let result;
-    try {
-      await input.onPromptSending?.({ threadId, displayAttachments: input.displayAttachments, turnMetadata });
-      const response = provider.steerTurn(
-        threadId,
-        turnId,
-        context.preparedInput === undefined
-          ? input.attachments?.some((attachment) => attachment.contentType?.startsWith("image/"))
-            ? [message, ...codexLocalImageInput(input.attachments)]
-            : message
-          : context.preparedInput,
-        {
-          clientUserMessageId
-        }
-      );
-      const receipt = pendingCodexAppServerUserMessage(sessionId, clientUserMessageId)?.receipt;
-      result = receipt ? await Promise.race([response, receipt.promise]) : await response;
-    } catch (error) {
-      if (Number.isInteger(error?.code) && error.code < 0) await input.onPromptRejected?.();
-      const recovered = await recoverAfterSteerFailure(error);
-      if (recovered) {
-        return recovered;
-      }
-      debugLog("appServerMessage.activeTurn.error", {
-        error: debugError(error),
-        messageId,
-        sessionId,
-        threadId,
-        turnId
-      });
-      throw error;
-    }
-    const steerFailure = codexAppServerSteerFailure(result, steerFailedCode);
-    if (steerFailure) {
-      const recovered = await recoverAfterSteerFailure(result);
-      if (recovered) {
-        return recovered;
-      }
-      debugLog("appServerMessage.activeTurn.failed", {
-        error: steerFailure.error,
-        messageId,
-        operationOutcome: steerFailure.operationOutcome,
-        sessionId,
-        threadId,
-        turnId
-      });
-      return { value: {
-        ...steerFailure,
-        result,
-        threadId,
-        turnId
-      } };
-    }
-    pendingCodexAppServerUserMessage(sessionId, clientUserMessageId)?.onNativeReceipt?.();
-    const conversationTurn = await writeCodexAppServerDeliveredUserMessage(
-      runtime,
-      sessionId,
-      displayMessage || message,
-      messageId,
-      turnMetadata,
-      input?.displayAttachments,
-      { threadId, turnId }
-    );
-    splitCodexAppServerReasoningTurn(threadId, turnId);
-    currentSession = await runtime.getSession(sessionId);
-    debugLog("appServerMessage.activeTurn.done", {
-      conversationTurnId: normalizeCodexRunText(conversationTurn?.turnId || conversationTurn?.id),
-      messageId,
-      sessionId,
-      threadId,
-      turnId
-    });
-    return { value: {
-      conversationTurn,
-      conversationTurns: [conversationTurn],
-      delivered: true,
-      deliveryMode: "active_turn",
-      newTurnRequired: false,
-      ok: true,
-      operationOutcome: "delivered_to_active_turn",
-      result,
-      threadId,
-      turnId
-    }, session: currentSession };
-  }
-
-  return {
+  return Object.freeze({
     selectMessageTurn: selectCodexAppServerMessageTurn,
-    dispatchMessage: dispatchCodexAppServerMessage,
-    startTurn: startCodexAppServerTurn,
-    steerTurn: steerCodexAppServerTurn
-  };
+    dispatchMessage: dispatchCodexAppServerMessage
+  });
 }