@jskit-ai/assistant-core 0.1.199 → 0.1.201

package/test/conversation.test.js

@@ -1,10 +1,33 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { createMemoryConversationStorage } from "../src/server/conversation/memoryStorage.js";
+import { createConversationStorage } from "../src/server/conversation/storage.js";
 import { createConversationTranscript } from "../src/server/conversation/transcript.js";
 import { conversationTurnsFromMessages } from "../src/shared/conversation/turns.js";
 import { verifyConversationStorageContract } from "../src/testing/conversationStorageContract.js";
 
+test("new output identity persists on its original message while older records remain unchanged", async () => {
+  let record = { turns: new Map(), metadata: {} };
+  const options = { readRecord: () => record, writeRecord: (_scope, next) => { record = next; } };
+  const transcript = createConversationTranscript({ storage: createConversationStorage(options) });
+  await transcript.writeConversationUserMessage("chat", { messageId: "old-user", text: "Old question" });
+  await transcript.writeConversationAssistantMessage("chat", { messageId: "old-answer", text: "Old answer" });
+  const old = structuredClone(record.turns.get("000001"));
+  await transcript.writeConversationUserMessage("chat", { messageId: "new-user", text: "New question" });
+  await transcript.writeConversationCommentaryMessage("chat", { messageId: "saved-progress", outputId: "native-progress", text: "Checking." });
+  const saved = await transcript.writeConversationAssistantMessage("chat", { messageId: "saved-answer", outputId: "native-answer", text: "New answer" });
+  await transcript.upsertConversationAssistantMessage("chat", { turnId: saved.turnId, text: "Corrected new answer" });
+  const reopened = createConversationTranscript({ storage: createConversationStorage(options) });
+  const rows = await reopened.readConversationLog("chat");
+  assert.deepEqual(record.turns.get("000001"), old);
+  assert.equal(Object.hasOwn(rows[0].assistant, "outputId"), false);
+  assert.equal(rows[1].commentary[0].messageId, "saved-progress");
+  assert.equal(rows[1].commentary[0].outputId, "native-progress");
+  assert.equal(rows[1].assistant.messageId, "saved-answer");
+  assert.equal(rows[1].assistant.outputId, "native-answer");
+  assert.equal(rows[1].assistant.text, "Corrected new answer");
+});
+
 test("memory conversation storage satisfies the replaceable storage contract", async () => {
   await verifyConversationStorageContract(createMemoryConversationStorage());
 });
@@ -55,3 +78,90 @@ test("message adaptation retains progress, attachments, system actions and SQL m
   assert.equal(turns[1].system.repair, true);
   assert.equal(turns[2].assistant.sql, "select 1");
 });
