@jskit-ai/assistant-core 0.1.200 → 0.1.201

package/src/server/conversation/codexMessageDelivery.js

@@ -0,0 +1,211 @@
+import { normalizeCodexRunText, codexAppServerPendingUserMessageOwnership } from "./codexTurnState.js";
+import {
+  codexAppServerNotificationItem,
+  codexAppServerUserMessageText,
+  codexAppServerNotificationTurnId
+} from "./codexEvents.js";
+
+// Original request deduplication and authored receipt persistence.
+// One instance and its two Maps belong to the containing retained run owner.
+export function createCodexAppServerMessageDelivery({
+  namespace,
+  publish,
+  messageMetadata,
+  createStore,
+  turnStateFromAgentRun,
+  deliveryStateMetadataKey,
+  output,
+  journal,
+  recovery
+}) {
+  const {
+    readAgentRunForSession: readCodexAppServerAgentRunForSession,
+    writeMirroredTerminalMessage: writeMirroredCodexAppServerTerminalMessage
+  } = output;
+  const { writeUserMessageOwnership: writeCodexAppServerUserMessageOwnership } = journal;
+  const { markProviderTurnActive: markCodexAppServerProviderTurnActive } = recovery;
+  const codexAppServerMessageDeliveries = new Map();
+  const codexAppServerPendingUserMessages = new Map();
+
+  async function withCodexAppServerMessageDelivery(sessionId, messageId, pendingMessage, operation) {
+    const normalizedMessageId = normalizeCodexRunText(messageId);
+    const deliveryKey = normalizedMessageId ? `${namespace(sessionId)}\0${normalizedMessageId}` : "";
+    const existing = deliveryKey ? codexAppServerMessageDeliveries.get(deliveryKey) : null;
+    if (existing) {
+      return existing;
+    }
+    if (deliveryKey) {
+      codexAppServerPendingUserMessages.set(deliveryKey, {
+        ...pendingMessage,
+        receipt: Promise.withResolvers()
+      });
+    }
+    const delivery = operation();
+    if (deliveryKey) {
+      codexAppServerMessageDeliveries.set(deliveryKey, delivery);
+    }
+    try {
+      return await delivery;
+    } finally {
+      if (deliveryKey && codexAppServerMessageDeliveries.get(deliveryKey) === delivery) {
+        codexAppServerMessageDeliveries.delete(deliveryKey);
+        codexAppServerPendingUserMessages.delete(deliveryKey);
+      }
+    }
+  }
+
+  async function writeCodexAppServerDeliveredUserMessage(
+    runtime,
+    sessionId = "",
+    text = "",
+    messageId = "",
+    turnMetadata = null,
+    attachments = [],
+    nativeIdentity = null
+  ) {
+    const normalizedSessionId = normalizeCodexRunText(sessionId);
+    const message = normalizeCodexRunText(text);
+    if (
+      !normalizedSessionId ||
+      (!message && !(Array.isArray(attachments) && attachments.length)) ||
+      typeof runtime?.store?.writeConversationUserMessage !== "function"
+    ) {
+      return null;
+    }
+    const pendingMessage = codexAppServerPendingUserMessages.get(
+      `${namespace(normalizedSessionId)}\0${normalizeCodexRunText(messageId)}`
+    );
+    if (pendingMessage?.recording) {
+      return pendingMessage.recording;
+    }
+    const recording = (async () => {
+      const written = await runtime.store.writeConversationUserMessage(normalizedSessionId, {
+        attachments,
+        nativeIdentity,
+        messageId: normalizeCodexRunText(messageId),
+        text: message,
+        turnMetadata: messageMetadata.delivered
+          ? await messageMetadata.delivered(runtime.store, normalizedSessionId, turnMetadata)
+          : turnMetadata
+      });
+      if (!written) {
+        return null;
+      }
+      await publish(normalizedSessionId, {
+        payload: {
+          conversationLogPatch: {
+            turn: written,
+            type: "upsert-turn"
+          }
+        },
+        reason: "codex-app-server-message-delivered"
+      });
+      return written;
+    })();
+    if (pendingMessage) {
+      pendingMessage.recording = recording;
+    }
+    return recording;
+  }
+
+  async function mirrorCodexAppServerTerminalUserMessage(sessionId = "", threadId = "", notification = {}) {
+    const normalizedSessionId = normalizeCodexRunText(sessionId);
+    const normalizedThreadId = normalizeCodexRunText(threadId);
+    const item = codexAppServerNotificationItem(notification);
+    const text = codexAppServerUserMessageText(item);
+    const clientId = normalizeCodexRunText(item?.clientId);
+    if (!normalizedSessionId || (!text && (!clientId || normalizeCodexRunText(item?.type) !== "userMessage"))) {
+      return;
+    }
+    const store = await createStore(normalizedSessionId);
+    const run = await readCodexAppServerAgentRunForSession(store, normalizedSessionId);
+    let ownership = codexAppServerPendingUserMessageOwnership(run, clientId);
+    if (!ownership && clientId && await store.conversationMessageIdExists(normalizedSessionId, clientId)) return;
+    const receiptId = ownership?.clientId || clientId;
+    const pendingMessage = codexAppServerPendingUserMessages.get(
+      `${namespace(normalizedSessionId)}\0${receiptId}`
+    );
+    let recoveredMessage = null;
+    if (receiptId && !pendingMessage) {
+      const saved = JSON.parse(await store.readMetadataValue(normalizedSessionId, deliveryStateMetadataKey) || "null");
+      const pending = Object.values(saved?.engines || {}).map((binding) => binding.pending)
+        .find((candidate) => candidate?.messageId === receiptId && candidate.threadId === normalizedThreadId);
+      if (pending) {
+        recoveredMessage = pending;
+        ownership ||= { clientId: receiptId, inputSource: "chat" };
+      }
+    }
+    if (!text && (!ownership || !(
+      Array.isArray(pendingMessage?.attachments) && pendingMessage.attachments.length ||
+      Array.isArray(recoveredMessage?.displayAttachments) && recoveredMessage.displayAttachments.length
+    ))) return;
+    if (ownership) {
+      // The provider's user-message receipt precedes its answer notifications.
+      // Persist the authored message here so answers cannot overtake it while
+      // the original HTTP request is still finishing startup bookkeeping.
+      if (pendingMessage) {
+        await writeCodexAppServerDeliveredUserMessage(
+          { store },
+          normalizedSessionId,
+          pendingMessage.text,
+          ownership.clientId,
+          { ...await messageMetadata.actor?.(pendingMessage.actorContext), ...pendingMessage.turnMetadata },
+          pendingMessage.attachments,
+          { threadId: normalizedThreadId, turnId: codexAppServerNotificationTurnId(notification) }
+        );
+      } else if (recoveredMessage) {
+        await writeCodexAppServerDeliveredUserMessage(
+          { store }, normalizedSessionId, recoveredMessage.displayMessage, receiptId,
+          recoveredMessage.turnMetadata, recoveredMessage.displayAttachments,
+          { threadId: normalizedThreadId, turnId: codexAppServerNotificationTurnId(notification) }
+        );
+      }
+      const turn = turnStateFromAgentRun(run || {});
+      const providerTurnId = codexAppServerNotificationTurnId(notification);
+      const providerTurnAlreadyTracked = normalizeCodexRunText(turn.state) === "active" &&
+        (!normalizedThreadId || normalizeCodexRunText(turn.threadId) === normalizedThreadId) &&
+        (!providerTurnId || normalizeCodexRunText(turn.turnId) === providerTurnId);
+      if (!providerTurnAlreadyTracked) {
+        await markCodexAppServerProviderTurnActive(normalizedSessionId, {
+          inputSource: ownership.inputSource,
+          status: "inProgress",
+          threadId: normalizedThreadId,
+          turnId: providerTurnId
+        });
+      }
+      await writeCodexAppServerUserMessageOwnership(
+        store,
+        normalizedSessionId,
+        ownership.clientId,
+        {
+          eventKind: "codex-app-server-user-message-consumed",
+          owned: false
+        }
+      );
+      if (providerTurnId) {
+        pendingMessage?.receipt.resolve({ id: providerTurnId });
+      }
+      return;
+    }
+    await markCodexAppServerProviderTurnActive(normalizedSessionId, {
+      status: "inProgress",
+      threadId: normalizedThreadId,
+      turnId: codexAppServerNotificationTurnId(notification)
+    });
+    await writeMirroredCodexAppServerTerminalMessage({
+      notification,
+      role: "user",
+      sessionId: normalizedSessionId,
+      text,
+      threadId: normalizedThreadId
+    });
+  }
+
+  return {
+    messageDeliveries: codexAppServerMessageDeliveries,
+    pendingUserMessages: codexAppServerPendingUserMessages,
+    withMessageDelivery: withCodexAppServerMessageDelivery,
+    writeDeliveredUserMessage: writeCodexAppServerDeliveredUserMessage,
+    mirrorTerminalUserMessage: mirrorCodexAppServerTerminalUserMessage
+  };
+}

