@jskit-ai/assistant-core 0.1.199 → 0.1.201

package/src/server/conversation/codexProviderSelection.js

@@ -0,0 +1,218 @@
+import { normalizeCodexRunText } from "./codexTurnState.js";
+import { codexAppServerProjectHookTrustConfig } from "./codexConfiguration.js";
+import { createCodexAppServerModelCatalogCache } from "./codexProvider.js";
+import { readCodexAppServerAccountIdentity } from "./codexHelperExecution.js";
+
+// Private composition of unchanged operations from the original run owner.
+export function createCodexProviderSelection({
+  providerSessions,
+  turnState,
+  helperLifecycle,
+  helperOwnershipError,
+  modelCatalogCacheMs,
+  errorPrefix
+}) {
+  const readCodexAppServerModelCatalog = createCodexAppServerModelCatalogCache({
+    cacheMs: modelCatalogCacheMs,
+    errorPrefix
+  });
+  function managedProviderKeyForThread(sessionId, workdir, threadId) {
+    for (const [providerKey, managed] of providerSessions.managed) {
+      const provider = providerSessions.owner.providers.get(providerKey);
+      if (
+        managed.sessionId !== sessionId ||
+        managed.workdir !== workdir ||
+        managed.threadId !== threadId ||
+        provider?.isAvailable?.() !== true
+      ) {
+        continue;
+      }
+      return providerKey;
+    }
+    return null;
+  }
+
+  async function ensureCodexAppServerProviderForManagedThread(session = {}, options = {}) {
+    const normalizedSessionId = normalizeCodexRunText(session.sessionId || session.id);
+    const turn = turnState(session);
+    if (!normalizedSessionId || !turn.threadId) {
+      return null;
+    }
+    const normalizedExecutionRoot = normalizeCodexRunText(options.executionRoot);
+    const normalizedWorkdir = normalizeCodexRunText(options.workdir);
+    for (const [providerKey, managed] of providerSessions.managed.entries()) {
+      const fields = providerSessions.keyFields(providerKey);
+      if (
+        fields.sessionId !== normalizedSessionId ||
+        (normalizedExecutionRoot && fields.executionRoot !== normalizedExecutionRoot) ||
+        (normalizedWorkdir && fields.workdir !== normalizedWorkdir) ||
+        normalizeCodexRunText(managed?.sessionId) !== normalizedSessionId ||
+        normalizeCodexRunText(managed?.threadId) !== turn.threadId
+      ) {
+        continue;
+      }
+      const provider = providerSessions.owner.providers.get(providerKey);
+      if (provider) {
+        return {
+          provider: await providerSessions.owner.ensureSession(
+            providerSessions.context(normalizedSessionId, managed.providerOptions)
+          ),
+          providerKey,
+          providerOptions: managed.providerOptions
+        };
+      }
+    }
+    return null;
+  }
+
+  async function ensureCodexAppServerProviderForActiveTurn(session = {}, options = {}) {
+    if (!turnState(session).active) {
+      return null;
+    }
+    return ensureCodexAppServerProviderForManagedThread(session, options);
+  }
+
+  async function acquireCodexAppServerOutputProvider(sessionId, session, managedIdentity, prepareProviderOptions) {
+    const activeProvider = await ensureCodexAppServerProviderForActiveTurn(session, managedIdentity);
+    const provider = activeProvider?.provider;
+    if (provider) return provider;
+    const providerOptions = await prepareProviderOptions();
+    return await providerSessions.owner.ensureSession(
+      providerSessions.context(normalizeCodexRunText(sessionId), providerOptions)
+    );
+  }
+
+  async function codexAppServerRuntimeForVisibleTerminal(sessionId, session, options, managedIdentity, prepareProviderOptions) {
+    const activeProvider = await ensureCodexAppServerProviderForActiveTurn(session, managedIdentity);
+    const providerOptions = activeProvider?.providerOptions || await prepareProviderOptions();
+    const provider = activeProvider?.provider || await providerSessions.owner.ensureSession(
+      providerSessions.context(normalizeCodexRunText(sessionId), providerOptions)
+    );
+    await codexAppServerProjectHookTrustConfig(provider, options.workdir, {
+      persist: true
+    });
+    const providerKey = activeProvider?.providerKey || providerSessions.context(sessionId, providerOptions).providerKey;
+    return providerSessions.owner.acquireRuntime({
+      operation: () => provider.ensureRuntime(),
+      provider,
+      providerKey,
+      providerOptions
+    });
+  }
+
+  function codexAppServerMessageContext(sessionId, context) {
+    const { runtime, session } = context;
+    return {
+      runtime,
+      session,
+      threadId: context.threadId,
+      async acquireProvider(currentSession) {
+        const activeProvider = await ensureCodexAppServerProviderForManagedThread(
+          currentSession, context.managedIdentity(currentSession)
+        );
+        if (activeProvider) return { provider: activeProvider.provider || null, reused: true };
+        return {
+          provider: await providerSessions.owner.ensureSession(providerSessions.context(
+            normalizeCodexRunText(sessionId), await context.providerOptions(currentSession)
+          )),
+          reused: false
+        };
+      }
+    };
+  }
+
+  function codexAppServerControlContext(sessionId, context) {
+    return {
+      runtime: context.runtime,
+      admissionError: context.admissionError,
+      threadId: context.threadId,
+      async acquireProvider(currentSession) {
+        const activeProvider = await ensureCodexAppServerProviderForActiveTurn(
+          currentSession, context.managedIdentity(currentSession)
+        );
+        return activeProvider?.provider || await providerSessions.owner.ensureSession(
+          providerSessions.context(normalizeCodexRunText(sessionId), await context.providerOptions(currentSession))
+        );
+      },
+      observationOwner(threadId) {
+        for (const [key, managed] of providerSessions.managed) {
+          const owner = providerSessions.owner.providers.get(key);
+          if (managed.sessionId === sessionId && managed.threadId === threadId && owner?.observationFailure) {
+            return owner;
+          }
+        }
+        return null;
+      }
+    };
+  }
+
+  function codexAppServerObservationRecoveryContext(sessionId, context) {
+    return {
+      threadId: context.threadId,
+      async acquireProvider(current) {
+        return providerSessions.owner.ensureSession(providerSessions.context(
+          normalizeCodexRunText(sessionId), await context.providerOptions(current)
+        ));
+      }
+    };
+  }
+
+  function codexAppServerSessionObserverOptions(sessionId, providerOptions) {
+    return {
+      get providerKey() {
+        return providerSessions.context(normalizeCodexRunText(sessionId), providerOptions).providerKey;
+      }
+    };
+  }
+
+  function rememberCodexAppServerPreparedThread(sessionId, providerOptions, context, thread) {
+    const connection = providerSessions.context(sessionId, providerOptions);
+    connection.runOwner.runtimeLifecycle.rememberManagedSession(connection.providerKey, {
+      providerOptions,
+      sessionId,
+      executionRoot: context.executionRoot,
+      threadId: thread.threadId,
+      workdir: context.workdir
+    });
+  }
+
+
+  async function readExecutionProfileModelCatalog(sessionId, preparation) {
+    if (!preparation.assistantScope) {
+      const restoration = await preparation.helperRestoration;
+      helperLifecycle.assertRestored(await helperLifecycle.restoreThreads(
+        restoration.projectRuntimeRoot, restoration.context
+      ));
+    }
+    const provider = preparation.provider || await providerSessions.owner.ensureSession(
+      providerSessions.context(normalizeCodexRunText(sessionId), await preparation.providerOptions)
+    );
+    return readCodexAppServerModelCatalog(provider, { signal: preparation.signal });
+  }
+
+  async function readProviderAccountIdentity(sessionId, preparation) {
+    const restoration = await preparation.helperRestoration;
+    helperLifecycle.assertRestored(await helperLifecycle.restoreThreads(
+      restoration.projectRuntimeRoot, restoration.context
+    ));
+    const providerOptions = await preparation.providerOptions;
+    const provider = await providerSessions.owner.withLifecycle(() =>
+      providerSessions.owner.providerForSession(providerSessions.context(sessionId, providerOptions))
+    );
+    return readCodexAppServerAccountIdentity(provider, helperOwnershipError);
+  }
+
+  return {
+    readExecutionProfileModelCatalog,
+    readProviderAccountIdentity,
+    managedProviderKeyForThread,
+    ensureCodexAppServerProviderForActiveTurn,
+    acquireCodexAppServerOutputProvider,
+    codexAppServerRuntimeForVisibleTerminal,
+    codexAppServerMessageContext,
+    codexAppServerControlContext,
+    codexAppServerObservationRecoveryContext,
+    codexAppServerSessionObserverOptions,
+    rememberCodexAppServerPreparedThread
+  };
+}