+
+test("record storage preserves original role, timestamp and message-id overwrite identity", async () => {
+  let record = { turns: new Map(), metadata: {} };
+  const storage = createConversationStorage({ readRecord: () => record, writeRecord: (_scope, next) => { record = next; } });
+  const at = "2026-10-01T01:00:00.123Z";
+  const write = message => storage.write("conversation", transaction => transaction.appendMessage("000001", message));
+  await write({ role: "thinking", at, text: "Start", messageId: "part:1" });
+  await write({ role: "thinking", at: "2026-10-01T09:00:00.123+08:00", text: "Start completed", messageId: " part:1 " });
+  assert.equal(record.turns.get("000001").messages.length, 1);
+  assert.equal(record.turns.get("000001").messages[0].text, "Start completed");
+  await write({ role: "thinking", at, text: "Independent item", messageId: "part:2" });
+  await write({ role: "commentary", at, text: "Different role", messageId: "part:1" });
+  await write({ role: "thinking", at: "2026-10-01T01:00:00.124Z", text: "Different timestamp", messageId: "part:1" });
+  assert.deepEqual(record.turns.get("000001").messages.map(({ text }) => text),
+    ["Start completed", "Independent item", "Different role", "Different timestamp"]);
+  await storage.write("conversation", transaction => transaction.appendMessage("000002",
+    { role: "thinking", at, text: "Another turn", messageId: "part:1" }));
+  assert.equal(record.turns.get("000001").messages.length, 4);
+  assert.equal(record.turns.get("000002").messages[0].text, "Another turn");
+  for (const role of ["assistant", "system", "user"]) {
+    await write({ role, at, text: "First", messageId: "same" });
+    await write({ role, at, text: "Updated", messageId: "same" });
+    assert.deepEqual(record.turns.get("000001").messages.filter(message => message.role === role).map(({ text }) => text), ["Updated"]);
+  }
+});
+
+test("original thinking fragments update their saved row and preserve commentary boundaries", async () => {
+  const storage = createMemoryConversationStorage();
+  const transcript = createConversationTranscript({ storage });
+  await transcript.writeConversationUserMessage("one", { messageId: "request", text: "Work" });
+  const at = "2026-10-01T01:00:00.000Z";
+  await transcript.writeConversationThinkingMessage("one", { at, text: "Start" });
+  await transcript.writeConversationThinkingMessage("one", { at, text: `Start ${"word ".repeat(1_000)}`.trim() });
+  await transcript.writeConversationCommentaryMessage("one", { at: "2026-10-01T01:00:01.000Z", text: "Checking the files." });
+  await transcript.writeConversationThinkingMessage("one", { at: "2026-10-01T01:00:02.000Z", text: "next ".repeat(1_000).trim() });
+  const messages = (await transcript.readConversationLog("one")).flatMap(row => row.messages)
+    .filter(({ role }) => ["thinking", "commentary"].includes(role));
+  // Original public coalesced-reasoning assertion, with only store fixture adaptation.
+  assert.deepEqual(messages.map(({ text }) => text), [
+    `Start ${"word ".repeat(1_000)}`.trim(), "Checking the files.", "next ".repeat(1_000).trim()
+  ]);
+});
+
+test("message identity replacement does not rewrite tool receipts, unknown roles or failed transactions", async () => {
+  let record = { turns: new Map(), metadata: { retained: true } };
+  const storage = createConversationStorage({ readRecord: () => record, writeRecord: (_scope, next) => { record = next; } });
+  const message = { role: "thinking", at: "2026-10-01T01:00:00.000Z", text: "Saved" };
+  const tools = [{ id: "effect:1", status: "unknown", arguments: { retained: true } }];
+  await storage.write("one", async transaction => {
+    await transaction.appendMessage("000001", message);
+    await transaction.updateTurnMetadata("000001", { applicationTools: tools });
+    await transaction.appendMessage("000001", { role: "tool", at: message.at, messageId: "call:1", text: "First tool data" });
+    await transaction.appendMessage("000001", { role: "tool", at: message.at, messageId: "call:1", text: "Second tool data" });
+  });
+  const before = structuredClone(record);
+  await assert.rejects(storage.write("one", async transaction => {
+    await transaction.appendMessage("000001", { ...message, text: "Uncommitted replacement" });
+    throw new Error("Replacement failed");
+  }), /Replacement failed/);
+  assert.deepEqual(record, before);
+  await storage.write("one", transaction => transaction.appendMessage("000001", { ...message, text: "Saved replacement" }));
+  assert.deepEqual(record.turns.get("000001").metadata.applicationTools, tools);
+  assert.deepEqual(record.turns.get("000001").messages.filter(({ role }) => role === "tool").map(({ text }) => text),
+    ["First tool data", "Second tool data"]);
+  assert.equal(record.turns.get("000001").messages.filter(({ role }) => role === "thinking").length, 1);
+});
+
+
+test("application transcript opt-in opens only authored application system turns", async () => {
+  for (const applicationTurns of [false, true]) {
+    for (const origin of [undefined, "system", "application"]) {
+      const storage = createMemoryConversationStorage();
+      const transcript = createConversationTranscript({ storage, applicationTurns });
+      await storage.write("one", transaction => transaction.appendMessage("000001", {
+        role: "system", text: "Saved instruction", at: "2026-10-01", ...(origin ? { origin } : {})
+      }));
+      const written = await transcript.writeConversationAssistantMessage("one", { text: "Native answer" });
+      assert.equal(written.turnId, applicationTurns && origin === "application" ? "000001" : "000002");
+      assert.equal((await transcript.readConversationLog("one")).length,
+        applicationTurns && origin === "application" ? 1 : 2);
+    }
+    const storage = createMemoryConversationStorage();
+    const transcript = createConversationTranscript({ storage, applicationTurns });
+    const authored = await transcript.writeConversationUserMessage("one", { text: "User request" });
+    assert.equal((await transcript.writeConversationAssistantMessage("one", { text: "Answer" })).turnId, authored.turnId);
+  }
+});