package/src/server/conversation/codexNativeHistoryExport.js

@@ -0,0 +1,95 @@
+import {
+  codexAppServerAssistantItemText,
+  codexAppServerUserMessageText
+} from "./codexEvents.js";
+import { canonicalNativeHistoryJson as canonicalJson, createNativeHistoryExport } from "./nativeHistoryExport.js";
+
+function threadHistoryMetadata(thread) {
+  const stored = { ...thread };
+  // These describe a currently loaded process, not persisted conversation
+  // content. Native deletion can unload a thread before refusing an external
+  // fork, so they must not invalidate an otherwise identical preservation.
+  delete stored.status;
+  delete stored.canAcceptDirectInput;
+  delete stored.environments;
+  return stored;
+}
+
+// The caller owns a bounded, read-only connection. This exports API-visible
+// content, not an importable database or a native-resume snapshot.
+export async function exportCodexNativeHistory(client, threadId, onRecord, {
+  signal, maxPages = 20_000, maxBytes = 2 * 1024 ** 3, errorPrefix = ""
+} = {}) {
+  if (!threadId || typeof onRecord !== "function") throw new TypeError("Native export requires a thread and record callback.");
+  const output = createNativeHistoryExport(onRecord, { signal, maxBytes });
+  const emit = output.emit;
+  let turnCount = 0;
+  let itemCount = 0;
+  let pages = 0;
+  const request = (method, params = {}) => {
+    signal?.throwIfAborted();
+    return client.request(method, { threadId, ...params }, { signal });
+  };
+  const { thread } = await request("thread/read", { includeTurns: false });
+  if (thread?.id !== threadId || !["idle", "notLoaded"].includes(thread.status?.type)) {
+    throw new Error("Codex native export requires the exact idle thread.");
+  }
+  if (thread.historyMode !== "paginated") {
+    throw Object.assign(new Error("Codex native retirement requires paginated history. This unsupported conversation needs operator cleanup."),
+      { code: `${errorPrefix}codex_paginated_history_required` });
+  }
+  const goalResult = await request("thread/goal/get");
+  if (!Object.hasOwn(goalResult || {}, "goal")) throw new Error("Codex did not return its native goal state.");
+  const { goal } = goalResult;
+  if (goal?.status === "active") throw new Error("Pause the Codex goal before native history retirement.");
+  const metadata = threadHistoryMetadata(thread);
+  await emit({ type: "thread", thread: metadata, text: [] });
+  await emit({ type: "goal", goal: goal ?? null,
+    text: typeof goal?.objective === "string" ? [{ role: "goal", text: goal.objective, branchId: threadId,
+      ...(Number.isFinite(goal.createdAt) ? { createdAt: new Date(goal.createdAt * 1000).toISOString() } : {}),
+      ...(Number.isFinite(goal.updatedAt) ? { updatedAt: new Date(goal.updatedAt * 1000).toISOString() } : {}) }] : [] });
+
+  const pageAll = async (method, params, consume) => {
+    let cursor;
+    const cursors = new Set();
+    do {
+      if (++pages > maxPages) throw new Error("Codex native export exceeded its page limit; history was not retired.");
+      const page = await request(method, { ...params, limit: 100, sortDirection: "asc", ...(cursor ? { cursor } : {}) });
+      if (!Array.isArray(page?.data) || page.data.length > 100 ||
+          (page.nextCursor != null && (typeof page.nextCursor !== "string" || !page.nextCursor))) {
+        throw new Error("Codex returned an invalid native history page.");
+      }
+      for (const entry of page.data) await consume(entry);
+      cursor = page.nextCursor;
+      if (cursor && cursors.has(cursor)) throw new Error("Codex repeated a native history cursor.");
+      if (cursor) cursors.add(cursor);
+    } while (cursor);
+  };
+  await pageAll("thread/turns/list", { itemsView: "notLoaded" }, async (turn) => {
+    if (!turn?.id || turn.itemsView !== "notLoaded" || !Array.isArray(turn.items) || turn.items.length || turn.status === "inProgress") {
+      throw new Error("Codex returned an invalid or active native turn.");
+    }
+    turnCount++;
+    await emit({ type: "turn", turn, text: [] });
+  });
+  await pageAll("thread/items/list", {}, async ({ turnId, item } = {}) => {
+    if (!turnId || !item?.id || typeof item.type !== "string") throw new Error("Codex returned an invalid native item.");
+    itemCount++;
+    const user = codexAppServerUserMessageText(item);
+    const assistant = codexAppServerAssistantItemText(item);
+    await emit({ type: "item", turnId, item,
+      text: user || assistant ? [{ role: user ? "user" : "assistant", text: user || assistant,
+        branchId: threadId, turnId, messageId: item.id,
+        ...(item.clientId ? { clientId: item.clientId } : {}),
+        ...(item.phase ? { phase: item.phase } : {}) }] : [] });
+  });
+  const after = await request("thread/read", { includeTurns: false });
+  const afterGoal = await request("thread/goal/get");
+  if (!["idle", "notLoaded"].includes(after.thread?.status?.type) ||
+      canonicalJson(threadHistoryMetadata(after.thread)) !== canonicalJson(metadata) ||
+      canonicalJson(afterGoal.goal ?? null) !== canonicalJson(goal ?? null)) {
+    throw new Error("Codex native history changed during export; preserve it again before retirement.");
+  }
+  signal?.throwIfAborted();
+  return output.complete({ historyMode: "paginated", turnCount, itemCount });
+}