@jskit-ai/assistant-core 0.1.205 → 0.1.206

package/test/aiConnectionClient.test.js

@@ -159,3 +159,212 @@ test("authorized image bytes use the selected provider protocol", async () => {
   ] }] }));
   assert.equal(chunks[0].choices[0].delta.content, "An image");
 });
+
+test("SDK streaming rejects its first provider failure before EOF without exposing later output", { timeout: 5000 }, async t => {
+  const source = new TransformStream();
+  const writer = source.writable.getWriter();
+  t.after(() => writer.abort().catch(() => {}));
+  let requests = 0;
+  const client = createAiConnectionClient(await publicConnection(), {
+    async fetch(url, options) {
+      requests++;
+      assert.equal(String(url), "https://opencode.ai/zen/v1/chat/completions");
+      assert.equal(new Headers(options.headers).get("authorization"), "Bearer public");
+      assert.equal(JSON.parse(options.body).tools[0].function.name, "lookup");
+      return new Response(source.readable, { headers: { "content-type": "text/event-stream" } });
+    }
+  });
+  const tools = [{ type: "function", function: { name: "lookup", parameters: {
+    type: "object", properties: { query: { type: "string" } }, required: ["query"]
+  } } }];
+  const iterator = client.createChatCompletionStream({ messages: [{ role: "user", content: "Find records" }], tools });
+  const send = data => writer.write(new TextEncoder().encode(`data: ${JSON.stringify(data)}\n\n`));
+  const first = iterator.next();
+  await send({ choices: [{ index: 0, delta: { content: "Before failure" } }] });
+  assert.deepEqual((await first).value, { choices: [{ delta: { content: "Before failure" } }] });
+  let settled = false;
+  const ending = iterator.next().then(
+    result => { settled = true; return { result }; },
+    error => { settled = true; return { error }; }
+  );
+  const firstFailure = { message: "First provider failure", code: "FIRST_FAILURE" };
+  await send({ error: firstFailure });
+  await new Promise(resolve => setImmediate(resolve));
+  assert.equal(settled, true, "the original provider failure rejects before any late output or transport EOF");
+  await send({ choices: [{ index: 0, delta: { content: "Must not be exposed" } }] });
+  await send({ choices: [{ index: 0, delta: { tool_calls: [
+    { index: 0, id: "late_call", type: "function", function: { name: "lookup", arguments: '{"query":"records"}' } }
+  ] } }] });
+  await send({ error: { message: "Later provider failure", code: "LATER_FAILURE" } });
+  await send({ choices: [{ index: 0, delta: {}, finish_reason: "tool_calls" }],
+    usage: { prompt_tokens: 3, completion_tokens: 4, total_tokens: 7 } });
+  await new Promise(resolve => setImmediate(resolve));
+  assert.equal(settled, true, "the original provider failure rejects before transport EOF");
+  await writer.close();
+  const outcome = await ending;
+  assert.equal(outcome.error?.name, "AI_StreamProviderError");
+  assert.equal(outcome.error.message, firstFailure.message);
+  assert.equal(outcome.error.code, firstFailure.code);
+  assert.deepEqual(outcome.error.data, firstFailure, "a later provider error must not replace the first failure");
+  assert.equal(outcome.result, undefined, "late text, tool calls, finish and usage never become a yielded chunk");
+  assert.equal((await iterator.next()).done, true);
+  assert.equal(requests, 1, "draining a failed stream must not retry or start a tool round");
+});
+
+test("SDK streaming rejects the first invalid tool input without yielding later calls or completion", { timeout: 5000 }, async t => {
+  const source = new TransformStream();
+  const writer = source.writable.getWriter();
+  t.after(() => writer.abort().catch(() => {}));
+  let requests = 0;
+  const client = createAiConnectionClient(await publicConnection(), {
+    async fetch() {
+      requests++;
+      return new Response(source.readable, { headers: { "content-type": "text/event-stream" } });
+    }
+  });
+  const tools = [{ type: "function", function: { name: "lookup", parameters: {
+    type: "object", properties: { query: { type: "string" } }, required: ["query"]
+  } } }];
+  const iterator = client.createChatCompletionStream({ messages: [{ role: "user", content: "Find records" }], tools });
+  const send = data => writer.write(new TextEncoder().encode(`data: ${JSON.stringify(data)}\n\n`));
+  const first = iterator.next();
+  await send({ choices: [{ index: 0, delta: { content: "Before tool validation" } }] });
+  assert.equal((await first).value.choices[0].delta.content, "Before tool validation");
+  const ending = iterator.next().then(result => ({ result }), error => ({ error }));
+  // The compatible adapter flushes these calls at EOF; malformed JSON reaches
+  // the SDK's invalid-input branch rather than relying on schema validation.
+  await send({ choices: [{ index: 0, delta: { tool_calls: [
+    { index: 0, id: "invalid_first", type: "function", function: { name: "lookup", arguments: '{"query":}' } },
+    { index: 1, id: "invalid_later", type: "function", function: { name: "lookup", arguments: '{"later":}' } },
+    { index: 2, id: "valid_later", type: "function", function: { name: "lookup", arguments: '{"query":"records"}' } }
+  ] }, finish_reason: "tool_calls" }], usage: { prompt_tokens: 3, completion_tokens: 4, total_tokens: 7 } });
+  await writer.close();
+  const outcome = await ending;
+  assert.equal(outcome.error?.name, "AI_InvalidToolInputError");
+  assert.equal(outcome.error.toolName, "lookup");
+  assert.equal(outcome.error.toolInput, '{"query":}', "the second invalid call cannot replace the first error");
+  assert.equal(outcome.result, undefined, "invalid and later valid calls, finish and usage remain unexposed");
+  assert.equal((await iterator.next()).done, true);
+  assert.equal(requests, 1);
+});
+
+test("SDK cancellation after its first text retains the original reason and suppresses later output", { timeout: 5000 }, async t => {
+  const source = new TransformStream();
+  const writer = source.writable.getWriter();
+  t.after(() => writer.abort().catch(() => {}));
+  const abort = new AbortController();
+  const reason = new Error("Stopped after the first text");
+  let requestSignal;
+  let requests = 0;
+  const client = createAiConnectionClient(await publicConnection(), {
+    async fetch(_url, options) {
+      requests++;
+      requestSignal = options.signal;
+      return new Response(source.readable, { headers: { "content-type": "text/event-stream" } });
+    }
+  });
+  const iterator = client.createChatCompletionStream({ messages: [{ role: "user", content: "Hello" }], signal: abort.signal });
+  const send = data => writer.write(new TextEncoder().encode(`data: ${JSON.stringify(data)}\n\n`));
+  const first = iterator.next();
+  await send({ choices: [{ index: 0, delta: { content: "First text" } }] });
+  assert.equal((await first).value.choices[0].delta.content, "First text");
+  const ending = iterator.next().then(result => ({ result }), error => ({ error }));
+  abort.abort(reason);
+  assert.equal(requestSignal.aborted, true);
+  assert.equal(requestSignal.reason, reason);
+  // Fetch remains controlled: let the real SDK observe abort while consuming
+  // the response, then finish the transport instead of replacing its runner.
+  await send({ choices: [{ index: 0, delta: { content: "Late text" } }] });
+  await send({ choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+    usage: { prompt_tokens: 1, completion_tokens: 2, total_tokens: 3 } });
+  await writer.close();
+  const outcome = await ending;
+  assert.equal(outcome.error, reason);
+  assert.equal(outcome.result, undefined, "abort after text cannot publish later text, finish or usage");
+  assert.equal((await iterator.next()).done, true);
+  assert.equal(requests, 1);
+});
+
+test("SDK streaming retains its immediate provider failure when the later transport fails", { timeout: 5000 }, async t => {
+  const source = new TransformStream();
+  const writer = source.writable.getWriter();
+  t.after(() => writer.abort().catch(() => {}));
+  let requests = 0;
+  const client = createAiConnectionClient(await publicConnection(), {
+    async fetch() {
+      requests++;
+      return new Response(source.readable, { headers: { "content-type": "text/event-stream" } });
+    }
+  });
+  const iterator = client.createChatCompletionStream({ messages: [{ role: "user", content: "Hello" }] });
+  const send = data => writer.write(new TextEncoder().encode(`data: ${JSON.stringify(data)}\n\n`));
+  const first = iterator.next();
+  await send({ choices: [{ index: 0, delta: { content: "Before failure" } }] });
+  assert.equal((await first).value.choices[0].delta.content, "Before failure");
+  let settled = false;
+  const ending = iterator.next().then(
+    result => { settled = true; return { result }; },
+    error => { settled = true; return { error }; }
+  );
+  const firstFailure = { message: "First provider failure", code: "FIRST_FAILURE" };
+  await send({ error: firstFailure });
+  await new Promise(resolve => setImmediate(resolve));
+  assert.equal(settled, true, "the first failure rejects before the later transport error");
+  await send({ choices: [{ index: 0, delta: { content: "Late text after rejection" } }] });
+  await new Promise(resolve => setImmediate(resolve));
+  assert.equal(settled, true, "the original provider failure rejects without waiting for later transport failure");
+  const lateTransportError = new Error("Late transport drain failure");
+  await writer.abort(lateTransportError);
+  const outcome = await ending;
+  assert.notEqual(outcome.error, lateTransportError, "transport drain failure must not replace the observed provider failure");
+  assert.equal(outcome.error?.name, "AI_StreamProviderError");
+  assert.equal(outcome.error.message, firstFailure.message);
+  assert.equal(outcome.error.code, firstFailure.code);
+  assert.deepEqual(outcome.error.data, firstFailure);
+  assert.equal(outcome.result, undefined, "late text and transport failure do not publish another chunk");
+  assert.equal((await iterator.next()).done, true);
+  assert.equal(requests, 1);
+});
+
+
+test("only explicit application-catalogue mode reports well-formed unavailable tool calls", async () => {
+  const toolCall = argumentsText => ({ choices: [{ index: 0, delta: { tool_calls: [
+    { index: 0, id: "unavailable-call", type: "function", function: { name: "unavailable_action", arguments: argumentsText } }
+  ] }, finish_reason: "tool_calls" }] });
+  const connection = await publicConnection();
+  for (const [reportUnavailableToolCalls, argumentsText] of [
+    [false, '{"value":"must not execute"}'], [true, '{"value":}'], [true, 'null'], [true, '[]'], [true, '"text"']
+  ]) {
+    let requests = 0;
+    const client = createAiConnectionClient(connection, { reportUnavailableToolCalls,
+      async fetch() { requests++; return eventsResponse([toolCall(argumentsText)]); }
+    });
+    await assert.rejects(Array.fromAsync(client.createChatCompletionStream({
+      messages: [{ role: "user", content: "Check without changing anything" }], tools: []
+    })), error => error.name === "AI_NoSuchToolError" && error.toolName === "unavailable_action");
+    assert.equal(requests, 1, "unavailable validation must not trigger an inference retry");
+  }
+  const invalidKnown = createAiConnectionClient(connection, { reportUnavailableToolCalls: true,
+    async fetch() { return eventsResponse([{ choices: [{ index: 0, delta: { tool_calls: [
+      { index: 0, id: "invalid-known", type: "function", function: { name: "lookup", arguments: '{"query":}' } }
+    ] }, finish_reason: "tool_calls" }] }]); }
+  });
+  await assert.rejects(Array.fromAsync(invalidKnown.createChatCompletionStream({
+    messages: [{ role: "user", content: "Find records" }],
+    tools: [{ type: "function", function: { name: "lookup", parameters: {
+      type: "object", properties: { query: { type: "string" } }, required: ["query"]
+    } } }]
+  })), error => error.name === "AI_InvalidToolInputError" && error.toolName === "lookup");
+  let requests = 0;
+  const client = createAiConnectionClient(connection, { reportUnavailableToolCalls: true,
+    async fetch() { requests++; return eventsResponse([toolCall('{"value":"must not execute"}')]); }
+  });
+  const chunks = await Array.fromAsync(client.createChatCompletionStream({
+    messages: [{ role: "user", content: "Check without changing anything" }], tools: []
+  }));
+  assert.deepEqual(chunks.flatMap(chunk => chunk.choices[0].delta.tool_calls || []), [{
+    index: 0, id: "unavailable-call", function: { name: "unavailable_action", arguments: '{"value":"must not execute"}' }
+  }]);
+  assert.equal(chunks.at(-1).choices[0].finish_reason, "tool-calls");
+  assert.equal(requests, 1, "reporting the attempted call neither executes an action nor starts another request");
+});