package/test/conversationAgentRun.test.js

@@ -0,0 +1,326 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { conversationAgentRunEvent, conversationAgentRunRecord, createCodexConversationRunStore, createCodexConversationStore } from "../src/server/conversation/agentRun.js";
+import { createMemoryConversationStorage } from "../src/server/conversation/memoryStorage.js";
+import { createReentrantConversationStorage } from "../src/server/conversation/storage.js";
+import { createConversationTranscript } from "../src/server/conversation/transcript.js";
+import { createConversationStreams } from "../src/server/conversation/streams.js";
+
+const scope = "actor:workspace:conversation";
+const runId = "codex_app_server";
+const start = "2026-10-01T01:00:00.000Z";
+const finish = "2026-10-01T01:00:01.000Z";
+
+async function fixture() {
+  const memory = createMemoryConversationStorage();
+  let writes = 0;
+  const storage = createReentrantConversationStorage({
+    ...memory,
+    write(id, operation) { writes += 1; return memory.write(id, operation); }
+  });
+  await storage.write(scope, transaction => transaction.writeMetadata({
+    product: { retained: true },
+    runtime: { version: 3, engine: "codex", segmentId: "segment-one", binding: { threadId: "native-thread" },
+      request: { messageId: "authored-request", message: "Frozen native prompt", attempted: true } }
+  }));
+  let current = true;
+  const store = createCodexConversationRunStore({ storage, scope, segmentId: "segment-one",
+    isCurrent: () => current, clock: () => new Date(start) });
+  return { storage, store, writes: () => writes, retire: () => { current = false; } };
+}
+
+test("original run updater retains event, timestamp, state and unknown-field semantics", () => {
+  const initial = conversationAgentRunEvent({ id: runId, events: [], extension: { preserved: true } }, runId, {
+    event: { at: ` ${start} `, kind: " claim ", message: " event message ", extra: "event extension" },
+    patch: { state: " active ", message: "patch message", updatedAt: finish, startedAt: start,
+      providerThreadId: "native-thread", providerTurnId: "native-turn", outerTurnId: "outer-turn", error: "explicit" }
+  });
+  assert.deepEqual(initial, {
+    id: runId, events: [{ at: start, kind: "claim", message: "event message", extra: "event extension", state: "active" }],
+    extension: { preserved: true }, state: "active", message: "patch message", updatedAt: start, startedAt: start,
+    providerThreadId: "native-thread", providerTurnId: "native-turn", outerTurnId: "outer-turn", error: "explicit",
+    active: true, finishedAt: ""
+  });
+  const completed = conversationAgentRunEvent(initial, runId, {
+    event: { state: "failed", kind: "", message: "" },
+    patch: { state: "completed", updatedAt: finish, startedAt: finish, message: " complete ", finishedAt: finish }
+  });
+  assert.equal(completed.active, false);
+  assert.equal(completed.startedAt, start);
+  assert.equal(completed.finishedAt, finish);
+  assert.equal(completed.error, "explicit");
+  assert.deepEqual(completed.events, [...initial.events,
+    { state: "completed", kind: "completed", message: "complete", at: finish }]);
+  const next = conversationAgentRunEvent(completed, runId, { patch: { state: "starting" } }, { now: () => new Date(finish) });
+  assert.equal(next.startedAt, start);
+  assert.equal(next.finishedAt, "");
+  assert.equal(next.error, "");
+  assert.equal(next.active, true);
+  assert.deepEqual(next.extension, initial.extension);
+  for (const state of ["cancelled", "completed", "failed", "interrupted", "timed_out"]) {
+    const terminal = conversationAgentRunEvent(completed, runId, { patch: { state } }, { now: () => new Date(start) });
+    assert.equal(terminal.active, false);
+    assert.equal(terminal.finishedAt, finish);
+  }
+  assert.equal(conversationAgentRunEvent(initial, runId, { patch: { state: "active", error: null } }).error, null);
+});
+
+test("original run reader preserves unknown fields and filters events without inventing a run", async () => {
+  const f = await fixture();
+  const before = f.writes();
+  assert.equal(await f.store.readAgentRun(scope, runId), null);
+  assert.deepEqual(await f.store.getSession(scope), { sessionId: scope, agentRuns: [] });
+  assert.equal(f.writes(), before);
+  for (const value of [undefined, null, [], "invalid"]) assert.equal(conversationAgentRunRecord(value, runId), null);
+  assert.deepEqual(conversationAgentRunRecord({ id: "ignored", active: false, events: [null, [], "invalid", { kind: "saved" }],
+    pendingUserMessageClientIds: ["request"], extension: { one: 1 } }, runId), {
+    id: runId, active: true, events: [{ kind: "saved" }], state: "starting",
+    pendingUserMessageClientIds: ["request"], extension: { one: 1 }
+  });
+  for (const state of ["unknown", false, 0]) {
+    assert.throws(() => conversationAgentRunRecord({ state }, runId), { code: "codex_app_server_invalid_run_state" });
+  }
+});
+
+test("native run mutation joins transcript writes and reads in one existing transaction", { timeout: 3_000 }, async () => {
+  const f = await fixture();
+  const transcript = createConversationTranscript({ storage: f.storage });
+  const before = f.writes();
+  const result = await f.store.mutateSession(scope, async () => {
+    assert.deepEqual(await f.store.getSession(scope), { sessionId: scope, agentRuns: [] });
+    await transcript.writeConversationUserMessage(scope, { messageId: "authored-request", text: "Authored message" });
+    const run = await f.store.writeAgentRunEvent(scope, runId, {
+      event: { kind: "claimed", at: start },
+      patch: { state: "starting", outerTurnId: "outer-turn", pendingUserMessageClientIds: ["authored-request"], retained: [1, 2] }
+    });
+    assert.deepEqual((await f.store.getSession(scope)).agentRuns, [run]);
+    assert.equal((await transcript.readConversationLog(scope))[0].user.text, "Authored message");
+    return run;
+  });
+  assert.equal(f.writes(), before + 1, "Nested native and transcript operations use one host writer call.");
+  const saved = await f.storage.read(scope, transaction => transaction.readMetadata());
+  assert.deepEqual(saved.runtime.binding.codexAppServerRun, result);
+  assert.deepEqual(saved.runtime.request, { messageId: "authored-request", message: "Frozen native prompt", attempted: true });
+  assert.deepEqual(saved.product, { retained: true });
+  result.retained.push(3);
+  assert.deepEqual((await f.store.readAgentRun(scope, runId)).retained, [1, 2]);
+  await assert.rejects(f.store.mutateSession(scope, async () => {
+    await f.store.writeAgentRunEvent(scope, runId, { patch: { state: "active", providerTurnId: "uncommitted" } });
+    await transcript.writeConversationAssistantMessage(scope, { text: "Uncommitted answer" });
+    throw new Error("commit refused");
+  }), /commit refused/);
+  assert.equal((await f.store.readAgentRun(scope, runId)).providerTurnId, undefined);
+  assert.equal((await transcript.readConversationLog(scope))[0].assistant, null);
+});
+
+test("original active-participant lease drains nested work and queues escaped callbacks", { timeout: 3_000 }, async () => {
+  const f = await fixture();
+  const nestedEntered = Promise.withResolvers();
+  const nestedRelease = Promise.withResolvers();
+  const escapedRelease = Promise.withResolvers();
+  let nested, escaped;
+  let outerFinished = false;
+  const before = f.writes();
+  const outer = f.storage.write(scope, async transaction => {
+    const metadata = await transaction.readMetadata();
+    metadata.outer = true;
+    await transaction.writeMetadata(metadata);
+    escaped = escapedRelease.promise.then(() => f.storage.write(scope, async current => {
+      const latest = await current.readMetadata();
+      latest.escaped = true;
+      await current.writeMetadata(latest);
+    }));
+    nested = f.storage.write(scope, async current => {
+      nestedEntered.resolve();
+      await nestedRelease.promise;
+      const latest = await current.readMetadata();
+      latest.nested = true;
+      await current.writeMetadata(latest);
+    });
+  }).then(() => { outerFinished = true; });
+  await nestedEntered.promise;
+  // This independent scope must not borrow another scope's active draft.
+  await f.storage.write("other", transaction => transaction.writeMetadata({ other: true }));
+  assert.equal(outerFinished, false);
+  nestedRelease.resolve();
+  await Promise.all([outer, nested]);
+  assert.equal(f.writes(), before + 2);
+  escapedRelease.resolve();
+  await escaped;
+  assert.equal(f.writes(), before + 3, "An inactive inherited participant must re-enter the host queue.");
+  const saved = await f.storage.read(scope, transaction => transaction.readMetadata());
+  assert.equal(saved.outer, true);
+  assert.equal(saved.nested, true);
+  assert.equal(saved.escaped, true);
+  assert.equal(saved.other, undefined);
+  assert.deepEqual(await f.storage.read("other", transaction => transaction.readMetadata()), { other: true });
+});
+
+test("native run mutation refuses stale owners, changed segments and cross-conversation access", { timeout: 3_000 }, async () => {
+  const f = await fixture();
+  await f.store.writeAgentRunEvent(scope, runId, { patch: { state: "completed", providerTurnId: "old-turn" } });
+  await assert.rejects(f.store.readAgentRun("other", runId), /another conversation/);
+  await assert.rejects(f.store.writeAgentRunEvent(scope, "another-run", {}), /only its Codex/);
+  const blocked = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  const changing = f.storage.write(scope, async transaction => {
+    blocked.resolve();
+    await release.promise;
+    const metadata = await transaction.readMetadata();
+    metadata.runtime.segmentId = "successor";
+    metadata.runtime.binding = { threadId: "successor-thread" };
+    await transaction.writeMetadata(metadata);
+  });
+  await blocked.promise;
+  const stale = f.store.writeAgentRunEvent(scope, runId, { patch: { state: "active" } });
+  release.resolve();
+  await changing;
+  await assert.rejects(stale, /retired native conversation/);
+  assert.deepEqual((await f.storage.read(scope, transaction => transaction.readMetadata())).runtime.binding,
+    { threadId: "successor-thread" });
+  f.retire();
+  await assert.rejects(f.store.writeAgentRunEvent(scope, runId, {}), /retired provider/);
+});
+
+
+test("late native authored receipts retain their exact request after the durable request changes", async () => {
+  const f = await fixture();
+  const transcript = createConversationTranscript({ storage: f.storage });
+  const store = createCodexConversationStore({ storage: f.storage, scope, segmentId: "segment-one",
+    isCurrent: () => true, transcript, streams: createConversationStreams() });
+  const authoredRequest = { messageId: "late-authored", text: "Original authorized message", origin: "application", at: start,
+    data: { request: "original" }, attachments: [{ attachmentId: "receipt", fileName: "saved.png", size: 4 }] };
+  await f.storage.write(scope, async transaction => {
+    const metadata = await transaction.readMetadata();
+    metadata.runtime.request = { messageId: "new-request", text: "A different request", data: { request: "new" } };
+    await transaction.writeMetadata(metadata);
+  });
+  const written = await store.writeConversationUserMessage(scope, {
+    messageId: authoredRequest.messageId, text: "Rendered native text is not the authored message",
+    authoredRequest, nativeIdentity: { threadId: "native-thread", turnId: "accepted-turn" }
+  });
+  assert.equal(written.system.text, authoredRequest.text);
+  assert.equal(written.system.at, start);
+  assert.deepEqual(written.system.data, authoredRequest.data);
+  assert.deepEqual(written.system.attachments, authoredRequest.attachments);
+  assert.equal(written.metadata.runtime.segmentId, "segment-one");
+  assert.equal(written.metadata.runtime.origin, "application");
+  assert.equal(written.metadata.runtime.nativeTurnId, "accepted-turn");
+  assert.equal(JSON.stringify(written).includes("nativeIdentity"), false);
+  assert.equal(JSON.stringify(written).includes("Rendered native"), false);
+  assert.equal(await store.writeConversationUserMessage(scope, { messageId: authoredRequest.messageId, authoredRequest }), null);
+  assert.equal((await transcript.readConversationLog(scope)).length, 1);
+  assert.equal((await f.storage.read(scope, transaction => transaction.readMetadata())).runtime.request.messageId, "new-request");
+});
+
+test("native output uses its exact notification identity after the stored run advances", async () => {
+  const f = await fixture();
+  const transcript = createConversationTranscript({ storage: f.storage });
+  const store = createCodexConversationStore({ storage: f.storage, scope, segmentId: "segment-one",
+    isCurrent: () => true, transcript, streams: createConversationStreams() });
+  await store.writeAgentRunEvent(scope, runId, { patch: {
+    state: "active", providerThreadId: "native-thread", providerTurnId: "successor-turn"
+  } });
+  const written = await store.writeConversationAssistantMessage(scope, {
+    messageId: "native-response", text: "Exact earlier response",
+    nativeIdentity: { threadId: "native-thread", turnId: "earlier-turn" }
+  });
+  assert.equal(written.metadata.runtime.nativeTurnId, "earlier-turn");
+  assert.equal(written.metadata.runtime.origin, undefined);
+  assert.equal(JSON.stringify(written).includes("nativeIdentity"), false);
+  assert.equal((await store.readAgentRun(scope, runId)).providerTurnId, "successor-turn");
+  const corrected = await store.upsertConversationAssistantMessage(scope, {
+    turnId: written.turnId, text: "Exact corrected response",
+    nativeIdentity: { threadId: "native-thread", turnId: "earlier-turn" }
+  });
+  assert.equal(corrected.metadata.runtime.nativeTurnId, "earlier-turn");
+  assert.equal(corrected.assistant.text, "Exact corrected response");
+  assert.equal((await transcript.readConversationLog(scope)).length, 1);
+});
+
+test("native stream origin uses only its exact authorized pending request before the authored row exists", async () => {
+  for (const origin of ["user", "application"]) {
+    const f = await fixture();
+    const transcript = createConversationTranscript({ storage: f.storage, applicationTurns: true });
+    const store = createCodexConversationStore({ storage: f.storage, scope, segmentId: "segment-one",
+      isCurrent: () => true, transcript, streams: createConversationStreams() });
+    const nativeIdentity = { threadId: "native-thread", turnId: "native-turn" };
+    await f.storage.write(scope, async transaction => {
+      const metadata = await transaction.readMetadata();
+      metadata.runtime.request.origin = origin;
+      await transaction.writeMetadata(metadata);
+    });
+    await store.writeAgentRunEvent(scope, runId, { patch: { state: "active",
+      providerThreadId: nativeIdentity.threadId, providerTurnId: nativeIdentity.turnId, outerTurnId: "authored-request" } });
+    const stream = await store.updateConversationStream(scope, { nativeIdentity,
+      turnId: "native-thread:native-turn", messageId: "first-live-reply", text: "Reply before receipt" });
+    assert.equal(stream.messages[0].origin, origin);
+    assert.equal(Object.hasOwn(stream.messages[0], "turnId"), false);
+    assert.equal(JSON.stringify(stream).includes("nativeIdentity"), false);
+    assert.deepEqual(await transcript.readConversationLog(scope), []);
+    for (const identity of [{ threadId: "another-thread", turnId: "native-turn" },
+      { threadId: "native-thread", turnId: "earlier-turn" }]) {
+      const unproven = await store.updateConversationStream(scope, { nativeIdentity: identity,
+        turnId: `${identity.threadId}:${identity.turnId}`, messageId: "unproven", text: "Unproven reply" });
+      assert.equal(unproven.messages[0].origin, undefined);
+      assert.equal(Object.hasOwn(unproven.messages[0], "turnId"), false);
+    }
+    await f.storage.write(scope, async transaction => {
+      const metadata = await transaction.readMetadata();
+      metadata.runtime.request.messageId = "unrelated-pending-request";
+      await transaction.writeMetadata(metadata);
+    });
+    const unrelated = await store.updateConversationStream(scope, { nativeIdentity,
+      turnId: "native-thread:native-turn", messageId: "unrelated", text: "No matching request" });
+    assert.equal(unrelated.messages[0].origin, undefined);
+    assert.equal(Object.hasOwn(unrelated.messages[0], "turnId"), false);
+    assert.deepEqual(await transcript.readConversationLog(scope), []);
+  }
+});
+
+test("native output origin joins only its exact outer authored request and preserves saved grouping", async () => {
+  for (const origin of ["user", "application"]) {
+    const f = await fixture();
+    const transcript = createConversationTranscript({ storage: f.storage, applicationTurns: true });
+    const streams = createConversationStreams();
+    const store = createCodexConversationStore({ storage: f.storage, scope, segmentId: "segment-one",
+      isCurrent: () => true, transcript, streams });
+    const nativeIdentity = { threadId: "native-thread", turnId: "native-turn" };
+    const authoredRequest = { messageId: "outer-request", text: "Authorized request", origin };
+    const authored = await store.writeConversationUserMessage(scope, {
+      messageId: authoredRequest.messageId, authoredRequest, nativeIdentity
+    });
+    await store.writeAgentRunEvent(scope, runId, { patch: { state: "active",
+      providerThreadId: nativeIdentity.threadId, providerTurnId: nativeIdentity.turnId, outerTurnId: authoredRequest.messageId } });
+    const streaming = await store.updateConversationStream(scope, { nativeIdentity,
+      turnId: "native-thread:native-turn", messageId: "live-reply", text: "Live reply" });
+    assert.equal(streaming.messages[0].origin, origin);
+    assert.equal(Object.hasOwn(streaming.messages[0], "turnId"), false);
+    assert.equal(JSON.stringify(streaming).includes("nativeIdentity"), false);
+    const first = await store.writeConversationAssistantMessage(scope, {
+      nativeIdentity, messageId: "first-reply", text: "First reply"
+    });
+    const second = await store.writeConversationAssistantMessage(scope, {
+      nativeIdentity, messageId: "second-reply", text: "Second reply"
+    });
+    assert.equal(first.turnId, authored.turnId);
+    assert.notEqual(second.turnId, authored.turnId);
+    assert.equal(second.user, null);
+    assert.equal(second.system, undefined);
+    assert.equal(second.metadata.runtime.origin, origin);
+    assert.equal((await transcript.readConversationLog(scope)).length, 2);
+    for (const identity of [{ threadId: "another-thread", turnId: "native-turn" },
+      { threadId: "native-thread", turnId: "earlier-turn" }]) {
+      const snapshot = await store.updateConversationStream(scope, { nativeIdentity: identity,
+        turnId: `${identity.threadId}:${identity.turnId}`, messageId: "unproven", text: "Unproven reply" });
+      assert.equal(snapshot.messages[0].origin, undefined);
+      assert.equal(Object.hasOwn(snapshot.messages[0], "turnId"), false);
+    }
+    await f.storage.write(scope, transaction => transaction.updateTurnMetadata(authored.turnId,
+      { runtime: { ...authored.metadata.runtime, segmentId: "another-segment" } }));
+    const unowned = await store.writeConversationAssistantMessage(scope, {
+      nativeIdentity, messageId: "unowned-reply", text: "Reply without a matching authored segment"
+    });
+    assert.equal(unowned.metadata.runtime.origin, undefined);
+  }
+});

