@jskit-ai/assistant-core 0.2.7 → 0.2.8

package/test/codexConversationSession.test.js

@@ -1498,11 +1498,11 @@ test("concurrent final common-runtime closes stop the shared Codex service once"
 
 for (const loseFirst of [true, false]) test(`shared Codex fallback records both common-runtime barriers before stop (first: ${loseFirst})`, async t => {
   const providers = new Map();
-  const startThread = CodexAppServerAgentProvider.prototype.startThread;
-  t.mock.method(CodexAppServerAgentProvider.prototype, "startThread", async function (...args) {
-    const thread = await startThread.apply(this, args);
-    providers.set(thread.id, this);
-    return thread;
+  const runRequest = CodexAppServerAgentProvider.prototype.runRequest;
+  t.mock.method(CodexAppServerAgentProvider.prototype, "runRequest", async function (operation, reason) {
+    const result = await runRequest.call(this, operation, reason);
+    if (reason === "codex-app-server-thread-start") providers.set(result.thread.id, this);
+    return result;
   });
   const execution = createLocalConversationExecution();
   const barriers = [];
@@ -1654,10 +1654,10 @@ for (const stage of ["preparation", "completion"]) test(`account invalidation re
 test("failed stopped-state persistence retains Codex recovery across reopening without starting work", async t => {
   let source;
   let rejectStopped = false;
-  const startThread = CodexAppServerAgentProvider.prototype.startThread;
-  t.mock.method(CodexAppServerAgentProvider.prototype, "startThread", async function (...args) {
-    source = this;
-    return startThread.apply(this, args);
+  const runRequest = CodexAppServerAgentProvider.prototype.runRequest;
+  t.mock.method(CodexAppServerAgentProvider.prototype, "runRequest", async function (operation, reason) {
+    if (reason === "codex-app-server-thread-start") source = this;
+    return runRequest.call(this, operation, reason);
   });
   const f = await fixture(t, { checkpoints: true, storage: disk => ({
     read: disk.read,
@@ -1858,7 +1858,7 @@ function applicationActions(execute) {
   const actions = createActionCatalogue();
   actions.register({ contributorId: "test.tools", domain: "numbers", actions: [{
     id: "numbers.read", version: 1, kind: "query", channels: ["automation"], surfaces: ["app"],
-    permission: { require: "all", permissions: ["numbers.read"] }, idempotency: "none",
+    permission: { require: "all", permissions: ["numbers.read"] },
     input: { schema: createSchema({}), mode: "replace" },
     output: { schema: createSchema({ value: { type: "number", required: true } }), mode: "replace" }, execute
   }] });
@@ -2344,7 +2344,7 @@ test("Codex retries retain their frozen local file manifest and cannot retarget
 test("Codex goal controls reject local attachments before native work", async t => {
   const f = await fixture(t, { attachments: { resolve: nativeAttachmentResolver } });
   await assert.rejects(f.conversation.updateGoal({ action: "set", messageId: "local-goal", objective: "Inspect the files",
-    attachmentIds: ["image", "file"], expectedSegmentId: (await f.conversation.read()).segmentId }), { code: "conversation_unsupported" });
+    attachmentIds: ["image", "file"], expectedSegmentId: (await f.conversation.read()).segmentId }), { code: "conversation_goal_attachments_unsupported" });
   assert.equal((await f.conversation.read()).conversationLog.length, 0);
   await assert.rejects(readFile(path.join(f.directory, "trace.jsonl")), { code: "ENOENT" });
 });
@@ -2464,6 +2464,7 @@ test("held lifecycle catalogue work does not block another owner's runtime stop
   }) });
   const acquiredProvider = other.createProvider({ providerKey: "b-acquire", providerOptions: acquireOptions, create: () => ({
     async ensureRuntime() { events.push("b-acquire"); return {}; },
+    ensureAvailable() { return this.ensureRuntime(); },
     async stopRuntime() { return { stopped: true }; }, close() {}
   }) });
   const catalogue = first.readModelCatalog({ prepareProviderOptions: async () => firstOptions,
@@ -2667,19 +2668,19 @@ test("held lifecycle catalogue rejection preserves a newer same-runtime tail and
   }
 });
 
-// Bound-host contract additions retain the original native app-server fixture,
-// schemas, tool-call framing, transcript store and run owner. Public Main's
-// identity/authority/readiness composition is a separate adoption prerequisite.
+// The bound-host contract on the native app-server fixture: schemas, tool-call
+// framing, transcript store and run owner. Identity, authority and readiness
+// composition belongs to the bound application.
 import { createCodexAppServerRunOwner, codexAppServerTurnState } from "../src/server/conversation/codexTurn.js";
-import { codexApplicationToolConfiguration, ensureCodexAppServerThread } from "../src/server/conversation/codexProvider.js";
+import { codexApplicationToolConfiguration, ensureCodexAppServerThread } from "../src/server/conversation/codexProviderThreads.js";
 import { createServiceToolCatalog } from "../src/server/lib/serviceToolCatalog.js";
 
 async function boundCodexToolsFixture(t, options = {}) {
   let sharedProvider;
-  const startThread = CodexAppServerAgentProvider.prototype.startThread;
-  t.mock.method(CodexAppServerAgentProvider.prototype, "startThread", async function (...args) {
-    sharedProvider ||= this;
-    return startThread.apply(this, args);
+  const runRequest = CodexAppServerAgentProvider.prototype.runRequest;
+  t.mock.method(CodexAppServerAgentProvider.prototype, "runRequest", async function (operation, reason) {
+    if (reason === "codex-app-server-thread-start") sharedProvider ||= this;
+    return runRequest.call(this, operation, reason);
   });
   const cleanups = [];
   let boundRuntime, owner;
@@ -2886,7 +2887,7 @@ test("bound Codex refuses stale turns, foreign threads and retired handlers with
 });
 
 test("shared Codex thread registrations retain ownership tokens and Helper request precedence", async t => {
-  const provider = new CodexAppServerAgentProvider();
+  const provider = new CodexAppServerAgentProvider({}, {});
   const calls = [];
   let originalClientRequest;
   provider.client = { setRequestHandler(callback) { originalClientRequest = callback; }, close() {} };
@@ -3259,7 +3260,7 @@ for (const ending of ["steer", "close"]) test(`transient native completion decli
     const closing = runtime.close();
     releaseAuthorization.resolve();
     await closing;
-    await assert.rejects(conversation.read(), { code: "conversation_closed" });
+    await assert.rejects(conversation.read(), { code: "conversation_handle_closed" });
   }
   assert.equal(events.some(event => event.type === "message" && event.status === "complete" &&
     event.role === "commentary" && event.text === "Checking the numbers."), false,

package/test/codexEvents.test.js

@@ -1,6 +1,8 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { codexAppServerNotificationError, codexAppServerProviderThreadAssistantSegments, codexAppServerProviderTurnError } from "../src/server/conversation/codexEvents.js";
+import { codexAppServerNotificationError } from "../src/server/conversation/codexEvents.js";
+import { codexAppServerProviderThreadAssistantSegments } from "../src/server/conversation/codexThreadSnapshot.js";
+import { codexAppServerProviderTurnError } from "../src/server/conversation/codexThreadSnapshot.js";
 
 test("phase-less Codex progress before tools does not become a final answer", () => {
   const items = [

package/test/codexHelperDeletion.test.js

@@ -1,17 +1,13 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import {
-  codexAppServerThreadHasReadableHistory,
-  deleteCodexAppServerThread,
-  deleteCodexAppServerHelperThread
-} from "../src/server/conversation/codexProvider.js";
+import { codexAppServerThreadHasReadableHistory, deleteCodexAppServerThread, deleteCodexAppServerHelperThread } from "../src/server/conversation/codexProviderThreads.js";
 
 function invalidRequest(method) {
   return Object.assign(new Error(`${method} rejected`), { code: -32600, method });
 }
 
-// The original Public lifecycle tests retain durable receipts, authority and
-// retry assertions. These cases cover the native protocol branch moved here.
+// These cases cover the native protocol branch of helper deletion; durable
+// receipts, authority and retries belong to the application's lifecycle tests.
 test("Helper deletion awaits the exact active-turn interruption before confirming deletion", async () => {
   const calls = [];
   const started = Promise.withResolvers();

package/test/codexIsolation.test.js

@@ -4,10 +4,10 @@ import {
   createCodexAppServerIsolation,
   codexToolFreeConfiguration,
   readCodexToolFreeConfiguration
-} from "../src/server/conversation/codexConfiguration.js";
+} from "../src/server/conversation/codexIsolation.js";
 
-// Carried from the original public helper bridge tests. Public profile, schema,
-// prompt and request-settings assertions remain in that unchanged test file.
+// Helper isolation at the native boundary. Profile, schema, prompt and
+// request-settings assertions belong to the application's helper tests.
 const MINIMUM_CODEX_VERSION = "0.151.0";
 const POLICY_UNENFORCEABLE = "codex_policy_unenforceable";
 const HELPER_DISABLED_FEATURES = Object.freeze([
@@ -104,8 +104,8 @@ function helperInventoryProvider({
   };
 }
 
-// The original application's prepare callback now supplies already authorized
-// policy values. These fixtures exercise only the native ownership boundary.
+// The application's prepare callback supplies already authorized policy
+// values. These fixtures exercise only the native ownership boundary.
 async function prepareHelper({ provider }) {
   const enforcement = await isolation.inspect(provider, { effort: "low", summary: "none" });
   return { enforcement, settings: { config: enforcement.config, cwd: enforcement.executionCwd } };
@@ -557,7 +557,7 @@ test("Codex helper safely reapplies isolation when resuming a controller-owned t
   assert.equal(calls.some(([method]) => method === "deleteThread"), false);
 });
 
-// Supplementary ownership-boundary checks, alongside the original assertions.
+// Ownership-boundary checks.
 test("helper inventory rejects a reconnect at either sequential read boundary", async () => {
   for (const changedAt of ["readConfig", "listHooks"]) {
     const provider = helperInventoryProvider();

package/test/codexModelCatalog.test.js

@@ -111,8 +111,8 @@ function liveCatalogFixture() {
   return { calls, captures, provider, readCatalog };
 }
 
-// These two cases carry the original public lifecycle assertions. Their public
-// counterparts retain host acquisition, restoration and application integration.
+// Helper model discovery per connection generation. Host acquisition,
+// restoration and application integration belong to the application's tests.
 test("helper model discovery uses one live provider catalog per connection generation", async () => {
   const { calls, provider, readCatalog } = liveCatalogFixture();
   const first = await readCatalog(provider);
@@ -217,10 +217,10 @@ test("invalid and unavailable native catalogs retain the host's error prefix wit
 
 test("native connection generation keeps the production method priority and falsy normalization", () => {
   assert.equal(codexAppServerProviderConnectionGeneration({ currentConnectionGeneration: () => " first ", connectionGeneration: "second" }), "first");
-  assert.equal(codexAppServerProviderConnectionGeneration({ connectionGeneration: () => 2 }), "2");
-  assert.equal(codexAppServerProviderConnectionGeneration({ connectionGeneration: " direct " }), "direct");
+  assert.equal(codexAppServerProviderConnectionGeneration({ currentConnectionGeneration: () => 2, connectionGeneration: () => 2 }), "2");
+  assert.equal(codexAppServerProviderConnectionGeneration({ currentConnectionGeneration: () => " direct ", connectionGeneration: " direct " }), "direct");
   for (const value of [0, false, null, undefined]) {
-    assert.equal(codexAppServerProviderConnectionGeneration({ connectionGeneration: value }), "");
+    assert.equal(codexAppServerProviderConnectionGeneration({ currentConnectionGeneration: () => value, connectionGeneration: value }), "");
   }
 });
 
@@ -281,8 +281,7 @@ function chatCatalogFixture(t, { resources = null } = {}) {
   return { owner, captures, readCatalog, retainProvider };
 }
 
-// Carried from the original public chat catalog tests. Only the application
-// controller fixture becomes the existing native provider owner.
+// Chat model discovery through a native provider owner.
 test("chat model discovery reuses a resident provider without closing it", async t => {
   const { captures, readCatalog, retainProvider } = chatCatalogFixture(t);
   await retainProvider();

package/test/codexProcess.test.js

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { test } from "node:test";
 import { assertCodexAuthPreflightReady } from "../src/server/conversation/codexAuthPreflight.js";
-import { createCodexAppServerRuntime } from "../src/server/conversation/codexProcess.js";
+import { createCodexAppServerRuntime } from "../src/server/conversation/codexRuntime.js";
 
 /** Starts a runtime whose execution host records the launch and reports failure. */
 async function launchRequest(t, configuration, executionMode = "interactive") {
@@ -21,7 +21,7 @@ async function launchRequest(t, configuration, executionMode = "interactive") {
       }
     }
   });
-  await assert.rejects(runtime.start({ codexCommand: process.execPath, executionMode, runtimeDir }), /recorded launch/);
+  await assert.rejects(runtime.start({ codexCommand: process.execPath, env: process.env, executionMode, runtimeDir }), /recorded launch/);
   return request;
 }
 
@@ -65,7 +65,7 @@ test("a non-octal umask is refused before it reaches the startup script", () =>
 test("the Codex sign-in check names itself to the execution host", async () => {
   let request;
   const execution = { async run(value) { request = value; return { ok: true, exitCode: 0, output: "{}" }; } };
-  await assertCodexAuthPreflightReady({ codexCommand: process.execPath }, { execution });
+  await assertCodexAuthPreflightReady({ codexCommand: process.execPath, env: process.env }, { execution });
   assert.equal(request.mode, "capture");
   assert.deepEqual(request.args.slice(-2), ["debug", "models"]);
   assert.deepEqual(request.execution, { label: "Checking the Codex sign-in", operationId: "codex-auth-preflight" });

package/test/codexThreadSelection.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { ensureCodexAppServerThread } from "../src/server/conversation/codexProvider.js";
+import { ensureCodexAppServerThread } from "../src/server/conversation/codexProviderThreads.js";
 
 test("retained Codex selection awaits observation before resume and identity publication before return", async () => {
   const calls = [];
@@ -67,6 +67,7 @@ test("selection failures preserve the original error and never fall back to a ne
     };
     await assert.rejects(ensureCodexAppServerThread({
       provider: {
+        async ensureAvailable() { return {}; },
         async ensureRuntime() { step("runtime"); return {}; },
         async readGoal() { step("goal"); return { goal: { status: "active" } }; },
         async setGoalStatus() { step("pause"); },
@@ -93,6 +94,7 @@ test("new selection starts once and rejects a missing native ID before publishin
     const settings = { model: "selected-model", sessionStartSource: "startup" };
     const selecting = ensureCodexAppServerThread({
       provider: {
+        async ensureAvailable() { return {}; },
         async ensureRuntime() { calls.push("runtime"); return {}; },
         async startThread(input) { calls.push("start"); assert.equal(input, settings); return { id }; },
         async resumeThread() { assert.fail("There is no saved thread to resume"); },
@@ -117,6 +119,7 @@ test("selection reads the saved pause marker again after resume and retains the
   let written;
   const selected = await ensureCodexAppServerThread({
     provider: {
+      async ensureAvailable() { return {}; },
       async ensureRuntime() { return {}; },
       async readGoal() { return { goal: { status: "paused" } }; },
       async setGoalStatus() { assert.fail("An already paused goal stays paused"); },

package/test/codexTurn.test.js

@@ -7,7 +7,8 @@ import test from "node:test";
 import { createMemoryConversationStorage } from "../src/server/conversation/memoryStorage.js";
 import { createConversationTranscript } from "../src/server/conversation/transcript.js";
 import { createConversationStreams } from "../src/server/conversation/streams.js";
-import { sendCodexAppServerPrompt, CodexAppServerAgentProvider, codexAppServerDeliveredTurn } from "../src/server/conversation/codexProvider.js";
+import { sendCodexAppServerPrompt, codexAppServerDeliveredTurn } from "../src/server/conversation/codexProviderTurns.js";
+import { CodexAppServerAgentProvider } from "../src/server/conversation/codexProvider.js";
 import { createCodexHelperThreadLedgerOwner } from "../src/server/conversation/codexHelperThreadLedger.js";
 import { createCodexSessionReconciliation } from "../src/server/conversation/codexSessionReconciliation.js";
 import { createCodexSessionCleanup } from "../src/server/conversation/codexSessionCleanup.js";
@@ -21,7 +22,7 @@ import {
   CODEX_APP_SERVER_RUN_STATE
 } from "../src/server/conversation/codexTurn.js";
 
-// Original stable-outer-turn source assertions follow their native owners.
+// A new chat turn claims its client message id through the run journal, which keeps the outer turn id.
 test("a new chat turn claims its client message id and preserves the stable outer identity", async () => {
   const messageSource = await readFile(new URL(
     "../src/server/conversation/codexMessageCommands.js", import.meta.url
@@ -34,9 +35,9 @@ test("a new chat turn claims its client message id and preserves the stable oute
   assert.match(journalSource, /outerTurnId: normalizedOuterTurnId/u);
 });
 
-// The original public renewal tests retain the application retry, accepted
-// handover, saved identity and structured acknowledgement assertions. These
-// cases exercise the native wait sequence carried from that implementation.
+// These cases exercise the native renewal wait sequence. Application retry,
+// accepted handover, saved identity and structured acknowledgement belong to
+// the application's renewal tests.
 function turn(id = "turn-1", status = "inProgress", text = "") {
   return {
     id,
@@ -342,7 +343,7 @@ function runFixture(initial = {}) {
 test("native run claims retain the original lock/read/write/read sequence and clear former goal ownership", async () => {
   const f = runFixture({ state: "completed", providerGoalStatus: "active", providerGoalThreadId: "old-thread",
     providerGoalUpdatedAt: "old-goal-time", pendingUserMessageClientIds: ["old-message"] });
-  const owner = createCodexAppServerRunOwner();
+  const owner = createCodexAppServerRunOwner({});
   const result = await owner.claimTurnStart(f.runtime, " session-1 ", " request-2 ");
   assert.equal(result.claimed, true);
   const run = result.session.agentRuns[0];
@@ -362,7 +363,7 @@ test("native run claims retain the original lock/read/write/read sequence and cl
 
 test("the moved native run guard preserves Stop when an earlier provider read resolves", async () => {
   const f = runFixture();
-  const owner = createCodexAppServerRunOwner();
+  const owner = createCodexAppServerRunOwner({});
   const observedRun = f.read();
   await owner.writeAgentRun(f.runtime, "session-1", { runState: CODEX_APP_SERVER_RUN_STATE.INTERRUPTED,
     status: "interrupted", threadId: "thread-1", turnId: "turn-1", publishReason: "codex-app-server-turn-interrupted" });
@@ -386,7 +387,7 @@ test("native recovery requires the exact stopped revision and keeps its original
   for (const state of ["failed", "interrupted"]) {
     const f = runFixture({ state, providerStatus: state });
     const observedRun = f.read();
-    const result = await createCodexAppServerRunOwner().writeAgentRun(f.runtime, "session-1", { observedRun,
+    const result = await createCodexAppServerRunOwner({}).writeAgentRun(f.runtime, "session-1", { observedRun,
       runState: CODEX_APP_SERVER_RUN_STATE.ACTIVE, status: "inProgress", threadId: "thread-1", turnId: "turn-1",
       updatedAt: "2026-10-01T01:00:00.000Z" });
     assert.equal(result.wrote, true);
@@ -422,7 +423,7 @@ test("durable processed results and observation loss prevent revival of an exact
 
 test("native phase changes require the current exact turn and retain its active start", async () => {
   const f = runFixture({ providerPhase: "reasoning" });
-  const owner = createCodexAppServerRunOwner();
+  const owner = createCodexAppServerRunOwner({});
   for (const turnId of ["", "foreign-turn"]) {
     assert.equal((await owner.writeAgentRun(f.runtime, "session-1", { phase: "compacting",
       runState: CODEX_APP_SERVER_RUN_STATE.ACTIVE, status: "inProgress", threadId: "thread-1", turnId })).wrote, false);
@@ -437,7 +438,7 @@ test("native phase changes require the current exact turn and retain its active
 test("a settling write for a predecessor turn cannot end the active successor run", async () => {
   for (const state of ["active", "finalizing", "starting"]) {
     const f = runFixture({ state, providerTurnId: "successor" });
-    const owner = createCodexAppServerRunOwner();
+    const owner = createCodexAppServerRunOwner({});
     const successor = f.read();
     for (const runState of [CODEX_APP_SERVER_RUN_STATE.COMPLETED, CODEX_APP_SERVER_RUN_STATE.FAILED,
       CODEX_APP_SERVER_RUN_STATE.INTERRUPTED]) {
@@ -540,7 +541,7 @@ test("the run owner's session closures are the ones its runtime lifecycle drains
 });
 
 test("the run owner exposes only operations its consumers use, not facet recovery state", () => {
-  const owner = createCodexAppServerRunOwner();
+  const owner = createCodexAppServerRunOwner({});
   for (const internal of ["completedTurns", "automaticHookThreads", "conversationTurnStarts", "reasoningPersistQueues",
     "threadReconciliations", "reasoningTurns", "finalAssistantResults", "mirroredTerminalItems", "clearActiveTimer",
     "clearFinalizingTimer", "adoptSuccessorTurn", "markTurnActive", "markTurnFinalizing", "checkManagedConnection"]) {
@@ -770,7 +771,9 @@ async function outputFixture({ persistCommentary } = {}) {
         nextCursor: offset + 1 < f.history.length ? String(offset + 1) : null };
     },
     async resumeThread() { throw new Error("History recovery must not resume native work"); },
-    async startTurn() { throw new Error("History reads must not resend the prompt"); }
+    async startTurn() { throw new Error("History reads must not resend the prompt"); },
+    isControlProbeTurn: () => false,
+    interruptionOutcome: () => ""
   };
   f.store = store;
   f.provider = provider;
@@ -1486,11 +1489,12 @@ test("original goal command preserves a failed cancellation for retry without re
   assert.equal(f.publications.length, 0);
 });
 
-// Original start/steer assertions retain the public admission and Git fixtures.
-// These bounded cases cover only the moved dispatch/receipt boundary and the
-// ownership adaptations: supplied settings, Error identity and result projection.
+// These bounded cases cover the dispatch and receipt boundary: supplied
+// settings, Error identity and result projection. Admission and Git fixtures
+// belong to the application's start and steer tests.
 function commandThreadFixture(f, providerAlreadyAvailable) {
   Object.assign(f.provider, {
+    async ensureAvailable() { return {}; },
     async ensureRuntime() { return {}; },
     async resumeThread(threadId) { return { id: threadId }; }
   });
@@ -1719,7 +1723,8 @@ test("original dispatch start waits for a persisted receipt and ignores its late
   const receipt = Promise.withResolvers();
   f.run = { ...f.run, state: "starting", providerTurnId: "", outerTurnId: messageId };
   f.owner.pendingUserMessages.set(`${context.promptDeliveryKey}\0${messageId}`, {
-    text: context.displayMessage, turnMetadata: context.turnMetadata, receipt
+    text: context.displayMessage, turnMetadata: context.turnMetadata, receipt,
+    onNativeReceipt() {}, onReceiptPersisted() {}
   });
   let rpcReplies = 0;
   let returned = false;
@@ -1804,7 +1809,8 @@ test("original dispatch steering persists the authored receipt while its exact n
   const acknowledgement = Promise.withResolvers();
   f.owner.pendingUserMessages.set(`${context.promptDeliveryKey}\0${context.messageId}`, {
     text: context.displayMessage, turnMetadata: context.turnMetadata,
-    attachments: [{ id: "diagram", name: "Diagram" }], receipt
+    attachments: [{ id: "diagram", name: "Diagram" }], receipt,
+    onNativeReceipt() {}, onReceiptPersisted() {}
   });
   let rpcReplies = 0;
   f.provider.steerTurn = async (threadId, turnId, input, params) => {
@@ -2204,7 +2210,8 @@ test("original authorized input supports an attachment-only receipt through the
   const acknowledgement = Promise.withResolvers();
   f.run = { ...f.run, state: "starting", providerTurnId: "" };
   f.owner.pendingUserMessages.set(`${context.promptDeliveryKey}\0${context.messageId}`, {
-    text: "", attachments, turnMetadata: context.turnMetadata, receipt
+    text: "", attachments, turnMetadata: context.turnMetadata, receipt,
+    onNativeReceipt() {}, onReceiptPersisted() {}
   });
   f.provider.sendTurn = async (threadId, input, params) => {
     assert.equal(threadId, f.threadId);
@@ -3124,7 +3131,8 @@ test("native receipt keeps admitted application data with the original authored
   f.run = { ...f.run, state: "starting", providerTurnId: "", pendingUserMessageClientIds: [messageId] };
   const receipt = Promise.withResolvers();
   f.owner.pendingUserMessages.set(`project:${f.sessionId}\0${messageId}`, {
-    text: "These are my actual words.", attachments: [], authoredInput: { messageId, data }, receipt
+    text: "These are my actual words.", attachments: [], authoredInput: { messageId, data }, receipt,
+    onNativeReceipt() {}, onReceiptPersisted() {}
   });
   f.observe();
   f.emit(f.receipt(messageId, "Prepared model context must not replace authored words"));
@@ -3169,7 +3177,8 @@ test("native receipt does not borrow application data from another authored iden
   const receipt = Promise.withResolvers();
   f.owner.pendingUserMessages.set(`project:${f.sessionId}\0${messageId}`, {
     text: "Unassociated actual words.", attachments: [],
-    authoredInput: { messageId: "other-message", data: { association: "foreign" } }, receipt
+    authoredInput: { messageId: "other-message", data: { association: "foreign" } }, receipt,
+    onNativeReceipt() {}, onReceiptPersisted() {}
   });
   f.observe();
   f.emit(f.receipt(messageId));

package/test/conversationApiFacilities.test.js

@@ -3,6 +3,7 @@ import test from "node:test";
 import { mkdtemp, readFile, readdir, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { createConversationRuntime, createFileConversationStorage, createMemoryConversationStorage } from "../src/server/conversation/index.js";
 
 test("API configuration rejects unsupported structured output before resolving an account or sending", async t => {
@@ -36,13 +37,13 @@ test("an existing API client keeps opaque receipts path-safe and selected histor
     apiClientFactory: { resolveClient({ context: actor, configuration }) {
       assert.equal(actor, context);
       assert.equal(configuration.integrationId, undefined, "Existing environment clients need no fabricated integration ID");
-      return { enabled: true, defaultModel: "existing-model", async createChatCompletionStream(input) {
-        requests.push(structuredClone(input.messages));
-        return (async function* () {
-          yield { choices: [{ delta: { content: " A complete answer. " } }] };
-          yield { choices: [{ delta: {}, finish_reason: "stop" }] };
-        })();
-      } };
+      // An existing client supplies its AI SDK model; this one speaks the OpenAI chat format.
+      return { enabled: true, defaultModel: "existing-model", model: createOpenAICompatible({ name: "existing", baseURL: "http://test.invalid/v1",
+        fetch: async (_url, request) => {
+          requests.push(JSON.parse(request.body).messages);
+          return new Response(`data: ${JSON.stringify({ choices: [{ index: 0, delta: { content: " A complete answer. " } }] })}\n\n` +
+            `data: ${JSON.stringify({ choices: [{ index: 0, delta: {}, finish_reason: "stop" }] })}\n\n`, { headers: { "content-type": "text/event-stream" } });
+        } })("existing-model") };
     } },
     attachments: { async resolve({ attachmentIds, context: actor, conversationId }) {
       assert.equal(actor, context);
@@ -59,7 +60,7 @@ test("an existing API client keeps opaque receipts path-safe and selected histor
   assert.equal((await conversation.send({ messageId, text: "Current question", attachmentIds: ["current"] })).messageId, messageId);
   const first = await conversation.wait();
   assert.equal(first.conversationLog[0].user.messageId, messageId);
-  assert.equal(first.conversationLog[0].assistant.text, " A complete answer. ", "The default API whitespace policy stays unchanged");
+  assert.equal(first.conversationLog[0].assistant.text, "A complete answer.", "The engine's reply has no whitespace at its ends");
   assert.deepEqual(resolvedAttachments, [["current"], ["historical"]]);
   assert.deepEqual(requests[0][1], { role: "user", content: [
     { type: "text", text: "Selected prior context" }, { type: "text", text: "Authorized historical bytes" }
@@ -83,7 +84,8 @@ test("an existing API client keeps opaque receipts path-safe and selected histor
   context.history = [];
   await conversation.send({ messageId: "empty-context", text: "No prior model context" });
   const last = await conversation.wait();
-  assert.deepEqual(requests[2].map(message => message.content), ["Existing instructions", "No prior model context"]);
+  assert.match(requests[2][0].content, /^Existing instructions\n\nCurrent state, from the system\./u);
+  assert.deepEqual(requests[2].slice(1).map(message => message.content), ["No prior model context"]);
   assert.equal(last.conversationLog.length, 3, "Explicitly empty model context never removes saved conversation history");
   await assert.rejects(conversation.send({ messageId: "x".repeat(129), text: "Must not dispatch" }), { code: "conversation_invalid_message" });
   assert.equal(requests.length, 3);

package/test/conversationAttachments.test.js

@@ -2,7 +2,7 @@ import { useAssistantAttachments } from "../src/client/conversation/useAssistant
 import assert from "node:assert/strict";
 import test from "node:test";
 import { createConversationRuntime, createMemoryConversationStorage } from "../src/server/conversation/index.js";
-import { codexLocalImageInput, codexTurnInput } from "../src/server/conversation/codexProvider.js";
+import { codexLocalImageInput, codexTurnInput } from "../src/server/conversation/codexProviderTurns.js";
 import { conversationAttachmentIds, createConversationAttachmentReader } from "../src/server/conversation/attachments.js";
 import { attachmentIdsField } from "../src/shared/index.js";
 import { ASSISTANT_ATTACHMENT_MAX_ITEMS as CLIENT_ATTACHMENT_MAX_ITEMS } from "../src/client/conversation/useAssistantAttachments.js";
@@ -154,7 +154,7 @@ test("authorized image bytes reach the API once and only safe receipts enter sto
   assert.doesNotMatch(JSON.stringify(state), /privatePath|private\/upload|iVBOR/);
   assert.equal((await f.conversation.send(input)).duplicate, true);
   assert.equal(f.reads.length, 1, "An accepted retry returns its receipt without rereading files or resending");
-  await assert.rejects(f.conversation.send({ ...input, attachmentIds: ["different"] }), { code: "conversation_message_conflict" });
+  await assert.rejects(f.conversation.send({ ...input, attachmentIds: ["different"] }), { code: "conversation_message_id_content_conflict" });
 });
 
 test("API history and continuity reauthorize files after reopen and renewal", async t => {
@@ -214,7 +214,7 @@ test("invalid IDs and caller-supplied attachment content do not reach the resolv
   for (const attachmentIds of [null, "picture", [""], ["picture", "picture"], [{}], Array.from({ length: 11 }, (_, i) => String(i))]) {
     await assert.rejects(f.conversation.send({ ...input, attachmentIds }), { code: "conversation_invalid_attachments" });
   }
-  await assert.rejects(f.conversation.send({ ...input, attachments: [resolution()] }), { code: "conversation_unsupported" });
+  await assert.rejects(f.conversation.send({ ...input, attachments: [resolution()] }), { code: "conversation_attachment_ids_only" });
   assert.equal(f.reads.length, 0);
   assert.equal(f.requests.length, 0);
 });

package/test/conversationConfiguration.test.js

@@ -128,7 +128,7 @@ test("runtime normalizes destination settings and retains file-backed selection
   conversation = await second.open({ id: "one" });
   assert.equal((await conversation.select(selection)).duplicate, true);
   await assert.rejects(conversation.select({ ...selection, configuration: { ...selection.configuration, model: "changed-model" } }),
-    { code: "conversation_replacement_conflict" });
+    { code: "conversation_replacement_operation_conflict" });
   const replacement = { operationId: "api", expectedSegmentId: selected.segmentId, reason: "engine-change", engine: "api",
     configuration: { systemPrompt: "API instructions.", integrationId: undefined, model: undefined, effort: undefined } };
   await conversation.replace(replacement);
@@ -140,7 +140,7 @@ test("runtime normalizes destination settings and retains file-backed selection
   conversation = await f.runtime({ defaultIntegrationId: "later-default" }).open({ id: "one" });
   assert.equal((await conversation.replace(replacement)).duplicate, true);
   await assert.rejects(conversation.replace({ ...replacement, configuration: { ...replacement.configuration, integrationId: "changed" } }),
-    { code: "conversation_replacement_conflict" });
+    { code: "conversation_replacement_operation_conflict" });
   assert.deepEqual((await conversation.read()).configuration, { systemPrompt: "API instructions.", integrationId: "next-default" });
   assert.deepEqual((await conversation.read()).conversationLog, []);
 });
@@ -166,7 +166,7 @@ test("file-backed pending replacement keeps its admitted configuration across a
   await first.close();
   const resumed = await f.runtime({ defaultIntegrationId: "later-default" }).open({ id: "one" });
   await assert.rejects(resumed.replace({ ...input, configuration: { ...input.configuration, systemPrompt: "Different instructions." } }),
-    { code: "conversation_replacement_pending" });
+    { code: "conversation_replacement_unfinished" });
   assert.deepEqual(await f.storage.read("one", transaction => transaction.readMetadata()), saved);
   await resumed.replace(input);
   assert.deepEqual((await resumed.read()).configuration, { systemPrompt: "Replacement instructions.", integrationId: "assistant" });
@@ -197,5 +197,5 @@ test("file-backed OpenCode selections keep compatible bindings and reserve a fre
   assert.equal((await reopened.select(selection)).duplicate, true);
   assert.deepEqual(await f.storage.read("open-code", tx => tx.readMetadata()), saved);
   await assert.rejects(reopened.select({ ...selection, configuration: { ...selection.configuration, integrationId: "different" } }),
-    { code: "conversation_replacement_conflict" });
+    { code: "conversation_replacement_operation_conflict" });
 });

package/test/conversationNativeStorage.test.js

@@ -6,7 +6,8 @@ import { randomUUID } from "node:crypto";
 import { nativeConversationStoragePolicy } from "../src/server/conversation/nativeStorage.js";
 import { createCodexAppServerProviderOwner } from "../src/server/conversation/codexProviderOwner.js";
 import { createCodexConversationDriver } from "../src/server/conversation/providers/codexDriver.js";
-import { createOpenCodeSharedRuntime, openCodeServerForDirectory } from "../src/server/conversation/openCodeRuntime.js";
+import { createOpenCodeSharedRuntime } from "../src/server/conversation/openCodeRuntime.js";
+import { openCodeServerForDirectory } from "../src/server/conversation/openCodeNativeSession.js";
 import { createOpenCodeConversationDriver } from "../src/server/conversation/providers/opencodeDriver.js";
 import { eventually } from "./fixtures/eventually.js";
 
@@ -274,30 +275,30 @@ test("Codex native existence checks a home whose thread previews exceed any byte
     [nativeThread("wanted", { previewBytes: 70 * 1024 })]
   ];
   const { inventory } = codexThreadListing(pages);
-  const { CodexAppServerAgentProvider } = await import("../src/server/conversation/codexProvider.js");
-  assert.equal(await CodexAppServerAgentProvider.prototype.nativeThreadExists.call(inventory, "wanted"), true);
-  assert.equal(await CodexAppServerAgentProvider.prototype.nativeThreadExists.call(inventory, "missing"), false);
+  const { createCodexProviderInventories } = await import("../src/server/conversation/codexProviderInventories.js");
+  assert.equal(await createCodexProviderInventories({ provider: inventory }).nativeThreadExists("wanted"), true);
+  assert.equal(await createCodexProviderInventories({ provider: inventory }).nativeThreadExists("missing"), false);
 });
 
 test("Codex native existence searches more threads than an inventory retains", async () => {
   const pages = Array.from({ length: 12 }, (_, page) =>
     Array.from({ length: 100 }, (_, index) => nativeThread(`thread-${page}-${index}`)));
   const { inventory, requests } = codexThreadListing(pages);
-  const { CodexAppServerAgentProvider } = await import("../src/server/conversation/codexProvider.js");
-  assert.equal(await CodexAppServerAgentProvider.prototype.nativeThreadExists.call(inventory, "thread-3-7"), true);
+  const { createCodexProviderInventories } = await import("../src/server/conversation/codexProviderInventories.js");
+  assert.equal(await createCodexProviderInventories({ provider: inventory }).nativeThreadExists("thread-3-7"), true);
   assert.equal(requests.length, 4, "the search stops at the page that lists the thread");
-  assert.equal(await CodexAppServerAgentProvider.prototype.nativeThreadExists.call(inventory, "thread-12-0"), false);
+  assert.equal(await createCodexProviderInventories({ provider: inventory }).nativeThreadExists("thread-12-0"), false);
 });
 
 test("a refused Codex inventory entry names the check and the thread", async () => {
-  const { CodexAppServerAgentProvider } = await import("../src/server/conversation/codexProvider.js");
+  const { createCodexProviderInventories } = await import("../src/server/conversation/codexProviderInventories.js");
   const outside = codexThreadListing([[nativeThread("thread-a"), nativeThread("thread-b", { cwd: "/elsewhere" })]]);
-  await assert.rejects(CodexAppServerAgentProvider.prototype.listNativeThreadsForCwd.call(outside.inventory, "/source"), (error) => {
+  await assert.rejects(createCodexProviderInventories({ provider: outside.inventory }).listNativeThreadsForCwd("/source"), (error) => {
     assert.equal(error.code, "vibe64_codex_retirement_inventory_invalid");
     assert.match(error.message, /thread thread-b .*outside the requested directory/u);
     return true;
   });
   const unnamed = codexThreadListing([[{ cwd: "/source" }]]);
-  await assert.rejects(CodexAppServerAgentProvider.prototype.listNativeThreadsForCwd.call(unnamed.inventory, "/source"),
+  await assert.rejects(createCodexProviderInventories({ provider: unnamed.inventory }).listNativeThreadsForCwd("/source"),
     /listed a thread without an id/u);
 });