package/test/assistantScroll.browser.test.js

@@ -405,7 +405,10 @@ test("upward scrolling loads older history once and preserves retry and selectio
       await expect(page.getByText("Conversation line 70:", { exact: false })).toBeVisible();
       await expect(requests).toHaveText("History requests: 3");
       await external("Exhaust history");
-      await body.focus();
+      await expect.poll(async () => {
+        await body.focus();
+        return body.evaluate(element => document.activeElement === element);
+      }).toBe(true);
       await body.press("Home");
       await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(0);
       await expect(requests).toHaveText("History requests: 3");
@@ -420,6 +423,206 @@ test("upward scrolling loads older history once and preserves retry and selectio
   }
 });
 
+test("retained hidden transcripts preserve readers and follow only at the latest message", {
+  skip: !RUN_BROWSER_TEST,
+  timeout: 90_000
+}, async () => {
+  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
+  const browser = await chromium.launch(createChromiumLaunchOptions());
+  try {
+    for (const width of [390, 800, 1365]) {
+      const page = await browser.newPage({ viewport: { width, height: 900 } });
+      await page.goto(`${vite.baseURL}/?controls=1&history=1&retain-hidden=1&initial-hidden=1`);
+      const body = page.locator(".assistant-transcript__body");
+      const external = name => page.getByRole("button", { name, exact: true }).evaluate(element => element.click());
+      await expect(body).toBeAttached();
+      await expect(body).toBeHidden();
+      await external("Toggle visibility");
+      await expect(body).toBeVisible();
+      await expect(page.locator(".assistant-transcript__settling")).toHaveCount(0);
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+      const draft = page.getByRole("textbox", { name: "Message AI assistant", exact: true });
+      await draft.fill("Keep my typed draft");
+      await body.hover();
+      await page.mouse.wheel(0, -1000);
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeGreaterThan(50);
+      await body.evaluate(element => { element.scrollTop = 420; });
+      await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(420);
+      await body.evaluate(element => {
+        window.retainedBody = element;
+        const top = element.getBoundingClientRect().top;
+        const anchor = [...element.querySelectorAll(".assistant-transcript__turn")].find(turn => turn.getBoundingClientRect().bottom > top);
+        window.retainedAnchor = { element: anchor, offset: anchor.getBoundingClientRect().top - top };
+      });
+      await external("Toggle visibility");
+      await expect(body).toBeHidden();
+      await external("Append reply");
+      // Hidden zero-geometry events must not change following or fetch history.
+      await body.evaluate(element => element.dispatchEvent(new Event("scroll")));
+      await expect(page.locator("output")).toHaveText("History requests: 0");
+      await external("Toggle visibility");
+      await expect(body).toBeVisible();
+      assert.equal(await body.evaluate(element => element === window.retainedBody), true);
+      await expect.poll(() => body.evaluate(element => Math.abs(window.retainedAnchor.element.getBoundingClientRect().top - element.getBoundingClientRect().top - window.retainedAnchor.offset))).toBeLessThan(2);
+      await expect(draft).toHaveValue("Keep my typed draft");
+      await body.hover();
+      await page.mouse.wheel(0, 100_000);
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+      await external("Toggle visibility");
+      await external("Append reply");
+      await external("Toggle visibility");
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+      await body.hover();
+      await page.mouse.wheel(0, -1000);
+      await external("Toggle visibility");
+      await external("Change conversation");
+      await external("Toggle visibility");
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+      await expect(page.locator(".assistant-transcript__settling")).toHaveCount(0);
+      assert.ok(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth));
+      await page.close();
+    }
+  } finally {
+    await browser.close();
+    await stopProcess(vite);
+  }
+});
+
+test("transient update errors keep the loaded transcript, reader, draft and focus in a compact banner", {
+  skip: !RUN_BROWSER_TEST,
+  timeout: 90_000
+}, async () => {
+  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
+  const browser = await chromium.launch(createChromiumLaunchOptions());
+  try {
+    for (const width of [390, 800, 1365]) {
+      const page = await browser.newPage({ viewport: { width, height: 900 } });
+      await page.goto(`${vite.baseURL}/?controls=1&history=1&update-errors=1`);
+      const body = page.locator(".assistant-transcript__body");
+      const draft = page.getByRole("textbox", { name: "Message AI assistant", exact: true });
+      const external = name => page.getByRole("button", { name, exact: true }).evaluate(element => element.click());
+      await expect(page.locator(".assistant-transcript__settling")).toHaveCount(0);
+      await draft.fill("Keep my draft while updates reconnect.");
+      await body.hover();
+      await page.mouse.wheel(0, -1000);
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeGreaterThan(50);
+      await body.evaluate(element => { element.scrollTop = 420; window.updateErrorBody = element; });
+      await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(420);
+      await draft.evaluate(element => {
+        element.focus({ preventScroll: true });
+        element.setSelectionRange(2, 7);
+        window.updateErrorDraft = element;
+      });
+      const rows = await body.locator(".assistant-transcript__turn").count();
+      await external("Show update error");
+      const banner = page.locator(".assistant-transcript__error");
+      await expect(banner).toContainText("Conversation updates are temporarily unavailable. Reload to reconnect; the assistant may still be working.");
+      await expect(banner.getByRole("button", { name: "Reload chat", exact: true })).toBeVisible();
+      await expect(body).toBeVisible();
+      assert.equal(await body.evaluate(element => element === window.updateErrorBody), true);
+      await expect(body.locator(".assistant-transcript__turn")).toHaveCount(rows);
+      await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(420);
+      await expect(draft).toHaveValue("Keep my draft while updates reconnect.");
+      await expect(draft).toBeFocused();
+      assert.deepEqual(await draft.evaluate(element => [element === window.updateErrorDraft, element.selectionStart, element.selectionEnd]), [true, 2, 7]);
+      const transcriptBox = await page.locator(".assistant-transcript").boundingBox();
+      const bannerBox = await banner.boundingBox();
+      const bodyBox = await body.boundingBox();
+      assert.ok(bannerBox.height < transcriptBox.height / 3);
+      assert.ok(bodyBox.height > transcriptBox.height / 2);
+      assert.ok(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth));
+      await banner.getByRole("button", { name: "Reload chat", exact: true }).click();
+      await expect(banner).toHaveCount(0);
+      await expect(page.locator(".assistant-conversation")).toHaveAttribute("data-error-reloads", "1");
+      assert.equal(await body.evaluate(element => element === window.updateErrorBody), true);
+      await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(420);
+      await expect(draft).toHaveValue("Keep my draft while updates reconnect.");
+      await expect(page.locator("output")).toHaveText("History requests: 0");
+      await body.hover();
+      await page.mouse.wheel(0, 100_000);
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+      await external("Show update error");
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+      await banner.getByRole("button", { name: "Reload chat", exact: true }).click();
+      await expect(banner).toHaveCount(0);
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+      await expect(page.locator(".assistant-conversation")).toHaveAttribute("data-error-reloads", "2");
+      await page.close();
+    }
+  } finally {
+    await browser.close();
+    await stopProcess(vite);
+  }
+});
+
+test("retained hidden history loads restore their original anchor and invalidate retired requests", {
+  skip: !RUN_BROWSER_TEST,
+  timeout: 90_000
+}, async () => {
+  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
+  const browser = await chromium.launch(createChromiumLaunchOptions());
+  try {
+    for (const width of [390, 800, 1365]) {
+      const page = await browser.newPage({ viewport: { width, height: 900 } });
+      const body = page.locator(".assistant-transcript__body");
+      const external = name => page.getByRole("button", { name, exact: true }).evaluate(element => element.click());
+      const load = async () => {
+        await page.goto(`${vite.baseURL}/?controls=1&history=1&paged-history=1&retain-hidden=1`);
+        await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+        await body.evaluate(element => {
+          element.dispatchEvent(new WheelEvent("wheel", { bubbles: true, deltaY: -1000 }));
+          element.scrollTop = 0;
+          element.dispatchEvent(new Event("scroll", { bubbles: true }));
+        });
+        await expect(page.getByRole("button", { name: "Loading older messages…", exact: true })).toBeDisabled();
+      };
+      await load();
+      const anchor = page.getByText("user message 21.", { exact: false });
+      const before = (await anchor.boundingBox()).y;
+      await body.evaluate(element => { window.retainedBody = element; });
+      await external("Toggle visibility");
+      await external("Complete history load");
+      await expect(page.getByText("user message 1.", { exact: false })).toHaveCount(1);
+      await expect(body).toBeHidden();
+      await external("Toggle visibility");
+      assert.equal(await body.evaluate(element => element === window.retainedBody), true);
+      await expect(body).toBeVisible();
+      await expect.poll(async () => Math.abs((await anchor.boundingBox()).y - before)).toBeLessThan(2);
+      await expect(page.locator("output")).toHaveText("History requests: 1");
+
+      await load();
+      const errorScrollTop = await body.evaluate(element => element.scrollTop);
+      await external("Toggle visibility");
+      await external("Fail history load");
+      await external("Toggle visibility");
+      await expect(page.getByText("History unavailable", { exact: true })).toBeVisible();
+      assert.equal(await body.evaluate(element => element.scrollTop), errorScrollTop, "unchanged/error completion preserves the original scrollTop while showing recovery");
+      await page.getByRole("button", { name: "Load older messages", exact: true }).evaluate(element => element.click());
+      await expect(page.locator("output")).toHaveText("History requests: 2");
+      await external("Toggle visibility");
+      await external("Change conversation");
+      await external("Complete history load");
+      await external("Toggle visibility");
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+
+      await load();
+      await body.evaluate(element => { window.retiredBody = element; });
+      await external("Toggle visibility");
+      await external("Toggle mount");
+      await external("Complete history load");
+      await external("Toggle mount");
+      await external("Toggle visibility");
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+      assert.equal(await body.evaluate(element => element === window.retiredBody), false);
+      await expect(page.locator("output")).toHaveText("History requests: 1");
+      await page.close();
+    }
+  } finally {
+    await browser.close();
+    await stopProcess(vite);
+  }
+});
+
 test("conversation composer preserves typing and reacts to external state and pane resizing", {
   skip: !RUN_BROWSER_TEST,
   timeout: 60_000
@@ -895,3 +1098,54 @@ test("unsent preview edits stay in their bubble and disappear for the canonical
     await stopProcess(vite);
   }
 });
