@jskit-ai/assistant-core 0.1.205 → 0.1.207

package/test/codexConversationSession.test.js

@@ -2126,3 +2126,321 @@ test("Codex goal controls reject local attachments before native work", async t
   assert.equal((await f.conversation.read()).conversationLog.length, 0);
   await assert.rejects(readFile(path.join(f.directory, "trace.jsonl")), { code: "ENOENT" });
 });
+
+
+for (const change of ["model", "effort"]) test(`Codex honors a consumer's fresh native policy for ${change} changes without retiring its shared peer`, async t => {
+  const f = await fixture(t);
+  const binding = (id = "conversation") => f.storage.read(id, async tx => (await tx.readMetadata()).runtime.binding);
+  const peer = await f.first.open({ id: "peer", configuration });
+  await peer.send({ messageId: "peer-first", text: "Peer history" });
+  await peer.wait();
+  const peerBinding = await binding("peer");
+  await f.conversation.send(input);
+  const original = await f.conversation.wait();
+  const previous = await binding();
+  const beforeSelection = await f.trace();
+  const oldHistory = JSON.parse(await readFile(path.join(f.directory, "history.json"), "utf8")).threads.find(thread => thread.id === previous.threadId);
+  const selected = { ...configuration, [change]: change === "model" ? "another-model" : "low" };
+  const request = { operationId: `fresh-${change}`, expectedSegmentId: original.segmentId,
+    engine: "codex", configuration: selected, retireNative: true };
+  const receipt = await f.conversation.select(request);
+  assert.notEqual(receipt.segmentId, original.segmentId);
+  const inert = await binding();
+  assert.equal(inert.threadId, "");
+  assert.equal(inert.configRoot, previous.configRoot);
+  assert.equal(inert.workdir, previous.workdir);
+  const predecessor = await f.storage.read("conversation", async tx => (await tx.readMetadata()).runtime.predecessors.find(segment => segment.segmentId === original.segmentId));
+  assert.equal(predecessor.binding.threadId, previous.threadId);
+  const selectedTrace = await f.trace();
+  assert.deepEqual(selectedTrace.filter(row => row.args || ["thread/start", "turn/start"].includes(row.method)),
+    beforeSelection.filter(row => row.args || ["thread/start", "turn/start"].includes(row.method)),
+    "Selecting inspects readiness without creating a thread, process or inference");
+  const retained = await f.conversation.read();
+  assert.equal(retained.id, original.id);
+  assert.deepEqual(retained.conversationLog, original.conversationLog);
+  assert.equal((await f.conversation.select(request)).duplicate, true);
+  await f.conversation.send({ messageId: "changed", text: "Continue after the change" });
+  assert.equal((await f.conversation.wait()).conversationLog.at(-1).metadata.runtime.status, "complete");
+  const fresh = await binding();
+  assert.ok(fresh.threadId);
+  assert.notEqual(fresh.threadId, previous.threadId);
+  assert.equal(fresh.accountIdentity, previous.accountIdentity);
+  assert.deepEqual(JSON.parse(await readFile(path.join(f.directory, "history.json"), "utf8")).threads.find(thread => thread.id === previous.threadId), oldHistory);
+  let trace = await f.trace();
+  assert.equal(trace.filter(row => row.args).length, 1, "A peer retains the original shared account service");
+  assert.equal(trace.filter(row => row.method === "thread/start").length, 3);
+  const calls = trace.filter(row => row.method === "turn/start");
+  assert.equal(calls.length, 3);
+  assert.equal(calls[2].params.threadId, fresh.threadId);
+  assert.equal(calls[2].params.model, selected.model);
+  assert.equal(calls[2].params.effort, selected.effort);
+  const handedHistory = JSON.parse(calls[2].params.input[0].text.split("\n").find(line => line.startsWith('{"messages":')));
+  assert.deepEqual(handedHistory.messages.map(({ role, text }) => [role, text]), [["user", "Hello"], ["assistant", "Answer: Hello"]]);
+  assert.deepEqual(handedHistory.removedMessageIds, []);
+  assert.equal(calls[2].params.input[0].text.split("User's message:\n")[1], "Continue after the change");
+  assert.match(calls[2].params.input[0].text, /Hello/);
+  assert.match(calls[2].params.input[0].text, /Answer: Hello/);
+  assert.match(calls[2].params.input[0].text, /Continue after the change/);
+  assert.doesNotMatch(calls[2].params.input[0].text, /Peer history/);
+  await peer.send({ messageId: "peer-next", text: "Peer continues" });
+  assert.equal((await peer.wait()).conversationLog.length, 2);
+  assert.equal((await binding("peer")).threadId, peerBinding.threadId);
+  trace = await f.trace();
+  assert.equal(trace.filter(row => row.args).length, 1);
+  assert.equal(trace.filter(row => row.method === "turn/start").at(-1).params.input[0].text, "Peer continues");
+  await f.first.close();
+  const resumed = await f.runtime().open({ id: "conversation" });
+  assert.equal((await resumed.select(request)).duplicate, true);
+  assert.equal((await resumed.send(input)).duplicate, true);
+  assert.equal((await binding()).threadId, fresh.threadId);
+  await resumed.send({ messageId: "after-restart", text: "Continue after restart" });
+  assert.equal((await resumed.wait()).conversationLog.length, 3);
+  trace = await f.trace();
+  assert.equal(trace.filter(row => row.args).length, 2);
+  assert.equal(trace.filter(row => row.method === "thread/start").length, 3);
+  assert.equal(trace.filter(row => row.method === "thread/resume").at(-1).params.threadId, fresh.threadId);
+  assert.equal(trace.filter(row => row.method === "turn/start").at(-1).params.input[0].text, "Continue after restart");
+  const returned = await resumed.select({ operationId: `restore-${change}`, expectedSegmentId: (await resumed.read()).segmentId,
+    engine: "codex", configuration, retireNative: true });
+  assert.notEqual(returned.segmentId, original.segmentId, "The consumer policy cannot restore an older retained segment");
+  assert.notEqual(returned.segmentId, receipt.segmentId);
+  await resumed.send({ messageId: "returned", text: "Back to the original settings" });
+  assert.equal((await resumed.wait()).conversationLog.length, 4);
+  const restored = await binding();
+  assert.notEqual(restored.threadId, previous.threadId);
+  assert.notEqual(restored.threadId, fresh.threadId);
+  assert.equal(restored.accountIdentity, previous.accountIdentity);
+  const restoredPrompt = (await f.trace()).filter(row => row.method === "turn/start").at(-1).params.input[0].text;
+  assert.match(restoredPrompt, /Hello/);
+  assert.match(restoredPrompt, /Continue after the change/);
+  assert.match(restoredPrompt, /Continue after restart/);
+});
+
+test("held lifecycle catalogue work does not block another owner's runtime stop or acquisition", async t => {
+  const root = await mkdtemp(path.join(tmpdir(), "jskit-codex-lifecycle-"));
+  const first = createCodexAppServerProviderOwner({ runtimeRoot: path.join(root, "a") });
+  const other = createCodexAppServerProviderOwner({ runtimeRoot: path.join(root, "b") });
+  const entered = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  const events = [];
+  const firstOptions = { runtimeDir: path.join(root, "a", "runtime") };
+  const stopOptions = { runtimeDir: path.join(root, "b", "stop") };
+  const acquireOptions = { runtimeDir: path.join(root, "b", "acquire") };
+  t.after(async () => {
+    for (const owner of [first, other]) await owner.invalidateRuntimes({ includeOwned: true, stopOwnedRuntimes: true });
+    await rm(root, { recursive: true, force: true });
+  });
+  const firstProvider = first.createProvider({ providerKey: "a", providerOptions: firstOptions, create: () => ({
+    async currentRuntimeInfo() { return { runtimeDir: firstOptions.runtimeDir }; },
+    async listModels() { entered.resolve(); await release.promise; events.push("a-catalogue-finished"); return { data: [] }; },
+    async stopRuntime() { events.push("a-stop"); return { stopped: true }; },
+    close() {}
+  }) });
+  await first.acquireRuntime({ providerKey: "a", providerOptions: firstOptions, provider: firstProvider, operation: async () => {} });
+  other.createProvider({ providerKey: "b-stop", providerOptions: stopOptions, create: () => ({
+    async stopRuntime() { events.push("b-stop"); return { stopped: true }; }, close() {}
+  }) });
+  const acquiredProvider = other.createProvider({ providerKey: "b-acquire", providerOptions: acquireOptions, create: () => ({
+    async ensureRuntime() { events.push("b-acquire"); return {}; },
+    async stopRuntime() { return { stopped: true }; }, close() {}
+  }) });
+  const catalogue = first.readModelCatalog({ prepareProviderOptions: async () => firstOptions,
+    providerFactory() { throw new Error("The existing provider must be reused."); } });
+  await entered.promise;
+  const stopping = other.stopCachedProvider("b-stop", { requireStopped: true });
+  const acquiring = other.ensureSession({ sessionId: "b", providerKey: "b-acquire", providerOptions: acquireOptions,
+    assertAdmission() {} });
+  let deadline;
+  try {
+    const [stopped, acquired] = await Promise.race([
+      Promise.all([stopping, acquiring]),
+      new Promise((_, reject) => { deadline = setTimeout(() => reject(new Error("An unrelated runtime waited for the held catalogue.")), 2000); })
+    ]);
+    assert.equal(stopped.stopped, true);
+    assert.equal(acquired, acquiredProvider);
+    assert.deepEqual(events, ["b-stop", "b-acquire"]);
+    assert.equal(first.providers.get("a"), firstProvider);
+  } finally {
+    clearTimeout(deadline);
+    release.resolve();
+    await Promise.allSettled([catalogue, stopping, acquiring]);
+  }
+});
+
+test("held lifecycle catalogue work preserves same-runtime peer ordering and the final participant stop", async t => {
+  const root = await mkdtemp(path.join(tmpdir(), "jskit-codex-lifecycle-peer-"));
+  const first = createCodexAppServerProviderOwner({ runtimeRoot: root });
+  const peer = createCodexAppServerProviderOwner({ runtimeRoot: root });
+  const providerOptions = { runtimeDir: path.join(root, "runtime") };
+  const entered = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  const events = [];
+  t.after(async () => {
+    for (const owner of [first, peer]) await owner.invalidateRuntimes({ includeOwned: true, stopOwnedRuntimes: true });
+    await rm(root, { recursive: true, force: true });
+  });
+  const provider = first.createProvider({ providerKey: "first", providerOptions, create: () => ({
+    async currentRuntimeInfo() { return { runtimeDir: providerOptions.runtimeDir }; },
+    async listModels() { entered.resolve(); await release.promise; events.push("catalogue"); return { data: [] }; },
+    async stopRuntime() { events.push("first-stop"); return { stopped: true }; }, close() {}
+  }) });
+  await first.acquireRuntime({ providerKey: "first", providerOptions, provider, operation: async () => {} });
+  peer.createProvider({ providerKey: "peer", providerOptions, create: () => ({
+    async stopRuntime() { events.push("peer-stop"); return { stopped: true }; },
+    close() { events.push("peer-close"); }
+  }) });
+  const catalogue = first.readModelCatalog({ prepareProviderOptions: async () => providerOptions,
+    providerFactory() { throw new Error("The existing provider must be reused."); } });
+  await entered.promise;
+  let finished = false;
+  const stopping = peer.stopCachedProvider("peer", { requireStopped: true }).then(value => { finished = true; return value; });
+  try {
+    await new Promise(resolve => setImmediate(resolve));
+    assert.equal(finished, false);
+    assert.deepEqual(events, []);
+  } finally {
+    release.resolve();
+    await catalogue;
+  }
+  const stopped = await stopping;
+  assert.equal(stopped.sharedProcessRetained, true);
+  assert.equal(stopped.stopped, false);
+  assert.equal(first.providers.get("first"), provider);
+  assert.equal(peer.providers.get("peer"), undefined);
+  assert.deepEqual(events, ["catalogue", "peer-close"]);
+  assert.equal((await first.stopCachedProvider("first", { requireStopped: true })).stopped, true);
+  assert.deepEqual(events, ["catalogue", "peer-close", "first-stop"]);
+});
+
+test("held lifecycle catalogue work preserves one owner's FIFO across different runtimes", async t => {
+  const root = await mkdtemp(path.join(tmpdir(), "jskit-codex-lifecycle-fifo-"));
+  const owner = createCodexAppServerProviderOwner({ runtimeRoot: root });
+  const providerOptions = { runtimeDir: path.join(root, "catalogue") };
+  const entered = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  const events = [];
+  t.after(async () => {
+    await owner.invalidateRuntimes({ includeOwned: true, stopOwnedRuntimes: true });
+    await rm(root, { recursive: true, force: true });
+  });
+  const provider = owner.createProvider({ providerKey: "catalogue", providerOptions, create: () => ({
+    async currentRuntimeInfo() { return { runtimeDir: providerOptions.runtimeDir }; },
+    async listModels() { entered.resolve(); await release.promise; events.push("catalogue"); return { data: [] }; },
+    async stopRuntime() { return { stopped: true }; }, close() {}
+  }) });
+  await owner.acquireRuntime({ providerKey: "catalogue", providerOptions, provider, operation: async () => {} });
+  owner.createProvider({ providerKey: "other", providerOptions: { runtimeDir: path.join(root, "other") }, create: () => ({
+    async stopRuntime() { events.push("other-stop"); return { stopped: true }; }, close() {}
+  }) });
+  const catalogue = owner.readModelCatalog({ prepareProviderOptions: async () => providerOptions,
+    providerFactory() { throw new Error("The existing provider must be reused."); } });
+  await entered.promise;
+  let finished = false;
+  const stopping = owner.stopCachedProvider("other", { requireStopped: true }).then(value => { finished = true; return value; });
+  try {
+    await new Promise(resolve => setImmediate(resolve));
+    assert.equal(finished, false);
+    assert.deepEqual(events, []);
+  } finally {
+    release.resolve();
+    await catalogue;
+  }
+  assert.equal((await stopping).stopped, true);
+  assert.deepEqual(events, ["catalogue", "other-stop"]);
+});
+
+test("held lifecycle catalogue preparation remains tracked through shutdown before its runtime key is known", async t => {
+  const root = await mkdtemp(path.join(tmpdir(), "jskit-codex-lifecycle-shutdown-"));
+  let closing = false;
+  const owner = createCodexAppServerProviderOwner({ runtimeRoot: root,
+    assertOpen() { if (closing) throw new Error("The application is shutting down."); } });
+  const entered = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  const events = [];
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const catalogue = owner.readModelCatalog({
+    async prepareProviderOptions() { entered.resolve(); await release.promise; return { runtimeDir: path.join(root, "runtime") }; },
+    providerFactory() {
+      return {
+        async currentRuntimeInfo() { return {}; },
+        async ensureRuntime() { events.push("acquire"); return { reused: false }; },
+        async listModels() { events.push("catalogue"); return { data: [] }; },
+        close() { events.push("close"); }
+      };
+    }
+  });
+  await entered.promise;
+  assert.equal(owner.lifecycleTasks.size, 1);
+  closing = true;
+  owner.beginShutdown();
+  let drained = false;
+  const draining = Promise.allSettled([...owner.lifecycleTasks]).then(() => { drained = true; });
+  try {
+    await new Promise(resolve => setImmediate(resolve));
+    assert.equal(drained, false);
+    assert.deepEqual(events, []);
+  } finally {
+    release.resolve();
+  }
+  await assert.rejects(catalogue, /application is shutting down/);
+  await draining;
+  assert.equal(drained, true);
+  assert.equal(owner.lifecycleTasks.size, 0);
+  assert.deepEqual(events, ["close"]);
+});
+
+test("held lifecycle catalogue rejection preserves a newer same-runtime tail and later owner work", async t => {
+  const root = await mkdtemp(path.join(tmpdir(), "jskit-codex-lifecycle-rejection-"));
+  const owners = [0, 1, 2].map(() => createCodexAppServerProviderOwner({ runtimeRoot: root }));
+  const providerOptions = { runtimeDir: path.join(root, "runtime") };
+  const entered = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  const nextEntered = Promise.withResolvers();
+  const nextRelease = Promise.withResolvers();
+  const failure = new Error("Catalogue unavailable.");
+  const catalogue = { data: [{ id: "model" }] };
+  let calls = 0;
+  t.after(async () => {
+    for (const owner of owners) await owner.invalidateRuntimes({ includeOwned: true, stopOwnedRuntimes: true });
+    await rm(root, { recursive: true, force: true });
+  });
+  const provider = owners[0].createProvider({ providerKey: "catalogue", providerOptions, create: () => ({
+    async currentRuntimeInfo() { return { runtimeDir: providerOptions.runtimeDir }; },
+    async listModels() {
+      calls += 1;
+      if (calls === 1) { entered.resolve(); await release.promise; throw failure; }
+      if (calls === 2) { nextEntered.resolve(); await nextRelease.promise; }
+      return catalogue;
+    },
+    async stopRuntime() { return { stopped: true }; }, close() {}
+  }) });
+  await owners[0].acquireRuntime({ providerKey: "catalogue", providerOptions, provider, operation: async () => {} });
+  const options = { prepareProviderOptions: async () => providerOptions,
+    providerFactory() { throw new Error("The existing provider must be reused."); } };
+  const failed = assert.rejects(owners[0].readModelCatalog(options), error => error === failure);
+  await entered.promise;
+  const next = owners[1].readModelCatalog(options);
+  let last;
+  try {
+    release.resolve();
+    await failed;
+    await nextEntered.promise;
+    let finished = false;
+    last = owners[2].readModelCatalog(options).then(value => { finished = true; return value; });
+    await new Promise(resolve => setImmediate(resolve));
+    assert.equal(finished, false);
+    assert.equal(calls, 2, "The rejected task cannot remove the newer runtime tail.");
+    nextRelease.resolve();
+    assert.equal(await next, catalogue);
+    assert.equal(await last, catalogue);
+    assert.equal(calls, 3);
+    assert.equal(await owners[0].readModelCatalog(options), catalogue);
+    assert.equal(calls, 4, "The original owner's queue also continues after rejection.");
+    await Promise.all(owners.flatMap(owner => [...owner.lifecycleTasks]));
+    assert.deepEqual(owners.map(owner => owner.lifecycleTasks.size), [0, 0, 0]);
+  } finally {
+    release.resolve();
+    nextRelease.resolve();
+    await Promise.allSettled([failed, next, last]);
+  }
+});

