@jskit-ai/assistant-core 0.1.171 → 0.1.173

package/test/assistantScroll.browser.test.js

@@ -22,6 +22,79 @@ const VIEWPORTS = Object.freeze([
   Object.freeze({ name: "drawer", width: 360, height: 600 })
 ]);
 
+test("adjacent reasoning stays grouped across storage rows, history pages and execution changes", {
+  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 errors = [];
+      page.on("pageerror", error => errors.push(error.message));
+      await page.goto(`${vite.baseURL}/?progress=1`);
+      const groups = page.locator(".assistant-progress");
+      const summaries = page.locator(".assistant-progress__message");
+      const input = page.getByRole("textbox", { name: "Message AI assistant" });
+      const external = name => page.getByRole("button", { name, exact: true }).evaluate(element => element.click());
+      await expect(groups).toHaveCount(1);
+      await expect(summaries).toHaveText(["Reasoning 2", "Reasoning 3"]);
+      await input.fill("Keep my draft");
+      await input.evaluate(element => element.setSelectionRange(2, 5));
+      await external("Change storage rows");
+      await expect(groups).toHaveCount(1);
+      await expect(summaries).toHaveText(["Reasoning 2", "Reasoning 3"]);
+      await external("Change storage rows");
+      await external("Toggle working");
+      await expect(summaries).toHaveCount(0);
+      await expect(page.getByRole("button", { name: "Show all 3 progress updates" })).toBeVisible();
+      await external("Toggle working");
+      await expect(summaries).toHaveText(["Reasoning 2", "Reasoning 3"]);
+      await external("Show all 3 progress updates");
+      await expect(summaries).toHaveCount(3);
+      await external("Load older messages");
+      await expect(groups).toHaveCount(1);
+      await expect(summaries).toHaveText(["Older reasoning", "Reasoning 1", "Reasoning 2", "Reasoning 3"]);
+      await external("Append thinking");
+      await expect(summaries).toHaveCount(5);
+      await expect(input).toBeFocused();
+      await expect(input).toHaveValue("Keep my draft");
+      assert.deepEqual(await input.evaluate(element => [element.selectionStart, element.selectionEnd]), [2, 5]);
+      await external("Show latest 2 progress updates");
+      await external("Toggle working");
+      await expect(summaries).toHaveCount(0);
+      await external("Show all 5 progress updates");
+      await external("Change conversation");
+      await expect(summaries).toHaveCount(0);
+      await external("Toggle working");
+
+      // Every visible non-reasoning message separates groups, regardless of rows.
+      for (const [index, role] of ["commentary", "assistant", "user", "system"].entries()) {
+        await external(`Append ${role}`);
+        await expect(summaries).toHaveCount(0);
+        await external("Append thinking");
+        await external("Append thinking");
+        await expect(groups).toHaveCount(index + 2);
+        await expect(summaries).toHaveCount(2);
+      }
+      await external("Change storage rows");
+      await expect(groups).toHaveCount(5);
+      await expect(summaries).toHaveCount(2);
+      const bodyText = await page.locator(".assistant-transcript__body").textContent();
+      assert.ok(bodyText.indexOf("commentary 6") < bodyText.indexOf("assistant 9"));
+      assert.ok(bodyText.indexOf("assistant 9") < bodyText.indexOf("user 12"));
+      assert.ok(bodyText.indexOf("user 12") < bodyText.indexOf("system 15"));
+      assert.ok(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth));
+      assert.deepEqual(errors, []);
+      await page.close();
+    }
+  } finally {
+    await browser.close();
+    await stopProcess(vite);
+  }
+});
+
 async function assertResponsiveAssistant(page, viewport) {
   await page.setViewportSize({ width: viewport.width, height: viewport.height });
   await page.goto("/");
@@ -167,3 +240,147 @@ test("conversation composer preserves typing and reacts to external state and pa
     await stopProcess(vite);
   }
 });