+
+
+test("pending history keeps following the reader when a new reply changes transcript height", {
+  skip: !RUN_BROWSER_TEST,
+  timeout: 90_000
+}, async () => {
+  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
+  const browser = await chromium.launch(createChromiumLaunchOptions());
+  try {
+    for (const width of [390, 1365]) {
+      const page = await browser.newPage({ viewport: { width, height: 900 } });
+      const errors = [];
+      page.on("pageerror", error => errors.push(error.message));
+      await page.goto(`${vite.baseURL}/?controls=1&history=1`);
+      const body = page.locator(".assistant-transcript__body");
+      const requests = page.locator("output");
+      const external = name => page.getByRole("button", { name, exact: true }).evaluate(element => element.click());
+      await expect(page.getByText("Conversation line 70:", { exact: false })).toBeVisible();
+      await body.hover();
+      await page.mouse.wheel(0, -100);
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeGreaterThan(50);
+      await body.evaluate(element => { element.scrollTop = 420; });
+      await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(420);
+      await page.mouse.wheel(0, -324);
+      const pending = page.getByRole("button", { name: "Loading older messages…", exact: true });
+      await expect(pending).toBeDisabled();
+      await expect(requests).toHaveText("History requests: 1");
+      const height = await body.evaluate(element => element.scrollHeight);
+      await external("Append reply");
+      await expect.poll(() => body.evaluate(element => element.scrollHeight)).toBeGreaterThan(height);
+      await expect.poll(async () => {
+        await body.focus();
+        return body.evaluate(element => document.activeElement === element);
+      }).toBe(true);
+      await body.press("Home");
+      await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(0);
+      const original = page.getByText("Conversation line 1:", { exact: false }).first();
+      const originalTop = (await original.boundingBox()).y;
+      await external("Complete history load");
+      await expect(pending).toHaveCount(0);
+      await expect.poll(async () => Math.abs((await original.boundingBox()).y - originalTop)).toBeLessThan(2);
+      await expect(requests).toHaveText("History requests: 1");
+      assert.deepEqual(errors, []);
+      assert.ok(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth));
+      await page.close();
+    }
+  } finally {
+    await browser.close();
+    await stopProcess(vite);
+  }
+});