package/src/server/conversation/codexReasoning.js

@@ -0,0 +1,314 @@
+import { normalizeCodexRunText, codexAppServerTurnCanReceiveProviderActivity, codexAppServerTurnKey } from "./codexTurnState.js";
+import { codexAppServerContentText, codexAppServerNotificationItem, codexAppServerOutputOwnerTurnId, codexAppServerNotificationParams, codexAppServerNotificationTurnId } from "./codexEvents.js";
+
+// Original per-turn reasoning channels, persistence queue and cleanup.
+// The containing output instance shares these exact Maps with its run owner.
+export function createCodexAppServerReasoning({
+  createStore,
+  publish,
+  turnStateFromAgentRun,
+  debugLog,
+  readCodexAppServerAgentRunForSession
+}) {
+  const codexAppServerReasoningTurns = new Map();
+  const codexAppServerReasoningPersistQueues = new Map();
+
+  function codexAppServerReasoningTurnKey(threadId = "", turnId = "") {
+    return codexAppServerTurnKey(threadId, turnId || "*");
+  }
+
+  function codexAppServerReasoningTurnState(threadId = "", turnId = "") {
+    const key = codexAppServerReasoningTurnKey(threadId, turnId);
+    const existing = codexAppServerReasoningTurns.get(key);
+    if (existing) {
+      return existing;
+    }
+    const created = {
+      createdAt: new Date().toISOString(),
+      segments: [],
+      channels: new Map(),
+      summaries: new Map()
+    };
+    codexAppServerReasoningTurns.set(key, created);
+    return created;
+  }
+
+  function codexAppServerReasoningExistingTurnState(threadId = "", turnId = "") {
+    return codexAppServerReasoningTurns.get(codexAppServerReasoningTurnKey(threadId, turnId)) ||
+      codexAppServerReasoningTurns.get(codexAppServerReasoningTurnKey(threadId, "*"));
+  }
+
+  function codexAppServerReasoningSummaryKey(notification = {}) {
+    const params = codexAppServerNotificationParams(notification);
+    const item = codexAppServerNotificationItem(notification);
+    const itemId = normalizeCodexRunText(params.itemId || item?.id || "summary");
+    const summaryIndex = String(params.summaryIndex ?? params.contentIndex ?? params.index ?? 0).trim() || "0";
+    return `${itemId}:${summaryIndex}`;
+  }
+
+  function createCodexAppServerReasoningSegment(state = {}, summary = null, summaryKey = "") {
+    const segment = {
+      chunks: [],
+      persistedAt: "",
+      persistedText: "",
+      summaryKey
+    };
+    if (Array.isArray(state.segments)) {
+      state.segments.push(segment);
+    }
+    if (summary) {
+      summary.currentSegment = segment;
+    }
+    return segment;
+  }
+
+  function codexAppServerReasoningSummaryDisplayText(value = "") {
+    let text = normalizeCodexRunText(value).replace(/\r\n/gu, "\n");
+    if (!text) {
+      return "";
+    }
+    text = text.replace(/\*\*([^*\n][\s\S]*?)\*\*/gu, "$1");
+    text = text.replace(/^\*\*\s*/u, "").replace(/\s*\*\*$/u, "");
+    return text
+      .split("\n")
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .join(" ")
+      .replace(/\s+/gu, " ")
+      .trim();
+  }
+
+  function codexAppServerReasoningDisplayText(value = "") {
+    return normalizeCodexRunText(value)
+      .replace(/\r\n/gu, "\n")
+      .split(/\n{2,}/u)
+      .map(codexAppServerReasoningSummaryDisplayText)
+      .filter(Boolean)
+      .join("\n\n")
+      .trim();
+  }
+
+  function recordCodexAppServerReasoningNotification(threadId = "", notification = {}, {
+    turnId = ""
+  } = {}) {
+    const method = normalizeCodexRunText(notification.method);
+    const item = codexAppServerNotificationItem(notification);
+    const completed = method === "item/completed" && item?.type === "reasoning";
+    if (!completed && !["item/reasoning/summaryPartAdded", "item/reasoning/summaryTextDelta", "item/reasoning/textDelta"].includes(method)) {
+      return false;
+    }
+    const normalizedThreadId = normalizeCodexRunText(threadId);
+    const normalizedTurnId = normalizeCodexRunText(turnId) || codexAppServerNotificationTurnId(notification);
+    if (!normalizedThreadId) {
+      return false;
+    }
+    const state = codexAppServerReasoningTurnState(normalizedThreadId, normalizedTurnId);
+    const params = codexAppServerNotificationParams(notification);
+    const itemId = normalizeCodexRunText(params.itemId || item?.id || "summary");
+    if (completed) {
+      // Completed-only providers expose the same readable parts in the item.
+      // Streamed items have already been recorded; do not replay their text.
+      if (state.channels.has(itemId)) return false;
+      const summary = codexAppServerContentText(item.summary);
+      const text = normalizeCodexRunText(summary) ? summary : codexAppServerContentText(item.content);
+      return recordCodexAppServerReasoningNotification(normalizedThreadId, {
+        method: normalizeCodexRunText(summary) ? "item/reasoning/summaryTextDelta" : "item/reasoning/textDelta",
+        params: { itemId, delta: text }
+      }, { turnId: normalizedTurnId });
+    }
+    const channel = method === "item/reasoning/textDelta" ? "content" : "summary";
+    // Some providers expose both channels. Keep the first readable stream once.
+    if (state.channels.has(itemId) && state.channels.get(itemId) !== channel) return false;
+    const summaryKey = codexAppServerReasoningSummaryKey(notification);
+    const summary = state.summaries.get(summaryKey) || {
+      currentSegment: null
+    };
+    if (!summary.currentSegment) {
+      createCodexAppServerReasoningSegment(state, summary, summaryKey);
+    }
+    if (method !== "item/reasoning/summaryPartAdded") {
+      let delta = codexAppServerContentText(params.delta || params.text);
+      if (delta) {
+        state.channels.set(itemId, channel);
+        const startsNewSegment = /^\s*\n/u.test(delta) &&
+          summary.currentSegment?.chunks?.length &&
+          summary.currentSegment?.persistedText;
+        if (startsNewSegment) {
+          delta = delta.replace(/^\s*\n+/u, "");
+          createCodexAppServerReasoningSegment(state, summary, summaryKey);
+        }
+        summary.currentSegment.chunks.push(delta);
+        state.summaries.set(summaryKey, summary);
+        return true;
+      }
+    }
+    state.summaries.set(summaryKey, summary);
+    return false;
+  }
+
+  async function recordCodexAppServerReasoningForSession(sessionId = "", threadId = "", notifications = []) {
+    const normalizedSessionId = normalizeCodexRunText(sessionId);
+    const normalizedThreadId = normalizeCodexRunText(threadId);
+    const store = await createStore(normalizedSessionId);
+    const run = await readCodexAppServerAgentRunForSession(store, normalizedSessionId);
+    const currentTurn = turnStateFromAgentRun(run || {});
+    const ownerTurnId = codexAppServerOutputOwnerTurnId({
+      notificationThreadId: normalizedThreadId,
+      notificationTurnId: codexAppServerNotificationTurnId(notifications[0]),
+      trackedActive: currentTurn.active,
+      trackedState: currentTurn.state,
+      trackedThreadId: currentTurn.threadId,
+      trackedTurnId: currentTurn.turnId
+    });
+    let changed = false;
+    for (const notification of notifications) {
+      if (recordCodexAppServerReasoningNotification(normalizedThreadId, notification, { turnId: ownerTurnId })) {
+        changed = true;
+      }
+    }
+    if (!changed) return false;
+    await queueCodexAppServerReasoningPersist(
+      normalizedSessionId,
+      normalizedThreadId,
+      ownerTurnId
+    );
+    return true;
+  }
+
+  function readCodexAppServerReasoningText(threadId = "", turnId = "") {
+    const state = codexAppServerReasoningExistingTurnState(threadId, turnId);
+    if (!state) {
+      return "";
+    }
+    return (Array.isArray(state.segments) ? state.segments : [])
+      .map((segment) => codexAppServerReasoningDisplayText(segment.chunks.join("")))
+      .filter(Boolean)
+      .join("\n\n")
+      .trim();
+  }
+
+  function codexAppServerReasoningPersistKey(sessionId = "", threadId = "", turnId = "") {
+    return [
+      normalizeCodexRunText(sessionId),
+      normalizeCodexRunText(threadId),
+      normalizeCodexRunText(turnId) || "*"
+    ].filter(Boolean).join(":");
+  }
+
+  async function persistCodexAppServerReasoningSummary(sessionId = "", threadId = "", turnId = "") {
+    const normalizedSessionId = normalizeCodexRunText(sessionId);
+    const state = codexAppServerReasoningExistingTurnState(threadId, turnId);
+    const segments = Array.isArray(state?.segments) ? state.segments : [];
+    const pendingSegments = segments
+      .map((segment) => ({
+        segment,
+        text: codexAppServerReasoningDisplayText(segment.chunks.join(""))
+      }))
+      .filter(({ segment, text }) => text && segment.persistedText !== text);
+    if (!normalizedSessionId || !state || !pendingSegments.length) {
+      return;
+    }
+    const store = await createStore(normalizedSessionId);
+    const run = await readCodexAppServerAgentRunForSession(store, normalizedSessionId);
+    if (normalizeCodexRunText(run?.inputSource) === "terminal") {
+      return;
+    }
+    const turn = turnStateFromAgentRun(run || {});
+    if (!codexAppServerTurnCanReceiveProviderActivity(turn, threadId, turnId)) {
+      debugLog("appServerReasoningSummary.ignored", {
+        currentState: turn.state,
+        currentStatus: turn.status,
+        currentThreadId: turn.threadId,
+        currentTurnId: turn.turnId,
+        sessionId: normalizedSessionId,
+        threadId: normalizeCodexRunText(threadId),
+        turnId: normalizeCodexRunText(turnId)
+      });
+      return;
+    }
+    for (const {
+      segment,
+      text
+    } of pendingSegments) {
+      segment.persistedAt ||= new Date().toISOString();
+      const written = await store.writeConversationThinkingMessage(normalizedSessionId, {
+        at: segment.persistedAt,
+        nativeIdentity: { threadId, turnId },
+        requireOpenTurn: false,
+        text
+      });
+      if (!written) {
+        continue;
+      }
+      segment.persistedText = text;
+      await publish(normalizedSessionId, {
+        payload: {
+          conversationLogPatch: {
+            turn: written,
+            type: "upsert-turn"
+          }
+        },
+        reason: "codex-app-server-reasoning-summary"
+      });
+    }
+  }
+
+  function queueCodexAppServerReasoningPersist(sessionId = "", threadId = "", turnId = "") {
+    const key = codexAppServerReasoningPersistKey(sessionId, threadId, turnId);
+    if (!key) {
+      return Promise.resolve();
+    }
+    return runQueuedCodexAppServerReasoningPersist(key, sessionId, threadId, turnId);
+  }
+
+  async function flushCodexAppServerReasoningPersist(sessionId = "", threadId = "", turnId = "") {
+    const key = codexAppServerReasoningPersistKey(sessionId, threadId, turnId);
+    const queued = key ? codexAppServerReasoningPersistQueues.get(key) : null;
+    if (queued) {
+      await queued.catch(() => null);
+    }
+    await persistCodexAppServerReasoningSummary(sessionId, threadId, turnId);
+  }
+
+  function runQueuedCodexAppServerReasoningPersist(key = "", sessionId = "", threadId = "", turnId = "") {
+    const previous = codexAppServerReasoningPersistQueues.get(key) || Promise.resolve();
+    const next = previous
+      .catch(() => null)
+      .then(() => persistCodexAppServerReasoningSummary(sessionId, threadId, turnId));
+    codexAppServerReasoningPersistQueues.set(key, next);
+    next
+      .finally(() => {
+        if (codexAppServerReasoningPersistQueues.get(key) === next) {
+          codexAppServerReasoningPersistQueues.delete(key);
+        }
+      })
+      .catch(() => null);
+    return next;
+  }
+
+  function cleanupCodexAppServerReasoningTurn(threadId = "", turnId = "") {
+    codexAppServerReasoningTurns.delete(codexAppServerReasoningTurnKey(threadId, turnId));
+    codexAppServerReasoningTurns.delete(codexAppServerReasoningTurnKey(threadId, "*"));
+  }
+
+  function splitCodexAppServerReasoningTurn(threadId = "", turnId = "") {
+    const state = codexAppServerReasoningExistingTurnState(threadId, turnId);
+    if (!state) {
+      return false;
+    }
+    for (const summary of state.summaries.values()) {
+      summary.currentSegment = null;
+    }
+    return true;
+  }
+
+  return {
+    reasoningTurns: codexAppServerReasoningTurns,
+    reasoningPersistQueues: codexAppServerReasoningPersistQueues,
+    recordReasoningForSession: recordCodexAppServerReasoningForSession,
+    readReasoningText: readCodexAppServerReasoningText,
+    flushReasoningPersist: flushCodexAppServerReasoningPersist,
+    cleanupReasoningTurn: cleanupCodexAppServerReasoningTurn,
+    splitReasoningTurn: splitCodexAppServerReasoningTurn
+  };
+}