@jskit-ai/assistant-core 0.2.7 → 0.2.9

package/src/server/conversation/storage.js

@@ -7,6 +7,7 @@ export function createConversationOperationLease() {
   const idle = new Promise((resolve) => {
     resolveIdle = resolve;
   });
+  // readable-check: allow unfrozen-result - data: a lease counts its running operations in place
   return {
     idle,
     operations: 0,
@@ -29,10 +30,13 @@ export function finishConversationOperation(lease, participant) {
   }
 }
 
-/** Nested native store operations share the host's current transaction. The
+/**
+ * Nested native store operations share the host's current transaction. The
  * supplied storage remains the only writer queue and commit/rollback owner.
+ * @param {import("../types.js").ConversationStorage} storage
  */
 export function createReentrantConversationStorage(storage) {
+  // readable-check: allow method-probe - input validation: the application's storage adapter must offer read and write
   if (typeof storage?.read !== "function" || typeof storage?.write !== "function") {
     throw new TypeError("Conversation storage requires read(scope, callback) and write(scope, callback).");
   }
@@ -52,26 +56,31 @@ export function createReentrantConversationStorage(storage) {
     }
   }
 
+  function read(scope, operation) {
+    const context = inherited(scope);
+    return context ? participate(context, operation) : storage.read(scope, operation);
+  }
+
+  function write(scope, operation) {
+    const context = inherited(scope);
+    if (context) return participate(context, operation);
+    return storage.write(scope, async transaction => {
+      const lease = createConversationOperationLease();
+      const participant = beginConversationOperation(lease);
+      try {
+        return await mutationContext.run({ scope, transaction, lease, participant }, () => operation(transaction));
+      } finally {
+        finishConversationOperation(lease, participant);
+        await lease.idle;
+      }
+    });
+  }
+
   return Object.freeze({
     ...storage,
-    read(scope, operation) {
-      const context = inherited(scope);
-      return context ? participate(context, operation) : storage.read(scope, operation);
-    },
-    write(scope, operation) {
-      const context = inherited(scope);
-      if (context) return participate(context, operation);
-      return storage.write(scope, async transaction => {
-        const lease = createConversationOperationLease();
-        const participant = beginConversationOperation(lease);
-        try {
-          return await mutationContext.run({ scope, transaction, lease, participant }, () => operation(transaction));
-        } finally {
-          finishConversationOperation(lease, participant);
-          await lease.idle;
-        }
-      });
-    },
+    read,
+    write,
+    // readable-check: allow method-probe - optional operation: a storage adapter may also delete a conversation
     ...(typeof storage.deleteConversation === "function"
       ? { deleteConversation: scope => storage.deleteConversation(scope) } : {})
   });
@@ -85,8 +94,8 @@ function conversationMessageStorageKey({ role, at, messageId } = {}) {
   const timestamp = date.toISOString().replace(/[-:]/gu, "").replace(".", "");
   const normalizedMessageId = String(messageId || "").trim();
   const idSuffix = normalizedMessageId ? `.${normalizedMessageId}` : "";
-  // The original transcript overwrote this same role/timestamp/id file. Its
-  // filesystem suffix restrictions do not apply to record-native message IDs.
+  // One role, timestamp and message ID name one message, so saving it again
+  // replaces it. Record-native message IDs need no filesystem-safe suffix.
   return `${normalizedRole}.${timestamp}${idSuffix}.md`;
 }
 
@@ -102,13 +111,21 @@ function conversationMessageIndex(record) {
   return record.index;
 }
 
-/** Transaction implementation for single-writer record adapters. This serializes
+/**
+ * Transaction implementation for single-writer record adapters. This serializes
  * one instance's writes; a database with multiple writers must also hold its own
  * transaction/lock across readRecord and writeRecord, or implement read/write directly.
  * An adapter may supply recordVersion(id), a cheap token that changes whenever
  * the saved record changes; the parsed record is then reused until it changes.
+ * @param {object} adapter
+ * @param {(id: string) => Promise<{ turns: Map<string, object>, metadata: object, summary?: object }>} adapter.readRecord
+ * @param {(id: string, record: object, view: object) => Promise<void>} adapter.writeRecord
+ * @param {(id: string) => Promise<void>} adapter.deleteRecord
+ * @param {(id: string) => Promise<unknown>} [adapter.recordVersion]
  */
 export function createConversationStorage({ readRecord, writeRecord, deleteRecord, recordVersion }) {
+  // readable-check: allow method-probe - optional operation: an adapter without recordVersion reads its record every time and keeps no cache
+  const versioned = typeof recordVersion === "function";
   const pending = new Map();
   const cache = new Map();
 
@@ -118,7 +135,7 @@ export function createConversationStorage({ readRecord, writeRecord, deleteRecor
   }
 
   async function readSaved(id) {
-    if (typeof recordVersion !== "function") return readRecord(id);
+    if (!versioned) return readRecord(id);
     const version = await recordVersion(id);
     const cached = cache.get(id);
     if (version != null && cached?.version === version) return cached.record;
@@ -130,7 +147,8 @@ export function createConversationStorage({ readRecord, writeRecord, deleteRecor
 
   // Saved records are shared and never changed in place. A transaction copies
   // the turn map and each turn it changes, then commits that new record.
-  // Adapter fields the transaction does not manage are carried unchanged.
+  // Adapter fields the transaction does not manage are carried unchanged. The
+  // record's optional `summary` is { text, throughTurnId }, written by compaction.
   function transaction(saved) {
     const { index: _index, ...draft } = saved;
     const added = new Map();
@@ -157,6 +175,24 @@ export function createConversationStorage({ readRecord, writeRecord, deleteRecor
       return { ...draft, index };
     }
     const turns = () => draft.turns;
+    function readTurn(id) {
+      const turn = turns().get(id);
+      if (!turn) return null;
+      const find = (role) => turn.messages.find((message) => message.role === role) || null;
+      const thinking = turn.messages.filter((message) => message.role === "thinking");
+      const commentary = turn.messages.filter((message) => message.role === "commentary");
+      // Native continuations (for example Claude background-task notifications)
+      // can add later replies to the same request turn. Every saved reply stays
+      // in the ordered message list; the latest one still closes it.
+      const replies = turn.messages.filter((message) => message.role === "assistant");
+      const activity = [...thinking, ...commentary, ...replies.slice(0, -1)].sort((a, b) => a.at.localeCompare(b.at));
+      const system = find("system"), user = find("user"), assistant = find("assistant");
+      return structuredClone({
+        turnId: id, user, assistant, thinking, commentary,
+        ...(system ? { system } : {}), ...(turn.metadata ? { metadata: turn.metadata } : {}),
+        messages: [system, user, ...activity, replies.at(-1)].filter(Boolean)
+      });
+    }
     function messageTurnId(id) {
       if (!id) return "";
       const turnId = added.get(id) ?? conversationMessageIndex(saved).get(id);
@@ -180,23 +216,20 @@ export function createConversationStorage({ readRecord, writeRecord, deleteRecor
         async hasMessage(id) { return Boolean(messageTurnId(id)); },
         // Optional transaction extension: the turn holding this message ID.
         async findMessageTurnId(id) { return messageTurnId(id); },
-        async readTurn(id) {
-          const turn = turns().get(id);
-          if (!turn) return null;
-          const find = (role) => turn.messages.find((message) => message.role === role) || null;
-          const thinking = turn.messages.filter((message) => message.role === "thinking");
-          const commentary = turn.messages.filter((message) => message.role === "commentary");
-          // Native continuations (for example Claude background-task notifications)
-          // can add later replies to the same request turn. Every saved reply stays
-          // in the ordered message list; the latest one still closes it.
-          const replies = turn.messages.filter((message) => message.role === "assistant");
-          const activity = [...thinking, ...commentary, ...replies.slice(0, -1)].sort((a, b) => a.at.localeCompare(b.at));
-          const system = find("system"), user = find("user"), assistant = find("assistant");
-          return structuredClone({
-            turnId: id, user, assistant, thinking, commentary,
-            ...(system ? { system } : {}), ...(turn.metadata ? { metadata: turn.metadata } : {}),
-            messages: [system, user, ...activity, replies.at(-1)].filter(Boolean)
-          });
+        async readTurn(id) { return readTurn(id); },
+        // The turns after `turnId`, in order ("" is all of them).
+        async readTurnsAfter(turnId) {
+          const ids = [...turns().keys()];
+          const start = turnId ? ids.indexOf(turnId) + 1 : 0;
+          if (!start && turnId) throw new Error("The conversation turn does not exist.");
+          return ids.slice(start).map(readTurn);
+        },
+        // The compaction summary: its text and the last turn it covers.
+        async readSummary() { return draft.summary ? structuredClone(draft.summary) : null; },
+        async writeSummary({ text, throughTurnId }) {
+          if (typeof text !== "string" || !text.trim()) throw new TypeError("A conversation summary requires text.");
+          if (!turns().get(throughTurnId)) throw new Error("The conversation turn does not exist.");
+          draft.summary = { text, throughTurnId };
         },
         async appendMessage(id, { turnMetadata, ...message }) {
           const turn = ownTurn(id);
@@ -234,7 +267,7 @@ export function createConversationStorage({ readRecord, writeRecord, deleteRecor
       else {
         const record = draft.record();
         await writeRecord(id, record, draft.view);
-        const version = typeof recordVersion === "function" ? await recordVersion(id) : null;
+        const version = versioned ? await recordVersion(id) : null;
         if (version != null) cache.set(id, { version, record });
       }
       return result;
@@ -245,15 +278,23 @@ export function createConversationStorage({ readRecord, writeRecord, deleteRecor
     finally { if (pending.get(id) === settled) pending.delete(id); }
   }
 
+  async function read(scope, callback) {
+    const id = key(scope);
+    await pending.get(id);
+    return callback(transaction(await readSaved(id)).view);
+  }
+
+  async function deleteConversation(scope) {
+    await write(scope, async () => {}, true);
+  }
+
   return Object.freeze({
+
     write,
-    async read(scope, callback) {
-      const id = key(scope);
-      await pending.get(id);
-      return callback(transaction(await readSaved(id)).view);
-    },
-    async deleteConversation(scope) {
-      await write(scope, async () => {}, true);
-    }
+
+    read,
+
+    deleteConversation
+
   });
 }

package/src/server/conversation/streams.js

@@ -1,4 +1,7 @@
-/** Transient provider output. Applications own scope, admission and final persistence. */
+/**
+ * Transient provider output. Applications own scope, admission and final persistence.
+ * @param {{ clock?: () => Date }} [options]
+ */
 export function createConversationStreams({ clock = () => new Date() } = {}) {
   const streams = new Map();
   let revision = 0;
@@ -77,5 +80,15 @@ export function createConversationStreams({ clock = () => new Date() } = {}) {
     return read(scope);
   }
 
-  return { read, update, complete, clear };
+  return Object.freeze({
+
+    read,
+
+    update,
+
+    complete,
+
+    clear
+
+  });
 }

package/src/server/conversation/structuredOutput.js

@@ -1,23 +1,19 @@
+import { isPlainRecord } from "./normalize.js";
+
 const OUTPUT_SCHEMA_MAX_BYTES = 64 * 1024;
 const OUTPUT_SCHEMA_MAX_DEPTH = 8;
 const OUTPUT_SCHEMA_MAX_PROPERTIES = 64;
 const OUTPUT_SCHEMA_MAX_ENUM_VALUES = 64;
 const OUTPUT_SCHEMA_MAX_ALTERNATIVES = 64;
 
-function isPlainRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
+/** The refusal of an output schema whose host supplies no error policy of its own. */
+function outputSchemaTypeError(message, details) {
+  return Object.assign(new TypeError(message), { details });
 }
 
-// Original bounded native-helper schema contract. The host supplies its existing
+// The bounded schema contract of structured output. The host supplies its own
 // error policy; native and API process ownership is outside this validator.
-export function validateConversationOutputSchema(outputSchema, {
-  maxOutputCharacters,
-  createError = (message, details) => Object.assign(new TypeError(message), { details })
-} = {}) {
+export function validateConversationOutputSchema(outputSchema, { maxOutputCharacters, createError = outputSchemaTypeError }) {
   if (!Number.isSafeInteger(maxOutputCharacters) || maxOutputCharacters < 1) {
     throw new TypeError("Structured output requires a finite positive output limit.");
   }

package/src/server/conversation/systemPrompt.js

@@ -50,5 +50,17 @@ export function createConversationSystemPrompt() {
     return operation;
   }
 
-  return Object.freeze({ ensure, isCurrent, invalidate, whenIdle: () => pending });
+  const whenIdle = () => pending;
+
+  return Object.freeze({
+
+    ensure,
+
+    isCurrent,
+
+    invalidate,
+
+    whenIdle
+
+  });
 }

package/src/server/conversation/tools.js

@@ -2,15 +2,44 @@ import { isDeepStrictEqual } from "node:util";
 
 const unknownOutcome = "The application operation did not return a verified result. Inspect its target before requesting another execution.";
 
-/** One turn's application calls. Native/API adapters only transport these calls. */
-export function createConversationTools({ catalog, toolSet: retainedToolSet, context, prepareContext, signal: turnSignal, previousCalls = [], authorize, save, emit,
-  maximumCalls = 32, discoveryOnly = false, transient = false, propagateErrors = false }) {
-  if (transient !== true && [authorize, save, emit].some(hook => typeof hook !== "function")) {
+/** A transient tool set's admission check: it has no admission to recheck. */
+function authorizeTransientCall() {}
+
+/** A transient tool set's save: its calls live only in memory. */
+function saveTransientCalls() {}
+
+/** A transient tool set's announcement: it publishes no events. */
+function announceTransientCall() {}
+
+const TRANSIENT_HOOKS = new Set([authorizeTransientCall, saveTransientCalls, announceTransientCall]);
+
+/**
+ * One turn's application calls. Native/API adapters only transport these calls.
+ * @param {object} options
+ * @param {import("../types.js").ServiceToolCatalog} options.catalog
+ * @param {{ tools: object[] }} [options.toolSet] A tool set resolved earlier for this turn.
+ * @param {object} options.context The caller context the calls run as.
+ * @param {() => Promise<object>} [options.prepareContext] Maps the context again before each call.
+ * @param {AbortSignal} options.signal
+ * @param {object[]} [options.previousCalls] The calls this turn already recorded.
+ * @param {() => Promise<void> | void} [options.authorize] Rechecks admission; required unless the tool set is transient.
+ * @param {(calls: object[]) => Promise<void> | void} [options.save] Saves the turn's calls; required unless the tool set is transient.
+ * @param {(event: object) => Promise<void> | void} [options.emit] Announces a call; required unless the tool set is transient.
+ * @param {number} [options.maximumCalls]
+ * @param {boolean} [options.discoveryOnly]
+ * @param {boolean} [options.transient]
+ * @param {boolean} [options.propagateErrors]
+ */
+export function createConversationTools({ catalog, toolSet: retainedToolSet, context, prepareContext, signal: turnSignal, previousCalls = [],
+  authorize = authorizeTransientCall, save = saveTransientCalls, emit = announceTransientCall, maximumCalls = 32, discoveryOnly = false,
+  transient = false, propagateErrors = false }) {
+  if (transient !== true && [authorize, save, emit].some(hook => typeof hook !== "function" || TRANSIENT_HOOKS.has(hook))) {
     throw new TypeError("Conversation tools require authorization, durable save and event facilities.");
   }
   if (transient === true && previousCalls.length) {
     throw new TypeError("Transient application tools cannot restore a previous execution.");
   }
+  // readable-check: allow method-probe - input validation: an optional context mapper must be a function
   if (prepareContext !== undefined && typeof prepareContext !== "function") throw new TypeError("Application tool context requires a server-owned mapper.");
   const toolSet = retainedToolSet ?? catalog.resolveToolSet(context, { discoveryOnly });
   const calls = new Map(structuredClone(previousCalls).map(call => [call.id, call]));
@@ -27,7 +56,7 @@ export function createConversationTools({ catalog, toolSet: retainedToolSet, con
   }
 
   async function run({ id, name, arguments: argumentsText }, signal) {
-    await authorize?.();
+    await authorize();
     let executionContext = prepareContext ? await prepareContext() : context;
     signal.throwIfAborted();
     if (typeof id !== "string" || !id || id.length > 256 || typeof name !== "string" || !name || name.length > 256 ||
@@ -49,17 +78,17 @@ export function createConversationTools({ catalog, toolSet: retainedToolSet, con
     calls.set(id, call);
     // Canonical calls reserve durably before the effect. Explicit transient
     // calls retain the same once-only state only for their non-resumable lifetime.
-    try { await save?.([...calls.values()]); }
+    try { await save([...calls.values()]); }
     catch (error) { calls.delete(id); throw error; }
-    await emit?.({ type: "tool", call: structuredClone(call) });
+    await emit({ type: "tool", call: structuredClone(call) });
     try {
-      await authorize?.();
+      await authorize();
       if (prepareContext) executionContext = await prepareContext();
       signal.throwIfAborted();
     } catch (error) {
       call.status = "not-executed";
       call.result = { ok: false, error: { code: "conversation_tool_not_executed", message: "Execution stopped before the action began." } };
-      await save?.([...calls.values()]);
+      await save([...calls.values()]);
       throw error;
     }
     let failed = false;
@@ -69,8 +98,8 @@ export function createConversationTools({ catalog, toolSet: retainedToolSet, con
     call.status = !call.result.ok && call.result.error?.status >= 500 ? "unknown" : "complete";
     // Keep the result in memory as well: retrySave can persist it after a failed
     // write without executing the action again or repeating model inference.
-    await save?.([...calls.values()]);
-    await emit?.({ type: "tool", call: structuredClone(call) });
+    await save([...calls.values()]);
+    await emit({ type: "tool", call: structuredClone(call) });
     if (failed) throw failure;
     if (!call.result.ok && call.result.error?.status >= 500) {
       throw Object.assign(new Error(unknownOutcome), { code: "conversation_tool_outcome_unknown" });
@@ -78,10 +107,13 @@ export function createConversationTools({ catalog, toolSet: retainedToolSet, con
     return structuredClone(call.result);
   }
 
-  return {
+  const records = () => structuredClone([...calls.values()]);
+
+  return Object.freeze({
     descriptors: toolSet.tools,
-    schemas: toolSet.tools.map(catalog.toOpenAiToolSchema), execute,
+    schemas: toolSet.tools.map(catalog.toOpenAiToolSchema),
+    execute,
     maximumArgumentBytes: catalog.limits.maxToolArgumentBytes,
-    records: () => structuredClone([...calls.values()])
-  };
+    records
+  });
 }

package/src/server/conversation/transcript.js

@@ -1,17 +1,31 @@
 import { normalizeNullableText } from "./normalize.js";
 import { conversationLogPage } from "../../shared/conversation/pagination.js";
 
-/** Conversation policy, independent of database, filesystem, identity and HTTP. */
-export function createConversationTranscript({ storage, clock = () => new Date(), applicationTurns = false } = {}) {
+/** The time a transcript records when its owner supplies no clock. */
+function currentDate() {
+  return new Date();
+}
+
+/**
+ * Conversation policy, independent of database, filesystem, identity and HTTP.
+ * @param {object} options
+ * @param {import("../types.js").ConversationStorage} options.storage
+ * @param {() => Date} [options.clock]
+ * @param {boolean} [options.applicationTurns]
+ */
+export function createConversationTranscript({ storage, clock = currentDate, applicationTurns = false }) {
+  // readable-check: allow method-probe - input validation: the application's storage adapter must offer read and write
   if (typeof storage?.read !== "function" || typeof storage?.write !== "function") {
     throw new TypeError("Conversation storage requires read(scope, callback) and write(scope, callback).");
   }
 
-  async function readConversationLog(scope, { presentation = false } = {}) {
+  // With `afterTurnId`, only the turns after it (those a summary doesn't cover).
+  async function readConversationLog(scope, { presentation = false, afterTurnId = "" } = {}) {
     if (typeof presentation !== "boolean") throw new TypeError("Transcript presentation requires an explicit boolean.");
     return storage.read(scope, async (transaction) => {
-      const ids = await transaction.listTurnIds();
-      const turns = (await Promise.all(ids.map((id) => transaction.readTurn(id)))).filter(hasMessages);
+      const read = afterTurnId ? transaction.readTurnsAfter(afterTurnId)
+        : Promise.all((await transaction.listTurnIds()).map((id) => transaction.readTurn(id)));
+      const turns = (await read).filter(hasMessages);
       return presentation ? turns.filter(turn => !isCompletedEnvelopeTurn(turn)) : turns;
     });
   }
@@ -98,6 +112,7 @@ export function createConversationTranscript({ storage, clock = () => new Date()
     if (!id) return null;
     return storage.read(scope, async (transaction) => {
       const submitted = turn => hasMessages(turn) && (turn.user || turn.system)?.messageId === id ? turn : null;
+      // readable-check: allow method-probe - optional operation: a storage transaction may find a message's turn directly
       if (typeof transaction.findMessageTurnId === "function") {
         const turnId = await transaction.findMessageTurnId(id);
         if (!turnId) return null;
@@ -112,25 +127,39 @@ export function createConversationTranscript({ storage, clock = () => new Date()
     });
   }
 
+  const conversationMessageIdExists = (scope, messageId) => storage.read(scope, (transaction) => transaction.hasMessage(normalizeNullableText(messageId)));
+
+  const writeConversationUserMessage = (scope, input) => append(scope, "user", input);
+
+  const writeConversationAssistantMessage = (scope, input) => append(scope, "assistant", input);
+
+  const writeConversationCommentaryMessage = (scope, input) => append(scope, "commentary", input);
+
+  const writeConversationThinkingMessage = (scope, input) => append(scope, "thinking", input);
+
+  const writeConversationSystemMessage = (scope, input) => append(scope, "system", input);
+
+  async function upsertConversationAssistantMessage(scope, { turnId = "", text = "" } = {}) {
+    const messageText = normalizeNullableText(text);
+    if (!messageText) return null;
+    return storage.write(scope, async (transaction) => {
+      const id = normalizeNullableText(turnId);
+      await transaction.replaceAssistant(id, { role: "assistant", text: messageText, at: new Date(clock()).toISOString() });
+      return transaction.readTurn(id);
+    });
+  }
+
   return Object.freeze({
     readConversationLog,
     findSubmittedTurn,
     readConversationLogPage,
-    conversationMessageIdExists: (scope, messageId) => storage.read(scope, (transaction) => transaction.hasMessage(normalizeNullableText(messageId))),
-    writeConversationUserMessage: (scope, input) => append(scope, "user", input),
-    writeConversationAssistantMessage: (scope, input) => append(scope, "assistant", input),
-    writeConversationCommentaryMessage: (scope, input) => append(scope, "commentary", input),
-    writeConversationThinkingMessage: (scope, input) => append(scope, "thinking", input),
-    writeConversationSystemMessage: (scope, input) => append(scope, "system", input),
-    async upsertConversationAssistantMessage(scope, { turnId = "", text = "" } = {}) {
-      const messageText = normalizeNullableText(text);
-      if (!messageText) return null;
-      return storage.write(scope, async (transaction) => {
-        const id = normalizeNullableText(turnId);
-        await transaction.replaceAssistant(id, { role: "assistant", text: messageText, at: new Date(clock()).toISOString() });
-        return transaction.readTurn(id);
-      });
-    }
+    conversationMessageIdExists,
+    writeConversationUserMessage,
+    writeConversationAssistantMessage,
+    writeConversationCommentaryMessage,
+    writeConversationThinkingMessage,
+    writeConversationSystemMessage,
+    upsertConversationAssistantMessage
   });
 }
 

package/src/server/hosts/claudeTurn.js

@@ -1,4 +1,2 @@
-export {
-  createClaudeConversationOwner,
-  claudeNativeMessageId
-} from "../conversation/claudeTurn.js";
+export { createClaudeConversationOwner } from "../conversation/claudeTurn.js";
+export { claudeNativeMessageId } from "../conversation/claudeHistory.js";

package/src/server/hosts/codexConfiguration.js

@@ -5,21 +5,19 @@ export {
   codexInteractiveArguments,
   normalizeCodexThreadId,
   codexAppServerProjectHookTrustConfig,
-  codexAuthOutputRequiresReconnect,
-  codexProviderConfiguration,
-  codexProviderFileConfiguration,
-  codexProviderCatalogPath,
-  verifyCodexProviderKey,
   codexProviderModelCatalog,
   codexCatalogRows,
   codexCatalogReasoningEfforts,
   codexCatalogModels,
   codexConfiguredModelCatalog,
   readCodexModelContextWindow,
-  createCodexAccountReader,
-  createCodexAppServerIsolation,
-  readCodexToolFreeConfiguration
+  codexProviderConfiguration,
+  codexProviderFileConfiguration,
+  codexProviderCatalogPath,
+  verifyCodexProviderKey
 } from "../conversation/codexConfiguration.js";
+export { codexAuthOutputRequiresReconnect, createCodexAccountReader } from "../conversation/codexAccountReader.js";
+export { createCodexAppServerIsolation, readCodexToolFreeConfiguration } from "../conversation/codexIsolation.js";
 export {
   codexDisabledProcessFeatureArguments,
   codexHomeDisposablePaths

package/src/server/hosts/codexEvents.js

@@ -19,10 +19,12 @@ export {
   codexAppServerNotificationEvent,
   codexAppServerNotificationItemId,
   codexAppServerNotificationTurnId,
-  codexAppServerProviderThreadAssistantSegments,
+  codexAppServerProviderThreadAssistantSegments
+} from "../conversation/codexEvents.js";
+export {
   codexAppServerProviderThreadTurns,
   codexAppServerProviderTurnForOperation,
   codexAppServerProviderTurnId,
   codexAppServerThreadError,
   codexAppServerThreadTurnId
-} from "../conversation/codexEvents.js";
+} from "../conversation/codexThreadSnapshot.js";

package/src/server/hosts/codexProcess.js

@@ -6,7 +6,7 @@ export {
   codexAppServerHelperHomeDir,
   codexAppServerHelperWorkspaceDir,
   codexAppServerIsHelper,
-  createCodexAppServerRuntime,
   normalizeCodexAppServerTerminalEnv,
   runCodexAppServerProcess
 } from "../conversation/codexProcess.js";
+export { createCodexAppServerRuntime } from "../conversation/codexRuntime.js";

package/src/server/hosts/codexProvider.js

@@ -1,22 +1,24 @@
 export {
   CODEX_APP_SERVER_INVALID_REQUEST_CODE,
-  CodexAppServerAgentProvider,
-  codexAppServerEndpointForTarget,
   codexAppServerRequestIsInvalid,
-  codexAppServerRuntimeStopWasVerified,
-  codexCliResumeCommand,
-  codexTextInput,
-  codexTurnInput,
-  createCodexAppServerProviderOwner,
   deleteCodexAppServerHelperThread,
   deleteCodexAppServerThread,
   ensureCodexAppServerThread,
   inspectCodexAppServerMessageAdmission,
   retireCodexConversationHistory,
-  readCodexNativeGoal,
+  readCodexNativeGoal
+} from "../conversation/codexProviderThreads.js";
+export { CodexAppServerAgentProvider } from "../conversation/codexProvider.js";
+export {
+  codexAppServerEndpointForTarget,
+  codexCliResumeCommand,
+  codexTextInput,
+  codexTurnInput,
   sendCodexAppServerPrompt,
   shellQuote
-} from "../conversation/codexProvider.js";
+} from "../conversation/codexProviderTurns.js";
+export { codexAppServerRuntimeStopWasVerified } from "../conversation/codexRuntimeInventory.js";
+export { createCodexAppServerProviderOwner } from "../conversation/codexProviderOwner.js";
 export { assertCodexAuthPreflightReady } from "../conversation/codexAuthPreflight.js";
 export {
   codexRenewalThreadError,

package/src/server/hosts/codexTurn.js

@@ -20,6 +20,6 @@ export {
 
 export {
   CODEX_HELPER_THREAD_LEDGER_SCHEMA_VERSION,
-  CODEX_HELPER_THREAD_LIFECYCLES,
-  createCodexHelperThreadLedgerOwner
-} from "../conversation/codexHelperThreadLedger.js";
+  CODEX_HELPER_THREAD_LIFECYCLES
+} from "../conversation/codexHelperThreadRecord.js";
+export { createCodexHelperThreadLedgerOwner } from "../conversation/codexHelperThreadLedger.js";

package/src/server/hosts/openCodeClient.js

@@ -2,7 +2,9 @@ export {
   OPENCODE_RESPONSE_LIMIT_BYTES,
   createOpenCodeServerClient,
   openCodeAssistantMessageText,
-  readBoundedResponse,
+  readBoundedResponse
+} from "../conversation/openCodeClient.js";
+export {
   readOpenCodeConversationDatabase,
   retireOpenCodeConversationHistory
-} from "../conversation/openCodeClient.js";
+} from "../conversation/openCodeNativeHistory.js";

package/src/server/index.js

@@ -14,6 +14,4 @@ export {
 } from "./lib/ndjson.js";
 export { resolveWorkspaceSlug } from "./lib/resolveWorkspaceSlug.js";
 export { createServiceToolCatalog } from "./lib/serviceToolCatalog.js";
-export { consumeCompletionStream, sanitizeAssistantMessageText } from "./lib/assistantCompletion.js";
-export { runAssistantToolLoop } from "./lib/assistantToolLoop.js";
 export { runBoundedAssistantToolLoop, readAssistantResponseEnvelope, readPartialAssistantReply } from "./conversation/boundedToolLoop.js";