package/test/claudeConversationSession.test.js

@@ -1199,3 +1199,81 @@ test("the same Claude driver reopens a verified closed conversation after retryi
     await local.close();
   }
 });
+
+
+for (const change of ["model", "effort"]) test(`Claude honors a consumer's fresh native policy for ${change} changes and restart`, async t => {
+  const f = await fixture(t);
+  const binding = () => f.storage.read("conversation", async tx => (await tx.readMetadata()).runtime.binding);
+  await f.conversation.send(input);
+  const original = await f.conversation.wait();
+  const previous = await binding();
+  const beforeSelection = await f.trace();
+  const oldHistoryPath = path.join(previous.configRoot, "projects", previous.workdir.replace(/[^a-zA-Z0-9]/gu, "-"), `${previous.conversationId}.jsonl`);
+  const oldHistory = await readFile(oldHistoryPath, "utf8");
+  const selected = { ...configuration, [change]: change === "model" ? "another-model" : "low" };
+  const request = { operationId: `fresh-${change}`, expectedSegmentId: original.segmentId,
+    engine: "claude", configuration: selected, retireNative: true };
+  const receipt = await f.conversation.select(request);
+  assert.notEqual(receipt.segmentId, original.segmentId);
+  const inert = await binding();
+  assert.notEqual(inert.conversationId, previous.conversationId);
+  assert.equal(inert.sent, false);
+  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.conversationId, previous.conversationId);
+  assert.equal(inert.executionId, "");
+  assert.deepEqual(await f.trace(), beforeSelection, "Selecting allocates an inert handle without 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.equal(fresh.conversationId, inert.conversationId);
+  assert.equal(fresh.accountIdentity, previous.accountIdentity);
+  assert.equal(await readFile(oldHistoryPath, "utf8"), oldHistory);
+  const trace = await f.trace();
+  const starts = trace.filter(row => row.args?.includes("--print"));
+  assert.equal(starts.length, 2);
+  assert.equal(starts[1].args[starts[1].args.indexOf("--session-id") + 1], inert.conversationId);
+  assert.equal(starts[1].args.includes("--resume"), false);
+  assert.equal(starts[1].args[starts[1].args.indexOf("--model") + 1], selected.model);
+  assert.equal(trace.filter(row => row.frame?.request?.subtype === "apply_flag_settings").at(-1).frame.request.settings.effortLevel, selected.effort);
+  const nativeMessages = trace.filter(row => row.frame?.type === "user");
+  assert.equal(nativeMessages.length, 2);
+  const handedHistory = JSON.parse(nativeMessages[1].frame.message.content.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(nativeMessages[1].frame.message.content.split("User's message:\n")[1], "Continue after the change");
+  assert.match(nativeMessages[1].frame.message.content, /Hello/);
+  assert.match(nativeMessages[1].frame.message.content, /Answer: Hello/);
+  assert.match(nativeMessages[1].frame.message.content, /Continue after the change/);
+  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()).conversationId, inert.conversationId);
+  await resumed.send({ messageId: "after-restart", text: "Continue after restart" });
+  assert.equal((await resumed.wait()).conversationLog.length, 3);
+  const restarted = await f.trace();
+  assert.equal(restarted.filter(row => row.frame?.type === "user").length, 3);
+  assert.equal(restarted.filter(row => row.frame?.type === "user").at(-1).frame.message.content, "Continue after restart");
+  const restart = restarted.filter(row => row.args?.includes("--print")).at(-1);
+  assert.equal(restart.args[restart.args.indexOf("--resume") + 1], inert.conversationId);
+  const returned = await resumed.select({ operationId: `restore-${change}`, expectedSegmentId: (await resumed.read()).segmentId,
+    engine: "claude", 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.conversationId, previous.conversationId);
+  assert.notEqual(restored.conversationId, inert.conversationId);
+  assert.equal(restored.accountIdentity, previous.accountIdentity);
+  const restoredPrompt = (await f.trace()).filter(row => row.frame?.type === "user").at(-1).frame.message.content;
+  assert.match(restoredPrompt, /Hello/);
+  assert.match(restoredPrompt, /Continue after the change/);
+  assert.match(restoredPrompt, /Continue after restart/);
+});