package/test/conversationApiFacilities.test.js

@@ -0,0 +1,90 @@
+import assert from "node:assert/strict";
+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 { createConversationRuntime, createFileConversationStorage, createMemoryConversationStorage } from "../src/server/conversation/index.js";
+
+test("API configuration rejects unsupported structured output before resolving an account or sending", async t => {
+  let resolved = 0;
+  const runtime = createConversationRuntime({ storage: createMemoryConversationStorage(), authorize: () => true,
+    apiClientFactory: { resolveClient() { resolved++; assert.fail("Unsupported structured output cannot start inference"); } } });
+  t.after(() => runtime.close());
+  const configuration = { systemPrompt: "Use the supplied instructions" };
+  await assert.rejects(runtime.open({ id: "unsupported", configuration: { ...configuration,
+    outputSchema: { type: "string", maxLength: 16 } } }), /API does not support structured output/);
+  assert.equal(resolved, 0);
+  const ordinary = await runtime.open({ id: "ordinary", configuration });
+  assert.equal(ordinary.capabilities.structuredOutput, false);
+  await assert.rejects(ordinary.configure({ outputSchema: { type: "string", maxLength: 16 } }), /API does not support structured output/);
+  assert.deepEqual((await ordinary.read()).configuration, configuration);
+  assert.equal(resolved, 0);
+});
+
+test("an existing API client keeps opaque receipts path-safe and selected history private without replacing canonical history", async t => {
+  const directory = await mkdtemp(join(tmpdir(), "conversation-api-client-"));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const requests = [], resolvedAttachments = [];
+  const context = { subjectId: "owner", history: [
+    { role: "user", content: "Selected prior context", attachmentIds: ["historical"] },
+    { role: "assistant", content: "Selected prior response" }
+  ] };
+  const runtime = createConversationRuntime({
+    storage: createFileConversationStorage({ directory }),
+    authorize: ({ context }) => context.subjectId === "owner",
+    apiHistory: ({ context }) => context.history,
+    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" }] };
+        })();
+      } };
+    } },
+    attachments: { async resolve({ attachmentIds, context: actor, conversationId }) {
+      assert.equal(actor, context);
+      assert.equal(conversationId, "sql/conversation");
+      resolvedAttachments.push([...attachmentIds]);
+      return { attachments: attachmentIds.map(attachmentId => ({ attachmentId, fileName: `${attachmentId}.txt`, size: 12 })),
+        content: attachmentIds.map(attachmentId => ({ type: "text", text: `Authorized ${attachmentId} bytes` })) };
+    } }
+  });
+  t.after(() => runtime.close());
+  const conversation = await runtime.open({ id: "sql/conversation", context,
+    configuration: { systemPrompt: "Existing instructions", model: "existing-model" } });
+  const messageId = "../invoice/42:follow-up";
+  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.deepEqual(resolvedAttachments, [["current"], ["historical"]]);
+  assert.deepEqual(requests[0][1], { role: "user", content: [
+    { type: "text", text: "Selected prior context" }, { type: "text", text: "Authorized historical bytes" }
+  ] });
+  assert.deepEqual(requests[0].at(-1), { role: "user", content: [
+    { type: "text", text: "Current question" }, { type: "text", text: "Authorized current bytes" }
+  ] });
+  const files = await readdir(directory);
+  assert.equal(files.length, 1);
+  assert.match(files[0], /^[a-f0-9]{64}\.json$/);
+  const persisted = await readFile(join(directory, files[0]), "utf8");
+  assert.match(persisted, /invoice\/42:follow-up/);
+  assert.doesNotMatch(persisted, /Selected prior|Authorized .* bytes/);
+
+  context.history = undefined;
+  await conversation.send({ messageId: "next", text: "Use canonical history" });
+  await conversation.wait();
+  assert.equal(requests[1].some(message => Array.isArray(message.content) && message.content[0]?.text === "Current question"), true);
+  assert.equal(requests[1].some(message => message.content === "Selected prior response"), false);
+
+  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.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);
+});