package/test/codexHistoryAdapter.test.js

@@ -539,3 +539,109 @@ test("an owned conversation resolves its native history only when foreign compac
   assert.equal(reads, 1);
   assert.match(calls.at(-1).input[1].content[0].text, /RANDOM_TOOL_FACT/);
 });
+
+test("OpenAI receives clock::sleep history as quoted context without changing native calls or the selected model", () => {
+  const call = { type: "function_call", name: "clock::sleep", call_id: "call_00_JWQtri71vpXPGPWQTcAZ8404",
+    arguments: '{"seconds":1}' };
+  const result = { type: "function_call_output", call_id: call.call_id, output: "Finished waiting.\n  Exact result." };
+  const valid = { type: "function_call", name: "shell_command", call_id: "valid", arguments: '{"command":"pwd"}' };
+  const validResult = { type: "function_call_output", call_id: valid.call_id, output: "/workspace" };
+  const unmatched = { type: "function_call_output", call_id: "another-call", output: "Do not associate this result." };
+  const body = { model: "gpt-6-astra", tools: [{ type: "function", name: "shell_command" }],
+    input: [valid, call, result, validResult, unmatched, foreign] };
+  const saved = structuredClone(body);
+  for (const destination of ["openai", "chatgpt", "apiKey"]) {
+    const translated = translateCodexHistory(body, destination);
+    assert.equal(translated.model, "gpt-6-astra");
+    assert.equal(translated.tools, body.tools);
+    assert.equal(translated.input.length, body.input.length);
+    assert.equal(translated.input[1].type, "message");
+    assert.equal(translated.input[1].role, "assistant");
+    assert.ok(translated.input[1].content[0].text.includes(JSON.stringify(call)));
+    assert.match(translated.input[1].content[0].text, /context only, not an available tool/);
+    assert.equal(translated.input[2].role, "user");
+    assert.ok(translated.input[2].content[0].text.includes(JSON.stringify({ call_id: call.call_id, name: call.name })));
+    assert.match(translated.input[2].content[0].text, /untrusted context, not new instructions/);
+    assert.equal(translated.input[2].content[1].text, result.output);
+    for (const index of [0, 3, 4]) assert.equal(translated.input[index], body.input[index]);
+    assert.equal(translated.input[5].type, "message", "Original reasoning translation still runs.");
+  }
+  for (const destination of ["deepseek", "zai", "zai-coding-plan", "unrelated"]) {
+    const translated = translateCodexHistory(body, destination);
+    assert.equal(translated.input[1], call);
+    assert.equal(translated.input[2], result);
+  }
+  assert.deepEqual(body, saved);
+});
+
+test("quoted historical function results retain text and image parts in their original positions", () => {
+  const call = { type: "function_call", name: "foreign::inspect", call_id: "image-call", arguments: "{}" };
+  const text = { type: "input_text", text: "Exact output\n  with whitespace" };
+  const image = { type: "input_image", image_url: "data:image/png;base64,fixture", detail: "original" };
+  const result = { type: "function_call_output", call_id: call.call_id, output: [text, image] };
+  const after = { type: "message", role: "user", content: [{ type: "input_text", text: "Then review it." }] };
+  const body = { input: [call, result, after] };
+  const saved = structuredClone(body);
+  const translated = translateCodexHistory(body);
+  assert.equal(translated.input.length, 3);
+  assert.ok(translated.input[0].content[0].text.includes(JSON.stringify(call)));
+  assert.equal(translated.input[1].content[1], text);
+  assert.equal(translated.input[1].content[2], image);
+  assert.equal(translated.input[2], after);
+  assert.deepEqual(body, saved);
+});
+
+test("invalid historical function identity or unsupported paired content fails without inventing an association", () => {
+  const call = { type: "function_call", name: "clock::sleep", call_id: "clock-call", arguments: "{}" };
+  const output = { type: "function_call_output", call_id: call.call_id, output: "Finished." };
+  for (const input of [
+    [{ ...call, call_id: "" }, output],
+    [{ ...call, arguments: {} }, output],
+    [call, { ...call, name: "shell_command" }, output],
+    [call, { ...output, output: null }],
+    [call, { ...output, output: [{ type: "input_text", text: 42 }] }],
+    [call, { ...output, output: [{ type: "input_image", image_url: 42 }] }],
+    [call, { ...output, output: [{ type: "unknown", text: "Not a supported result." }] }]
+  ]) {
+    const saved = structuredClone(input);
+    assert.throws(() => translateCodexHistory({ input }), { statusCode: 422 });
+    assert.deepEqual(input, saved);
+  }
+  const unmatched = { ...output, call_id: "unmatched", output: [{ type: "unknown" }] };
+  assert.equal(translateCodexHistory({ input: [call, unmatched] }).input[1], unmatched);
+});
+
+test("the real adapter forwards selected GPT compaction and response requests without invalid function-call names", async t => {
+  const calls = [];
+  const adapter = await startCodexHistoryAdapter({ token: randomUUID(), fetchImpl: async (url, options) => {
+    calls.push({ url, body: JSON.parse(options.body) });
+    return new Response("accepted", { status: 200 });
+  } });
+  t.after(() => adapter.close());
+  const call = { type: "function_call", name: "clock::sleep", call_id: "clock-call", arguments: '{"seconds":1}' };
+  const output = { type: "function_call_output", call_id: call.call_id, output: "Finished." };
+  const ordinary = { type: "function_call", name: "shell_command", call_id: "ordinary-call", arguments: "{}" };
+  const body = { model: "gpt-6-astra", input: [call, output, ordinary], tools: [{ type: "function", name: "shell_command" }] };
+  const saved = structuredClone(body);
+  for (const [destination, upstream] of [["chatgpt", "https://chatgpt.com/backend-api/codex"], ["apiKey", "https://api.openai.com/v1"]]) {
+    for (const route of ["responses", "responses/compact"]) {
+      const response = await fetch(`${adapter.baseUrl}/${destination}/${route}`, { method: "POST", body: JSON.stringify(body) });
+      assert.equal(response.status, 200);
+      assert.equal(await response.text(), "accepted");
+      const sent = calls.at(-1);
+      assert.equal(sent.url, `${upstream}/${route}`);
+      assert.equal(sent.body.model, "gpt-6-astra");
+      assert.deepEqual(sent.body.tools, body.tools);
+      assert.deepEqual(sent.body.input.filter(item => item.type === "function_call"), [ordinary]);
+      assert.ok(sent.body.input[0].content[0].text.includes(JSON.stringify(call)));
+      assert.equal(sent.body.input[1].content[1].text, output.output);
+    }
+  }
+  const accepted = calls.length;
+  const rejected = await fetch(`${adapter.baseUrl}/chatgpt/responses`, { method: "POST",
+    body: JSON.stringify({ ...body, input: [call, { ...output, output: [{ type: "unknown" }] }] }) });
+  assert.equal(rejected.status, 422);
+  assert.match((await rejected.json()).error.message, /history is not supported/);
+  assert.equal(calls.length, accepted, "Unsupported paired history must fail before provider admission.");
+  assert.deepEqual(body, saved);
+});