+
+test("working state appears before output and suggestion agents and activity rendering are replaceable", {
+  skip: !RUN_BROWSER_TEST,
+  timeout: 60_000
+}, async () => {
+  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
+  const browser = await chromium.launch(createChromiumLaunchOptions());
+  try {
+    const page = await browser.newPage({ viewport: { width: 390, height: 844 } });
+    await page.goto(`${vite.baseURL}/?conversation=1&support=1`);
+    const input = page.getByRole("textbox", { name: "Message AI assistant" });
+    await page.getByRole("button", { name: "Use suggestion: Suggestion from small-model", exact: true }).hover();
+    await expect(input).toHaveAttribute("placeholder", "Suggestion from small-model");
+    await expect(input).toHaveValue("");
+    await page.getByRole("button", { name: "Change suggestion model" }).click();
+    await page.getByRole("button", { name: "Use suggestion: Suggestion from other-model", exact: true }).click();
+    await expect(input).toHaveValue("Suggestion from other-model");
+    await expect(input).toBeFocused();
+    await input.press("Enter");
+    const activity = page.locator(".assistant-composer-support__assistant-status");
+    await expect(activity).toHaveText("Assistant is working…");
+    await expect(page.locator(".assistant-composer-support__sr-status")).toHaveText("Assistant is working…");
+    await input.fill("Keep typing while waiting");
+    await input.evaluate(element => element.setSelectionRange(5, 11));
+    await page.getByRole("button", { name: "Custom activity", exact: true }).evaluate(element => element.click());
+    await expect(activity).toHaveText("Custom activity: Assistant is working…");
+    await expect(input).toBeFocused();
+    assert.deepEqual(await input.evaluate(element => [element.selectionStart, element.selectionEnd]), [5, 11]);
+    await page.getByRole("button", { name: "External stopping", exact: true }).evaluate(element => element.click());
+    await expect(activity).toHaveText("Custom activity: Stopping…");
+    await page.getByRole("button", { name: "External stopped", exact: true }).evaluate(element => element.click());
+    await expect(activity).toHaveCount(0);
+    await expect(input).toHaveValue("Keep typing while waiting");
+  } finally {
+    await browser.close();
+    await stopProcess(vite);
+  }
+});
+
+
+test("optional goals show running and paused lights, count only active time, and adapt to pane width", {
+  skip: !RUN_BROWSER_TEST,
+  timeout: 60_000
+}, async () => {
+  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
+  const browser = await chromium.launch(createChromiumLaunchOptions());
+  try {
+    const page = await browser.newPage({ viewport: { width: 1365, height: 900 } });
+    await page.clock.install();
+    await page.goto(`${vite.baseURL}/?conversation=1&goal=1`);
+    const input = page.getByRole("textbox", { name: "Message AI assistant" });
+    await page.getByRole("button", { name: "Set goal", exact: true }).click();
+    await page.getByRole("textbox", { name: "Goal objective" }).fill("Complete the shared assistant.");
+    await page.getByRole("spinbutton", { name: "Token budget (optional)" }).fill("10000");
+    await page.getByRole("button", { name: "Start goal", exact: true }).click();
+    await expect(page.getByText("Complete the shared assistant.", { exact: true })).toBeVisible();
+    await input.click();
+    await input.fill("Preserve this draft and caret");
+    await input.evaluate(element => element.setSelectionRange(5, 9));
+    const light = page.locator(".assistant-goal__light");
+    await expect(light).toHaveCSS("background-color", "rgb(211, 47, 47)");
+    await expect(light).toHaveCSS("animation-name", /^assistant-goal-flash/u);
+    const elapsed = page.locator(".assistant-goal__elapsed");
+    await page.clock.fastForward(65_000);
+    await expect(elapsed).toHaveText("1:05");
+    await expect(input).toBeFocused();
+    assert.deepEqual(await input.evaluate(element => [element.selectionStart, element.selectionEnd]), [5, 9]);
+    await page.getByRole("button", { name: "Goal running", exact: true }).click();
+    await page.getByRole("button", { name: "Pause goal", exact: true }).click();
+    await expect(light).toHaveCSS("background-color", "rgb(239, 108, 0)");
+    await expect(light).toHaveCSS("animation-name", "none");
+    const pausedTime = await elapsed.textContent();
+    await page.clock.fastForward(120_000);
+    await expect(elapsed).toHaveText(pausedTime);
+    await page.getByRole("button", { name: "Resume goal", exact: true }).click();
+    await page.clock.fastForward(5_000);
+    await expect(elapsed).toHaveText("1:10");
+    await page.emulateMedia({ reducedMotion: "reduce" });
+    await expect(light).toHaveCSS("animation-name", "none");
+    await expect(light).toHaveCSS("background-color", "rgb(211, 47, 47)");
+    await input.click();
+    await page.getByRole("button", { name: "Resize pane" }).click();
+    await expect(elapsed).toBeHidden();
+    await expect(light).toBeVisible();
+    await page.getByRole("button", { name: "Goal running", exact: true }).click();
+    await expect(page.getByText("Running time: 1:10", { exact: true })).toBeVisible();
+    await page.getByRole("button", { name: "Toggle goals" }).evaluate(element => element.click());
+    await expect(page.locator(".assistant-goal")).toHaveCount(0);
+    await expect(page.getByRole("button", { name: "Pause goal", exact: true })).toBeHidden();
+    await expect(input).toHaveValue("Preserve this draft and caret");
+  } finally {
+    await browser.close();
+    await stopProcess(vite);
+  }
+});
+
+
+test("shared model choices and file delivery preserve a responsive composer", {
+  skip: !RUN_BROWSER_TEST,
+  timeout: 60_000
+}, async () => {
+  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
+  const browser = await chromium.launch(createChromiumLaunchOptions());
+  try {
+    const page = await browser.newPage({ viewport: { width: 390, height: 844 } });
+    await page.goto(`${vite.baseURL}/?conversation=1&capabilities=1`);
+    const input = page.getByRole("textbox", { name: "Message AI assistant" });
+    await page.getByRole("button", { name: "Choose AI", exact: true }).click();
+    const model = page.getByRole("combobox", { name: "Choose model", exact: true });
+    await model.click();
+    await model.press("ControlOrMeta+A");
+    await model.press("Backspace");
+    await model.pressSequentially("Model 3");
+    await page.getByRole("option", { name: "Model 3", exact: true }).click();
+    await page.getByRole("button", { name: "Apply", exact: true }).click();
+    await expect(page.getByText("Model: model-2; sent files:", { exact: true })).toBeVisible();
+    await input.click();
+    await input.fill("Read these files");
+    await page.locator('input[type="file"]').setInputFiles([
+      { name: "notes.txt", mimeType: "text/plain", buffer: Buffer.from("First file") },
+      { name: "tasks.txt", mimeType: "text/plain", buffer: Buffer.from("Second file") }
+    ]);
+    await expect(page.getByText("0 of 2 ready · 50%", { exact: true })).toBeVisible();
+    await expect(page.getByRole("button", { name: "Send", exact: true })).toBeDisabled();
+    await input.fill("Keep editing while files upload");
+    await input.evaluate(element => element.setSelectionRange(5, 9));
+    await page.getByRole("button", { name: "Finish uploads", exact: true }).evaluate(element => element.click());
+    await expect(page.getByText("2 of 2 ready", { exact: true })).toBeVisible();
+    await expect(input).toBeFocused();
+    assert.deepEqual(await input.evaluate(element => [element.selectionStart, element.selectionEnd]), [5, 9]);
+    await page.getByRole("button", { name: "Remove notes.txt", exact: true }).click();
+    await page.getByRole("button", { name: "Send", exact: true }).click();
+    await expect(page.getByText("Model: model-2; sent files: tasks.txt", { exact: true })).toBeVisible();
+    await expect(page.getByRole("region", { name: "Message attachments", exact: true })).toHaveCount(0);
+    await page.getByRole("button", { name: "Choose AI", exact: true }).click();
+    await expect(model).toBeDisabled();
+    await expect(page.getByText("AI choices are view-only while the assistant is working.", { exact: true })).toBeVisible();
+    await input.fill("The next message stays editable");
+    assert.ok(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth));
+  } finally {
+    await browser.close();
+    await stopProcess(vite);
+  }
+});

