@jskit-ai/assistant-core 0.2.7 → 0.2.9

package/src/server/conversation/codexMessageDelivery.js

@@ -1,12 +1,25 @@
-import { normalizeCodexRunText, codexAppServerPendingUserMessageOwnership } from "./codexTurnState.js";
+import { codexAppServerPendingUserMessageOwnership } from "./codexTurnState.js";
 import {
   codexAppServerNotificationItem,
   codexAppServerUserMessageText,
   codexAppServerNotificationTurnId
 } from "./codexEvents.js";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { ignoreReceipt } from "./nativeCommandCallbacks.js";
 
-// Original request deduplication and authored receipt persistence.
-// One instance and its two Maps belong to the containing retained run owner.
+/**
+ * Request deduplication and authored receipt persistence. One instance and its two Maps belong to its run owner.
+ * @param {object} dependencies
+ * @param {import("./codexTurn.js").CodexSessionNamespace} dependencies.namespace
+ * @param {import("./codexTurn.js").CodexPublish} dependencies.publish
+ * @param {import("./codexTurn.js").CodexMessageMetadataHooks} dependencies.messageMetadata
+ * @param {import("./codexTurn.js").CodexCreateStore} dependencies.createStore
+ * @param {import("./codexTurn.js").CodexAgentRunTurnStateReader} dependencies.turnStateFromAgentRun
+ * @param {string} dependencies.deliveryStateMetadataKey
+ * @param {import("./codexOutput.js").CodexAppServerOutput} dependencies.output
+ * @param {import("./codexRunJournal.js").CodexRunJournal} dependencies.journal
+ * @param {import("./codexTurnRecovery.js").CodexTurnRecovery} dependencies.recovery
+ */
 export function createCodexAppServerMessageDelivery({
   namespace,
   publish,
@@ -18,12 +31,6 @@ export function createCodexAppServerMessageDelivery({
   journal,
   recovery
 }) {
-  const {
-    readAgentRunForSession: readCodexAppServerAgentRunForSession,
-    writeMirroredTerminalMessage: writeMirroredCodexAppServerTerminalMessage
-  } = output;
-  const { writeUserMessageOwnership: writeCodexAppServerUserMessageOwnership } = journal;
-  const { markProviderTurnActive: markCodexAppServerProviderTurnActive } = recovery;
   const codexAppServerMessageDeliveries = new Map();
   const codexAppServerPendingUserMessages = new Map();
 
@@ -36,15 +43,18 @@ export function createCodexAppServerMessageDelivery({
   }
 
   async function withCodexAppServerMessageDelivery(sessionId, messageId, pendingMessage, operation) {
-    const normalizedMessageId = normalizeCodexRunText(messageId);
+    const normalizedMessageId = normalizeText(messageId);
     const deliveryKey = normalizedMessageId ? messageDeliveryKey(sessionId, normalizedMessageId) : "";
     const existing = deliveryKey ? codexAppServerMessageDeliveries.get(deliveryKey) : null;
     if (existing) {
       return existing;
     }
     if (deliveryKey) {
+      const { onNativeReceipt = ignoreReceipt, onReceiptPersisted = ignoreReceipt } = pendingMessage;
       codexAppServerPendingUserMessages.set(deliveryKey, {
         ...pendingMessage,
+        onNativeReceipt,
+        onReceiptPersisted,
         receipt: Promise.withResolvers()
       });
     }
@@ -72,36 +82,33 @@ export function createCodexAppServerMessageDelivery({
     nativeIdentity = null,
     data
   ) {
-    const normalizedSessionId = normalizeCodexRunText(sessionId);
-    const message = normalizeCodexRunText(text);
+    const normalizedSessionId = normalizeText(sessionId);
+    const message = normalizeText(text);
     if (
       !normalizedSessionId ||
-      (!message && !(Array.isArray(attachments) && attachments.length)) ||
-      typeof runtime?.store?.writeConversationUserMessage !== "function"
+      (!message && !(Array.isArray(attachments) && attachments.length))
     ) {
       return null;
     }
-    const pendingMessage = pendingUserMessage(normalizedSessionId, normalizeCodexRunText(messageId));
+    const pendingMessage = pendingUserMessage(normalizedSessionId, normalizeText(messageId));
     if (pendingMessage?.recording) {
       return pendingMessage.recording;
     }
     const authored = pendingMessage?.authoredInput;
-    const applicationData = authored?.messageId === normalizeCodexRunText(messageId) ? authored.data : data;
+    const applicationData = authored?.messageId === normalizeText(messageId) ? authored.data : data;
     const recording = (async () => {
       const written = await runtime.store.writeConversationUserMessage(normalizedSessionId, {
         attachments,
         nativeIdentity,
-        messageId: normalizeCodexRunText(messageId),
+        messageId: normalizeText(messageId),
         text: message,
         ...(applicationData !== undefined ? { data: structuredClone(applicationData) } : {}),
-        turnMetadata: messageMetadata.delivered
-          ? await messageMetadata.delivered(runtime.store, normalizedSessionId, turnMetadata)
-          : turnMetadata
+        turnMetadata: await messageMetadata.delivered(runtime.store, normalizedSessionId, turnMetadata)
       });
       if (!written) {
         return null;
       }
-      pendingMessage?.onReceiptPersisted?.();
+      pendingMessage?.onReceiptPersisted();
       await publish(normalizedSessionId, {
         payload: {
           conversationLogPatch: {
@@ -120,16 +127,16 @@ export function createCodexAppServerMessageDelivery({
   }
 
   async function mirrorCodexAppServerTerminalUserMessage(sessionId = "", threadId = "", notification = {}) {
-    const normalizedSessionId = normalizeCodexRunText(sessionId);
-    const normalizedThreadId = normalizeCodexRunText(threadId);
+    const normalizedSessionId = normalizeText(sessionId);
+    const normalizedThreadId = normalizeText(threadId);
     const item = codexAppServerNotificationItem(notification);
     const text = codexAppServerUserMessageText(item);
-    const clientId = normalizeCodexRunText(item?.clientId);
-    if (!normalizedSessionId || (!text && (!clientId || normalizeCodexRunText(item?.type) !== "userMessage"))) {
+    const clientId = normalizeText(item?.clientId);
+    if (!normalizedSessionId || (!text && (!clientId || normalizeText(item?.type) !== "userMessage"))) {
       return;
     }
     const store = await createStore(normalizedSessionId);
-    const run = await readCodexAppServerAgentRunForSession(store, normalizedSessionId);
+    const run = await output.readAgentRunForSession(store, normalizedSessionId);
     let ownership = codexAppServerPendingUserMessageOwnership(run, clientId);
     if (!ownership && clientId && await store.conversationMessageIdExists(normalizedSessionId, clientId)) return;
     const receiptId = ownership?.clientId || clientId;
@@ -149,7 +156,7 @@ export function createCodexAppServerMessageDelivery({
       Array.isArray(recoveredMessage?.displayAttachments) && recoveredMessage.displayAttachments.length
     ))) return;
     if (ownership) {
-      pendingMessage?.onNativeReceipt?.();
+      pendingMessage?.onNativeReceipt();
       // 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.
@@ -159,7 +166,7 @@ export function createCodexAppServerMessageDelivery({
           normalizedSessionId,
           pendingMessage.text,
           ownership.clientId,
-          { ...await messageMetadata.actor?.(pendingMessage.actorContext), ...pendingMessage.turnMetadata },
+          { ...await messageMetadata.actor(pendingMessage.actorContext), ...pendingMessage.turnMetadata },
           pendingMessage.attachments,
           { threadId: normalizedThreadId, turnId: codexAppServerNotificationTurnId(notification) }
         );
@@ -173,18 +180,18 @@ export function createCodexAppServerMessageDelivery({
       }
       const turn = turnStateFromAgentRun(run || {});
       const providerTurnId = codexAppServerNotificationTurnId(notification);
-      const providerTurnAlreadyTracked = normalizeCodexRunText(turn.state) === "active" &&
-        (!normalizedThreadId || normalizeCodexRunText(turn.threadId) === normalizedThreadId) &&
-        (!providerTurnId || normalizeCodexRunText(turn.turnId) === providerTurnId);
+      const providerTurnAlreadyTracked = normalizeText(turn.state) === "active" &&
+        (!normalizedThreadId || normalizeText(turn.threadId) === normalizedThreadId) &&
+        (!providerTurnId || normalizeText(turn.turnId) === providerTurnId);
       if (!providerTurnAlreadyTracked) {
-        await markCodexAppServerProviderTurnActive(normalizedSessionId, {
+        await recovery.markProviderTurnActive(normalizedSessionId, {
           inputSource: ownership.inputSource,
           status: "inProgress",
           threadId: normalizedThreadId,
           turnId: providerTurnId
         });
       }
-      await writeCodexAppServerUserMessageOwnership(
+      await journal.writeUserMessageOwnership(
         store,
         normalizedSessionId,
         ownership.clientId,
@@ -198,12 +205,12 @@ export function createCodexAppServerMessageDelivery({
       }
       return;
     }
-    await markCodexAppServerProviderTurnActive(normalizedSessionId, {
+    await recovery.markProviderTurnActive(normalizedSessionId, {
       status: "inProgress",
       threadId: normalizedThreadId,
       turnId: codexAppServerNotificationTurnId(notification)
     });
-    await writeMirroredCodexAppServerTerminalMessage({
+    await output.writeMirroredTerminalMessage({
       notification,
       role: "user",
       sessionId: normalizedSessionId,
@@ -212,12 +219,14 @@ export function createCodexAppServerMessageDelivery({
     });
   }
 
-  return {
+  return Object.freeze({
     messageDeliveries: codexAppServerMessageDeliveries,
     pendingUserMessages: codexAppServerPendingUserMessages,
     pendingUserMessage,
     withMessageDelivery: withCodexAppServerMessageDelivery,
     writeDeliveredUserMessage: writeCodexAppServerDeliveredUserMessage,
     mirrorTerminalUserMessage: mirrorCodexAppServerTerminalUserMessage
-  };
+  });
 }
+
+/** @typedef {ReturnType<typeof createCodexAppServerMessageDelivery>} CodexAppServerMessageDelivery */

package/src/server/conversation/codexModelCatalog.js

@@ -1,4 +1,5 @@
 import { normalizeNullableText as normalizeAgentText } from "./normalize.js";
+import { codexAppServerOwnedRuntimeKey, codexAppServerOwnedRuntimes, withRuntimeLifecycle } from "./codexRuntimeInventory.js";
 
 // Bounded live model catalog, cached per provider connection generation.
 export function codexAppServerModelCatalogError(message = "", errorPrefix = "") {
@@ -7,13 +8,9 @@ export function codexAppServerModelCatalogError(message = "", errorPrefix = "")
   return error;
 }
 
-export function codexAppServerProviderConnectionGeneration(provider = null) {
-  const generation = typeof provider?.currentConnectionGeneration === "function"
-    ? provider.currentConnectionGeneration()
-    : typeof provider?.connectionGeneration === "function"
-      ? provider.connectionGeneration()
-      : provider?.connectionGeneration;
-  return normalizeAgentText(generation || "");
+/** @param {import("./codexProvider.js").CodexAppServerAgentProvider} provider */
+export function codexAppServerProviderConnectionGeneration(provider) {
+  return normalizeAgentText(provider.currentConnectionGeneration() || "");
 }
 
 function codexAppServerModelCatalogSnapshot(value = null, errorPrefix = "") {
@@ -39,6 +36,7 @@ export function createCodexAppServerModelCatalogCache({
 } = {}) {
   const codexAppServerModelCatalogs = new WeakMap();
   return async function readCodexAppServerModelCatalog(provider, { signal = null } = {}) {
+    // readable-check: allow method-probe - safety invariant: a provider without live model discovery is refused with codex_model_catalog_unavailable
     if (typeof provider.listModels !== "function") {
       const error = new Error("Codex live model discovery is unavailable.");
       error.code = `${errorPrefix}codex_model_catalog_unavailable`;
@@ -95,3 +93,84 @@ export function createCodexAppServerModelCatalogCache({
     }
   };
 }
+
+/**
+ * The chat model catalogue an owner reads from its native runtime, cached per runtime identity. A runtime it
+ * starts only for the read stops again.
+ * @param {object} dependencies
+ * @param {<T>(operation: () => T) => Promise<Awaited<T>>} dependencies.withLifecycle
+ * @param {() => void} dependencies.assertOpen
+ * @param {(request: { operation: () => Promise<object>, provider: object, providerOptions: object }) => Promise<object>} dependencies.acquireRuntime
+ * @param {(record: object) => Promise<object>} dependencies.stopOwnedRuntime
+ * @param {(provider: object) => void} dependencies.forgetOwnedRuntime
+ */
+export function createCodexRuntimeModelCatalog({ withLifecycle, assertOpen, acquireRuntime, stopOwnedRuntime, forgetOwnedRuntime }) {
+  let codexAppServerChatModelCatalog = null;
+
+  function readModelCatalog({
+    prepareProviderOptions,
+    providerFactory,
+    resources = null,
+    signal = null,
+    cacheMs = 30_000
+  } = {}) {
+    return withLifecycle(async () => {
+      assertOpen();
+      signal?.throwIfAborted();
+      const providerOptions = await prepareProviderOptions();
+      return withRuntimeLifecycle(codexAppServerOwnedRuntimeKey("", providerOptions), async () => {
+        const existing = codexAppServerOwnedRuntimes.get(
+          codexAppServerOwnedRuntimeKey("", providerOptions)
+        );
+        const provider = existing?.provider || providerFactory(providerOptions);
+        let runtime = null;
+        let catalog = null;
+        let identity = "";
+        try {
+          assertOpen();
+          identity = JSON.stringify(await provider.currentRuntimeInfo());
+          signal?.throwIfAborted();
+          if (codexAppServerChatModelCatalog?.identity === identity &&
+              codexAppServerChatModelCatalog.expiresAt > Date.now()) {
+            return codexAppServerChatModelCatalog.value;
+          }
+          if (!existing?.provider) {
+            runtime = await acquireRuntime({
+              operation: () => provider.ensureRuntime(),
+              provider,
+              providerOptions
+            });
+          }
+          catalog = await provider.listModels({ includeHidden: false, limit: 100 }, { signal });
+        } finally {
+          if (!existing?.provider) {
+            try {
+              if ((runtime || provider.runtime)?.reused === false) {
+                await stopOwnedRuntime({ provider, resources });
+              } else {
+                forgetOwnedRuntime(provider);
+              }
+            } finally {
+              provider.close();
+            }
+          }
+        }
+        codexAppServerChatModelCatalog = {
+          expiresAt: Date.now() + cacheMs,
+          identity,
+          value: catalog
+        };
+        return catalog;
+      });
+    });
+  }
+
+  function forgetModelCatalog() {
+    codexAppServerChatModelCatalog = null;
+  }
+
+  return Object.freeze({
+    read: readModelCatalog,
+    forget: forgetModelCatalog
+  });
+}