package/test/codexTurn.test.js

@@ -1,10 +1,13 @@
 import assert from "node:assert/strict";
-import { readFile } from "node:fs/promises";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 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 } from "../src/server/conversation/codexProvider.js";
+import { sendCodexAppServerPrompt, CodexAppServerAgentProvider } from "../src/server/conversation/codexProvider.js";
+import { createCodexHelperThreadLedgerOwner } from "../src/server/conversation/codexHelperThreadLedger.js";
 import {
   waitForCodexAppServerTurn,
   createCodexAppServerRunOwner,
@@ -60,6 +63,119 @@ function fixture(turns = []) {
   return { provider, listeners, operations };
 }
 
+// Joining fixture for the original detached coordinator. Native observation is
+// the same provider/watcher fixture above; the host only prepares its policy.
+async function detachedFixture(t, { refused = false, unavailable = null, contextError = null, dispatchError = null } = {}) {
+  const f = fixture([turn("turn-1", "completed", "Original detached answer.")]);
+  const stateRoot = await mkdtemp(join(tmpdir(), "codex-detached-"));
+  t.after(() => rm(stateRoot, { recursive: true, force: true }));
+  const runtime = { stateRoot };
+  const session = { sessionId: "session-1" };
+  const threadSettings = { model: "selected-model", cwd: "/authorized/workdir" };
+  const turnSettings = { model: "selected-model", effort: "high", cwd: "/authorized/workdir" };
+  f.events = [];
+  f.releases = 0;
+  Object.assign(f.provider, {
+    async resumeThread(id, settings) {
+      assert.equal(id, "thread-1");
+      assert.equal(settings, threadSettings);
+      f.operations.push("resume");
+      return { id };
+    },
+    async startThread(settings) {
+      assert.deepEqual(settings, { ...threadSettings, ephemeral: true });
+      f.operations.push("create");
+      return { response: { thread: { id: "thread-1" } } };
+    },
+    async sendTurn(id, input, settings) {
+      assert.equal(id, "thread-1");
+      assert.deepEqual(input, ["Original prompt"]);
+      assert.deepEqual(settings, turnSettings);
+      f.operations.push("dispatch");
+      if (dispatchError) throw dispatchError;
+      return turn("turn-1", "completed");
+    }
+  });
+  const conversationPreparation = {
+    detached(id) {
+      assert.equal(id, "session-1");
+      f.operations.push("admission");
+      return {
+        admission: refused ? { ok: false, code: "original_closing" } : { ok: true, release() { f.releases++; f.operations.push("release"); } },
+        get result() { f.operations.push("input"); return unavailable; },
+        get prompt() { return "Original prompt"; },
+        execution(context) {
+          assert.equal(context.provider, f.provider);
+          return { threadPreparation: { settings: () => threadSettings }, authorized: { turnSettings },
+            failure(error, status) { assert.equal(status, ""); return error; } };
+        }
+      };
+    },
+    context(id, input, options) {
+      f.operations.push("context");
+      assert.equal(id, "session-1");
+      assert.equal(options, f.options);
+      if (contextError) throw contextError;
+      return { context: { session }, helperTurn: false, projectRuntimeRoot: stateRoot, providerOptions: {},
+        project: provider => ({ provider, runtime, session, workdir: "/authorized/workdir", ok: true }) };
+    },
+    admissionError() { return null; },
+    failure(error) { return { ok: false, error: error.message, code: error.code }; }
+  };
+  f.options = { runtime, session, onEvent(event) {
+    f.events.push(event);
+    f.operations.push(`event:${event.type}`);
+    return f.onEvent?.(event);
+  } };
+  f.owner = createCodexAppServerRunOwner({ conversationPreparation,
+    helperThreads: { ledgerOwner: createCodexHelperThreadLedgerOwner({ executionProfile: value => structuredClone(value) }) },
+    providerSessions: { owner: { providers: new Map(), ensureSession: async () => f.provider }, context: () => ({}) }
+  });
+  return f;
+}
+
+test("original detached run coordinator joins ordinary create/resume, events and native completion without awaiting observers", async t => {
+  for (const resume of [false, true]) await t.test(resume ? "resume" : "create", { timeout: 2_000 }, async t => {
+    const f = await detachedFixture(t);
+    const neverAwaited = Promise.withResolvers();
+    f.onEvent = () => neverAwaited.promise;
+    const result = await f.owner.runDetachedConversation("session-1", {
+      prompt: "Original prompt", ...(resume ? { codexSessionId: "thread-1" } : { ephemeral: true })
+    }, f.options);
+    assert.deepEqual(result, { ok: true, text: "Original detached answer.", threadId: "thread-1", turnId: "turn-1" });
+    assert.deepEqual(f.events, [
+      { type: "thread", threadId: "thread-1" },
+      { type: "turn", status: "completed", threadId: "thread-1", turnId: "turn-1" },
+      { type: "completed", status: "completed", text: "Original detached answer.", threadId: "thread-1", turnId: "turn-1" }
+    ]);
+    assert.deepEqual(f.operations, ["admission", "input", "context", resume ? "resume" : "create",
+      "event:thread", "subscribe", "dispatch", "event:turn", "read", "unsubscribe", "event:completed", "release"]);
+    assert.equal(f.releases, 1);
+    assert.equal(f.listeners.size, 0);
+    assert.equal(f.owner.conversations.size, 0, "Detached execution does not retain a Main/scoped conversation.");
+  });
+});
+
+test("original detached admission/result boundary releases every early or dispatched failure", async t => {
+  const failure = Object.assign(new Error("Original native failure"), { code: "original_native_failure" });
+  for (const scenario of ["refused", "disabled", "empty", "context", "thread-event", "dispatch"]) await t.test(scenario, async t => {
+    const unavailable = scenario === "disabled" ? { ok: false, code: "original_disabled" }
+      : scenario === "empty" ? { ok: false, code: "original_empty" } : null;
+    const f = await detachedFixture(t, { refused: scenario === "refused", unavailable,
+      contextError: scenario === "context" ? failure : null, dispatchError: scenario === "dispatch" ? failure : null });
+    if (scenario === "thread-event") f.onEvent = () => { throw failure; };
+    const result = await f.owner.runDetachedConversation("session-1", { prompt: "Original prompt", ephemeral: true }, f.options);
+    assert.deepEqual(result, scenario === "refused" ? { ok: false, code: "original_closing" }
+      : unavailable || { ok: false, error: failure.message, code: failure.code });
+    assert.equal(f.releases, scenario === "refused" ? 0 : 1);
+    assert.equal(f.listeners.size, 0);
+    assert.equal(f.owner.conversations.size, 0);
+    if (["refused", "disabled", "empty"].includes(scenario)) assert.equal(f.operations.includes("context"), false);
+    if (scenario !== "dispatch") assert.equal(f.operations.includes("dispatch"), false);
+    if (scenario === "dispatch") assert.equal(f.operations.includes("unsubscribe"), true);
+  });
+});
+
 test("an already completed exact turn returns its saved answer without subscribing or rereading", async () => {
   const f = fixture();
   const result = await waitForCodexAppServerTurn(f.provider, " thread-1 ", turn("turn-1", "completed", "Approved handover."));
@@ -2156,3 +2272,88 @@ test("original live observation completion preserves a changed main run and read
     assert.equal(f.publications.some(event => event.reason === "codex-observation-stopped"), false);
   }
 });
+
+for (const [status, cause, explicit, expected] of [
+  ["interrupted", "", "", "interrupted"],
+  ["interrupted", "control_reconfiguration", "", "control_reconfiguration"],
+  ["interrupted", "user_cancelled", "", "user_cancelled"],
+  ["failed", "control_reconfiguration", "", "provider_failure"],
+  ["interrupted", "control_reconfiguration", "service_restart", "service_restart"]
+]) {
+  test(`native ${status} preserves ${expected} outcome without inferring its cause`, async () => {
+    const notices = [];
+    const checkpoints = [];
+    const f = await receiptFixture({
+      outcomeNotice(_runtime, sessionId, threadId, turnId, outcome) { notices.push({ sessionId, threadId, turnId, outcome }); },
+      checkpoint(sessionId, value) { checkpoints.push({ sessionId, ...value }); }
+    });
+    const provider = new CodexAppServerAgentProvider({}, { credentials: { assertCurrent() {} } });
+    provider.client = { isOpen: () => true, close() {}, async request(method, input) {
+      assert.equal(method, "turn/interrupt");
+      assert.deepEqual(input, { threadId: f.threadId, turnId: f.turnId });
+      assert.equal(provider.interruptionOutcome(f.threadId, f.turnId), cause, "Cause precedes the actual native request");
+      return {};
+    } };
+    try {
+      if (cause) await provider.interruptTurn(f.threadId, f.turnId, { outcome: cause });
+      f.provider.interruptionOutcome = provider.interruptionOutcome.bind(provider);
+      assert.equal(provider.interruptionOutcome("another-thread", f.turnId), "");
+      assert.equal(provider.interruptionOutcome(f.threadId, "another-turn"), "");
+      const result = await f.owner.stopTurnWithProviderFailure(f.sessionId, f.threadId, f.turnId, {
+        status, provider: f.provider, verifyInactive: false, ...(explicit ? { outcome: explicit } : {})
+      });
+      assert.equal(result.status, status);
+      if (expected === "control_reconfiguration") assert.match(result.error, /while its controls were restored/u);
+      if (status === "interrupted") assert.doesNotMatch(result.error, /provider failed|app-server failed/u);
+      assert.deepEqual(notices, [{ sessionId: f.sessionId, threadId: f.threadId, turnId: f.turnId, outcome: expected }]);
+      assert.deepEqual(checkpoints, [{ sessionId: f.sessionId, status, turnOutcome: expected, threadId: f.threadId, turnId: f.turnId }]);
+      assert.equal(f.run.providerStatus, status);
+      assert.equal(f.run.providerThreadId, f.threadId);
+      assert.equal(f.run.providerTurnId, f.turnId);
+    } finally {
+      provider.close();
+      assert.equal(provider.interruptionOutcome(f.threadId, f.turnId), "");
+      f.owner.clearSessionRecoveryTimers(f.sessionId);
+    }
+  });
+}
+
+test("user Stop records its exact cause before queued native completion while the interrupt reply is held", async () => {
+  const notices = [];
+  const f = await receiptFixture({ outcomeNotice(_runtime, sessionId, threadId, turnId, outcome) {
+    notices.push({ sessionId, threadId, turnId, outcome });
+  } });
+  const issued = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  const provider = new CodexAppServerAgentProvider({}, { credentials: { assertCurrent() {} } });
+  provider.client = { isOpen: () => true, close() {}, async request(method, input) {
+    assert.equal(method, "turn/interrupt");
+    assert.deepEqual(input, { threadId: f.threadId, turnId: f.turnId });
+    assert.equal(provider.interruptionOutcome(f.threadId, f.turnId), "user_cancelled");
+    f.run.providerStatus = "interrupted";
+    f.emit({ method: "turn/completed", params: { threadId: f.threadId, turn: { id: f.turnId, status: "interrupted" } } });
+    issued.resolve();
+    await release.promise;
+    return {};
+  } };
+  f.provider.interruptTurn = provider.interruptTurn.bind(provider);
+  f.provider.interruptionOutcome = provider.interruptionOutcome.bind(provider);
+  f.observe();
+  const stopped = f.owner.interruptTurn(f.sessionId, {}, controlContext(f));
+  stopped.catch(() => {});
+  try {
+    await issued.promise;
+    await f.drain();
+    assert.deepEqual(notices, [{ sessionId: f.sessionId, threadId: f.threadId, turnId: f.turnId, outcome: "user_cancelled" }],
+      "The queued completion cannot write a provider-failure or unknown-interruption notice first");
+    assert.equal(f.run.state, "interrupted");
+    assert.equal(f.run.providerThreadId, f.threadId);
+    assert.equal(f.run.providerTurnId, f.turnId);
+  } finally {
+    release.resolve();
+    await stopped;
+    provider.close();
+    f.owner.clearSessionRecoveryTimers(f.sessionId);
+  }
+  assert.equal(notices.length, 1);
+});