package/test/suggestions.test.js

@@ -0,0 +1,114 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { effectScope, ref } from "vue";
+import { useAssistantSuggestions } from "../src/client/conversation/useAssistantSuggestions.js";
+
+const flush = () => new Promise(resolve => setImmediate(resolve));
+const suggestion = prompt => ({ label: "Suggested next step", prompt });
+
+test("suggestions debounce drafts and independently configure their generator", async t => {
+  t.mock.timers.enable({ apis: ["setTimeout"] });
+  const scope = effectScope();
+  t.after(() => scope.stop());
+  const draft = ref("");
+  const configuration = ref({ agent: "quick-suggestions", model: "small", instructions: "Suggest a next step" });
+  const calls = [];
+  const state = scope.run(() => useAssistantSuggestions({ draft, configuration,
+    generate: async input => { calls.push(input); return [suggestion(input.draft || input.configuration.model)]; }
+  }));
+  draft.value = "First";
+  t.mock.timers.tick(500);
+  draft.value = "Second";
+  t.mock.timers.tick(749);
+  assert.equal(calls.length, 0);
+  t.mock.timers.tick(1);
+  await flush();
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].draft, "Second");
+  assert.deepEqual(calls[0].configuration, configuration.value);
+  assert.deepEqual(state.items.value, [suggestion("Second")]);
+  configuration.value.model = "other";
+  t.mock.timers.tick(750);
+  await flush();
+  assert.equal(calls[0].configuration.model, "small", "The in-flight configuration is a snapshot");
+  assert.equal(calls[1].configuration.model, "other");
+});
+
+test("obsolete suggestions cannot return after scope, draft or agent changes", async t => {
+  t.mock.timers.enable({ apis: ["setTimeout"] });
+  const scope = effectScope();
+  const requestKey = ref("conversation-one");
+  const draft = ref("");
+  const calls = [];
+  const generate = ref(input => new Promise(resolve => calls.push({ ...input, resolve })));
+  const state = scope.run(() => useAssistantSuggestions({ requestKey, draft, generate }));
+  t.mock.timers.tick(750);
+  requestKey.value = "conversation-two";
+  assert.equal(calls[0].signal.aborted, true);
+  t.mock.timers.tick(750);
+  draft.value = "New draft";
+  assert.equal(calls[1].signal.aborted, true);
+  t.mock.timers.tick(750);
+  generate.value = async () => [suggestion("New agent")];
+  assert.equal(calls[2].signal.aborted, true);
+  t.mock.timers.tick(750);
+  await flush();
+  for (const call of calls) call.resolve([suggestion("Obsolete")]);
+  await flush();
+  assert.deepEqual(state.items.value, [suggestion("New agent")]);
+  requestKey.value = "conversation-three";
+  scope.stop();
+  t.mock.timers.tick(750);
+  assert.equal(state.loading.value, false);
+  assert.equal(state.items.value.length, 0);
+});
+
+test("suggestion previews preserve a draft and stale selections cannot submit", async t => {
+  t.mock.timers.enable({ apis: ["setTimeout"] });
+  const scope = effectScope();
+  t.after(() => scope.stop());
+  const draft = ref("");
+  const selected = [];
+  const state = scope.run(() => useAssistantSuggestions({ draft,
+    generate: async () => [suggestion("Next step")], onSelect: text => selected.push(text)
+  }));
+  t.mock.timers.tick(750);
+  await flush();
+  state.focus();
+  assert.equal(state.previewSuggestion(state.items.value[0]), true);
+  assert.equal(draft.value, "");
+  assert.equal(state.preview.value, "Next step");
+  assert.equal(state.select(suggestion("Next step")), true);
+  assert.deepEqual(selected, ["Next step"]);
+  state.dismiss();
+  assert.equal(state.visible.value, false);
+  assert.equal(state.select(suggestion("Next step")), false);
+  state.blur();
+  state.focus();
+  t.mock.timers.tick(750);
+  await flush();
+  assert.equal(state.visible.value, true);
+  draft.value = "Keep my text";
+  assert.equal(state.preview.value, "");
+  assert.equal(state.select(suggestion("Next step")), false);
+  assert.equal(draft.value, "Keep my text");
+});
+
+test("a failing suggestion agent leaves the composer independent and stops retrying", async t => {
+  t.mock.timers.enable({ apis: ["setTimeout"] });
+  const scope = effectScope();
+  t.after(() => scope.stop());
+  const draft = ref("Keep this");
+  let requests = 0;
+  const state = scope.run(() => useAssistantSuggestions({ draft,
+    generate: async () => { requests++; throw new Error("Suggestion service unavailable"); }
+  }));
+  t.mock.timers.tick(750);
+  await flush();
+  assert.equal(state.error.value, "Suggestion service unavailable");
+  assert.equal(state.loading.value, false);
+  assert.equal(state.visible.value, false);
+  assert.equal(draft.value, "Keep this");
+  t.mock.timers.tick(60_000);
+  assert.equal(requests, 1);
+});