package/test/claudeTurn.test.js

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { setTimeout as delay } from "node:timers/promises";
 import { createClaudeConversationTurn, claudeNativeMessageId, runClaudeRenewalTurn,
   waitForClaudeConversationTurn } from "../src/server/conversation/claudeTurn.js";
 
@@ -80,6 +81,13 @@ test("lost acknowledgement stays uncertain and stop rejects pending admission",
   assert.equal(turn.read().text, "");
 });
 
+test("storage failure rejects admission and a slow acknowledged write is not a native timeout", async () => {
+  const { turn, send } = fixture();
+  await send("slow", { timeoutMs: 5, accept: async () => delay(15) });
+  await assert.rejects(send("failed", { accept: async () => { throw new Error("Storage offline"); } }), /Storage offline/);
+  turn.stop();
+});
+
 test("native session identity and helper output bounds are enforced without truncating answers", async () => {
   const { turn, send } = fixture();
   await assert.rejects(turn.receive({ type: "user", session_id: "another-session" }), /different conversation id/);
@@ -92,6 +100,16 @@ test("native session identity and helper output bounds are enforced without trun
   turn.stop();
 });
 
+test("a native error result is failure information rather than an assistant answer", async () => {
+  const { turn, send, events } = fixture();
+  await send();
+  await turn.receive({ type: "result", subtype: "error_during_execution", is_error: true, result: "The model connection failed." });
+  assert.equal(turn.read().status, "failed");
+  assert.equal(turn.read().error, "The model connection failed.");
+  assert.equal(turn.read().text, "");
+  assert.equal(events.some(event => event.type === "message"), false);
+});
+
 function renewalFixture() {
   const input = { clientMessageId: "renewal-operation", prompt: "Approved prompt", timeoutMs: 100 };
   const uuid = claudeNativeMessageId(input.clientMessageId);