@jskit-ai/assistant-core 0.2.7 → 0.2.9

package/src/server/conversation/codexProcessLeader.js

@@ -7,6 +7,7 @@ await runCodexAppServerProcess({
   runtimeDir,
   command,
   args,
+  env: process.env,
   runtimeToken: process.env[CODEX_APP_SERVER_DEFAULT_ENVIRONMENT.runtimeToken],
   bundled: process.env[CODEX_APP_SERVER_DEFAULT_ENVIRONMENT.modelCatalogSource] === "bundled",
   additionalModels: codexProviderModelCatalog({ models: NATIVE_AI_PROVIDERS.flatMap(provider =>

package/src/server/conversation/codexPromptDispatch.js

@@ -0,0 +1,241 @@
+import { codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerErrorMessage, codexAppServerSteerFailure, codexAppServerMessageRequiresNewTurn, codexAppServerMessageDeferred } from "./codexTurnState.js";
+import { codexAppServerRequestIsInvalid } from "./codexProviderThreads.js";
+import { codexLocalImageInput, codexAppServerDeliveredTurn, sendCodexAppServerPrompt } from "./codexProviderTurns.js";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { ignorePromptRejection, ignorePromptSending } from "./nativeCommandCallbacks.js";
+
+/**
+ * Delivers one prompt to the native thread: it starts a new turn, or steers the active one. Each delivery owns its
+ * user message until the native receipt arrives, and releases it when the provider refuses.
+ * @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("./codexMessageDelivery.js").CodexAppServerMessageDelivery} dependencies.delivery
+ * @param {import("./codexTurn.js").CodexDebugError} dependencies.debugError
+ * @param {import("./codexTurn.js").CodexDebugLog} dependencies.debugLog
+ * @param {string} dependencies.steerFailedCode
+ * @param {import("./codexTurn.js").CodexTurnStateReader} dependencies.turnState
+ */
+export function createCodexPromptDispatch({
+  output,
+  journal,
+  recovery,
+  threadStatus,
+  delivery,
+  debugError,
+  debugLog,
+  steerFailedCode,
+  turnState
+}) {
+
+  async function startCodexAppServerTurn(sessionId, input = {}, context = {}) {
+    const { runtime, provider, threadId, messageId, renderedPrompt, turnMetadata } = context;
+    const { onPromptSending = ignorePromptSending, onPromptRejected = ignorePromptRejection } = input;
+    let providerFailure = "";
+    let nativeDelivery = null;
+    const promptSessionId = normalizeText(sessionId);
+    const clientUserMessageId = messageId;
+    await journal.writeUserMessageOwnership(runtime.store, sessionId, clientUserMessageId, {
+      eventKind: "codex-app-server-user-message-owned",
+      owned: true
+    });
+    try {
+      await onPromptSending({ threadId: threadId, displayAttachments: input.displayAttachments, turnMetadata });
+      const response = sendCodexAppServerPrompt({
+        clientUserMessageId,
+        prompt: renderedPrompt,
+        attachments: input.attachments,
+        provider,
+        threadId
+      }, context);
+      const receipt = delivery.pendingUserMessage(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.
+      nativeDelivery = receipt
+        ? await Promise.race([response, receipt.promise.then((turn) => ({ turn }))])
+        : await response;
+    } catch (error) {
+      if (Number.isInteger(error?.code) && error.code < 0) await onPromptRejected();
+      await journal.writeUserMessageOwnership(runtime.store, sessionId, clientUserMessageId, {
+        eventKind: "codex-app-server-user-message-released",
+        owned: false
+      });
+      await journal.markTurnIdle(sessionId, {
+        error: codexAppServerErrorMessage(error, "Codex app-server prompt delivery failed."),
+        status: "failed",
+        threadId: threadId
+      });
+      return { error, turnFailureHandled: true };
+    }
+    const { turnId: deliveredTurnId, status: deliveredTurnStatus } = codexAppServerDeliveredTurn(nativeDelivery);
+    if (!deliveredTurnId) {
+      throw new Error("Codex app-server accepted the prompt without returning a turn id.");
+    }
+    delivery.pendingUserMessage(promptSessionId, clientUserMessageId)?.onNativeReceipt();
+    await recovery.markTurnActive(sessionId, {
+      requireTrackedTurn: true,
+      status: "inProgress",
+      threadId: threadId,
+      turnId: deliveredTurnId
+    });
+    if (codexAppServerTurnStatusIsProviderFailure(deliveredTurnStatus)) {
+      providerFailure = `Codex turn ${deliveredTurnStatus}.`;
+      await recovery.stopTurnWithProviderFailure(sessionId, threadId, deliveredTurnId, {
+        provider,
+        status: deliveredTurnStatus
+      });
+    } else if (codexAppServerTurnStatusIsSuccessfulComplete(deliveredTurnStatus)) {
+      const completion = await recovery.completeTurn(sessionId, threadId, deliveredTurnId, {
+        provider,
+        status: deliveredTurnStatus
+      });
+      if (completion?.ok === false) {
+        providerFailure = normalizeText(completion.error) || "Codex completed, but its response could not be processed.";
+      }
+    }
+    return { delivery: nativeDelivery, deliveredTurnId, providerFailure };
+  }
+
+  async function steerCodexAppServerTurn(sessionId, input = {}, context = {}) {
+    const { runtime, provider, threadId, turnId, message, displayMessage, messageId, clientUserMessageId, turnMetadata } = context;
+    const { onPromptSending = ignorePromptSending, onPromptRejected = ignorePromptRejection } = input;
+    let currentSession;
+    await journal.writeUserMessageOwnership(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 journal.writeUserMessageOwnership(runtime.store, sessionId, clientUserMessageId, {
+        eventKind: "codex-app-server-user-message-released",
+        owned: false
+      });
+      await threadStatus.reconcileThreadStatus(sessionId, provider, threadId, {
+        source: "message_delivery_steer_race"
+      }).catch(() => null);
+      currentSession = await runtime.getSession(sessionId);
+      const currentTurn = turnState(currentSession);
+      const sameTurnIsActive = currentTurn.active === true &&
+        normalizeText(currentTurn.threadId) === threadId &&
+        normalizeText(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 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 = delivery.pendingUserMessage(sessionId, clientUserMessageId)?.receipt;
+      result = receipt ? await Promise.race([response, receipt.promise]) : await response;
+    } catch (error) {
+      if (Number.isInteger(error?.code) && error.code < 0) await 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
+      } };
+    }
+    delivery.pendingUserMessage(sessionId, clientUserMessageId)?.onNativeReceipt();
+    const conversationTurn = await delivery.writeDeliveredUserMessage(
+      runtime,
+      sessionId,
+      displayMessage || message,
+      messageId,
+      turnMetadata,
+      input.displayAttachments,
+      { threadId, turnId }
+    );
+    output.splitReasoningTurn(threadId, turnId);
+    currentSession = await runtime.getSession(sessionId);
+    debugLog("appServerMessage.activeTurn.done", {
+      conversationTurnId: normalizeText(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 Object.freeze({
+    startTurn: startCodexAppServerTurn,
+    steerTurn: steerCodexAppServerTurn
+  });
+}
+
+/** @typedef {ReturnType<typeof createCodexPromptDispatch>} CodexPromptDispatch */