@assistant-ui/core 0.1.14 → 0.1.15

package/src/tests/RemoteThreadListThreadListRuntimeCore-reload.test.ts

@@ -0,0 +1,209 @@
+import { describe, it, expect, vi } from "vitest";
+import type { RemoteThreadListResponse } from "../runtimes/remote-thread-list/types";
+import {
+  createCore,
+  deferred,
+  makeAdapter,
+} from "./remote-thread-list-test-helpers";
+
+describe("RemoteThreadListThreadListRuntimeCore.reload", () => {
+  it("refetches list() after a successful empty load", async () => {
+    const listFn = vi
+      .fn<() => Promise<RemoteThreadListResponse>>()
+      .mockResolvedValueOnce({ threads: [] })
+      .mockResolvedValueOnce({
+        threads: [
+          {
+            status: "regular",
+            remoteId: "t-1",
+            externalId: "t-1",
+            title: "After auth",
+          },
+        ],
+      });
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    await core.getLoadThreadsPromise();
+    expect(listFn).toHaveBeenCalledTimes(1);
+    expect(core.threadIds).toEqual([]);
+
+    await core.reload();
+    expect(listFn).toHaveBeenCalledTimes(2);
+    expect(core.threadIds).toEqual(["t-1"]);
+  });
+
+  it("returns the same cached promise from getLoadThreadsPromise when reload is not called", async () => {
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({ threads: [] })),
+    });
+    const core = createCore(adapter);
+
+    const p1 = core.getLoadThreadsPromise();
+    const p2 = core.getLoadThreadsPromise();
+    await p1;
+    await p2;
+
+    expect(adapter.list).toHaveBeenCalledTimes(1);
+  });
+
+  it("drops stale responses when a reload is triggered mid-flight", async () => {
+    const first = deferred<RemoteThreadListResponse>();
+    const second = deferred<RemoteThreadListResponse>();
+    const listFn = vi
+      .fn<() => Promise<RemoteThreadListResponse>>()
+      .mockReturnValueOnce(first.promise)
+      .mockReturnValueOnce(second.promise);
+
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    core.getLoadThreadsPromise();
+    const reloaded = core.reload();
+
+    second.resolve({
+      threads: [
+        {
+          status: "regular",
+          remoteId: "fresh",
+          externalId: "fresh",
+          title: "Fresh",
+        },
+      ],
+    });
+    await reloaded;
+
+    first.resolve({
+      threads: [
+        {
+          status: "regular",
+          remoteId: "stale",
+          externalId: "stale",
+          title: "Stale",
+        },
+      ],
+    });
+    // flush microtasks so the stale then() reducer runs and its generation
+    // guard has a chance to discard the result
+    await Promise.resolve();
+
+    expect(core.threadIds).toEqual(["fresh"]);
+    expect(core.threadIds).not.toContain("stale");
+  });
+
+  it("recovers after a failed initial load", async () => {
+    const listFn = vi
+      .fn<() => Promise<RemoteThreadListResponse>>()
+      .mockRejectedValueOnce(new Error("401"))
+      .mockResolvedValueOnce({
+        threads: [
+          {
+            status: "regular",
+            remoteId: "t-1",
+            externalId: "t-1",
+            title: "Authed",
+          },
+        ],
+      });
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    await core.getLoadThreadsPromise();
+    expect(core.threadIds).toEqual([]);
+    expect(core.isLoading).toBe(false);
+
+    await core.reload();
+    expect(listFn).toHaveBeenCalledTimes(2);
+    expect(core.threadIds).toEqual(["t-1"]);
+  });
+
+  it("does not clear the active reload's promise when a stale load rejects", async () => {
+    const first = deferred<RemoteThreadListResponse>();
+    const second = deferred<RemoteThreadListResponse>();
+    const listFn = vi
+      .fn<() => Promise<RemoteThreadListResponse>>()
+      .mockReturnValueOnce(first.promise)
+      .mockReturnValueOnce(second.promise);
+
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    core.getLoadThreadsPromise();
+    const reloaded = core.reload();
+
+    first.reject(new Error("stale 401"));
+    await Promise.resolve();
+
+    second.resolve({
+      threads: [
+        {
+          status: "regular",
+          remoteId: "fresh",
+          externalId: "fresh",
+          title: "Fresh",
+        },
+      ],
+    });
+
+    await reloaded;
+    expect(core.threadIds).toEqual(["fresh"]);
+    expect(core.isLoading).toBe(false);
+  });
+
+  it("only the last of several overlapping reloads wins", async () => {
+    const deferreds = [
+      deferred<RemoteThreadListResponse>(),
+      deferred<RemoteThreadListResponse>(),
+      deferred<RemoteThreadListResponse>(),
+    ];
+    const listFn = vi
+      .fn<() => Promise<RemoteThreadListResponse>>()
+      .mockImplementationOnce(() => deferreds[0]!.promise)
+      .mockImplementationOnce(() => deferreds[1]!.promise)
+      .mockImplementationOnce(() => deferreds[2]!.promise);
+
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    const r1 = core.getLoadThreadsPromise();
+    const r2 = core.reload();
+    const r3 = core.reload();
+
+    deferreds[2]!.resolve({
+      threads: [
+        {
+          status: "regular",
+          remoteId: "c",
+          externalId: "c",
+          title: "c",
+        },
+      ],
+    });
+    await r3;
+
+    deferreds[0]!.resolve({
+      threads: [
+        {
+          status: "regular",
+          remoteId: "a",
+          externalId: "a",
+          title: "a",
+        },
+      ],
+    });
+    deferreds[1]!.resolve({
+      threads: [
+        {
+          status: "regular",
+          remoteId: "b",
+          externalId: "b",
+          title: "b",
+        },
+      ],
+    });
+    await r1;
+    await r2;
+
+    expect(core.threadIds).toEqual(["c"]);
+  });
+});

package/src/tests/RemoteThreadListThreadListRuntimeCore-switchToThread-dedupe.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect, vi } from "vitest";
+import type {
+  RemoteThreadListResponse,
+  RemoteThreadMetadata,
+} from "../runtimes/remote-thread-list/types";
+import {
+  createCore,
+  deferred,
+  makeAdapter,
+} from "./remote-thread-list-test-helpers";
+
+describe("RemoteThreadListThreadListRuntimeCore.switchToThread dedupe", () => {
+  it("does not duplicate threadIds when list() resolves during fetch()", async () => {
+    const THREAD_ID = "thread-1";
+    const listDeferred = deferred<RemoteThreadListResponse>();
+    const fetchDeferred = deferred<RemoteThreadMetadata>();
+
+    const adapter = makeAdapter({
+      list: vi.fn(() => listDeferred.promise),
+      fetch: vi.fn(() => fetchDeferred.promise),
+    });
+
+    const core = createCore(adapter, THREAD_ID);
+
+    const loadPromise = core.getLoadThreadsPromise();
+    const switchPromise = core.switchToThread(THREAD_ID);
+
+    // Commit `list()` before resolving `fetch()` so `switchToThread` reads a
+    // state that already contains THREAD_ID.
+    listDeferred.resolve({
+      threads: [
+        {
+          status: "regular",
+          remoteId: THREAD_ID,
+          externalId: THREAD_ID,
+          title: "Test",
+        },
+      ],
+    });
+    await loadPromise;
+
+    fetchDeferred.resolve({
+      status: "regular",
+      remoteId: THREAD_ID,
+      externalId: THREAD_ID,
+      title: "Test",
+    });
+    await switchPromise;
+
+    expect(core.threadIds.filter((id) => id === THREAD_ID)).toEqual([
+      THREAD_ID,
+    ]);
+  });
+
+  it("does not duplicate archivedThreadIds when list() resolves during fetch()", async () => {
+    const THREAD_ID = "archived-1";
+    const listDeferred = deferred<RemoteThreadListResponse>();
+    const fetchDeferred = deferred<RemoteThreadMetadata>();
+
+    const adapter = makeAdapter({
+      list: vi.fn(() => listDeferred.promise),
+      fetch: vi.fn(() => fetchDeferred.promise),
+    });
+
+    const core = createCore(adapter, THREAD_ID);
+    // Without this stub, auto-unarchive would filter `archivedThreadIds` via
+    // `updateStatusReducer`, hiding any duplicate written by `switchToThread`.
+    (
+      core as unknown as { unarchive: (id: string) => Promise<void> }
+    ).unarchive = async () => {};
+
+    const loadPromise = core.getLoadThreadsPromise();
+    const switchPromise = core.switchToThread(THREAD_ID);
+
+    listDeferred.resolve({
+      threads: [
+        {
+          status: "archived",
+          remoteId: THREAD_ID,
+          externalId: THREAD_ID,
+          title: "Archived",
+        },
+      ],
+    });
+    await loadPromise;
+
+    fetchDeferred.resolve({
+      status: "archived",
+      remoteId: THREAD_ID,
+      externalId: THREAD_ID,
+      title: "Archived",
+    });
+    await switchPromise;
+
+    expect(core.archivedThreadIds.filter((id) => id === THREAD_ID)).toEqual([
+      THREAD_ID,
+    ]);
+  });
+
+  it("moves the id to the correct array when list() and fetch() disagree on status", async () => {
+    const THREAD_ID = "flipped-1";
+    const listDeferred = deferred<RemoteThreadListResponse>();
+    const fetchDeferred = deferred<RemoteThreadMetadata>();
+
+    const adapter = makeAdapter({
+      list: vi.fn(() => listDeferred.promise),
+      fetch: vi.fn(() => fetchDeferred.promise),
+    });
+
+    const core = createCore(adapter, THREAD_ID);
+
+    const loadPromise = core.getLoadThreadsPromise();
+    const switchPromise = core.switchToThread(THREAD_ID);
+
+    // A concurrent unarchive between `list()` and `fetch()` flips the status.
+    listDeferred.resolve({
+      threads: [
+        {
+          status: "archived",
+          remoteId: THREAD_ID,
+          externalId: THREAD_ID,
+          title: "Flipped",
+        },
+      ],
+    });
+    await loadPromise;
+
+    fetchDeferred.resolve({
+      status: "regular",
+      remoteId: THREAD_ID,
+      externalId: THREAD_ID,
+      title: "Flipped",
+    });
+    await switchPromise;
+
+    expect(core.threadIds).toContain(THREAD_ID);
+    expect(core.archivedThreadIds).not.toContain(THREAD_ID);
+  });
+});

package/src/tests/attachment.test.ts

@@ -0,0 +1,180 @@
+import { describe, expect, it } from "vitest";
+import {
+  attachmentsEqual,
+  liftNonTextParts,
+  partToCompleteAttachment,
+} from "../adapters/attachment";
+import type { CompleteAttachment } from "../types/attachment";
+
+const makeAttachment = (id: string): CompleteAttachment => ({
+  id,
+  type: "document",
+  name: "file.pdf",
+  content: [
+    { type: "file", data: "data", mimeType: "application/pdf", filename: id },
+  ],
+  status: { type: "complete" },
+});
+
+describe("attachmentsEqual", () => {
+  it("returns true for two empty arrays", () => {
+    expect(attachmentsEqual([], [])).toBe(true);
+  });
+
+  it("returns false when lengths differ", () => {
+    expect(attachmentsEqual([makeAttachment("a")], [])).toBe(false);
+  });
+
+  it("returns true when all ids match in order", () => {
+    const a = makeAttachment("a");
+    const b = makeAttachment("b");
+    expect(attachmentsEqual([a, b], [a, b])).toBe(true);
+  });
+
+  it("returns false when ids differ at the same length", () => {
+    expect(attachmentsEqual([makeAttachment("a")], [makeAttachment("b")])).toBe(
+      false,
+    );
+  });
+});
+
+describe("partToCompleteAttachment", () => {
+  it("converts an image part using the filename as name", () => {
+    const result = partToCompleteAttachment({
+      type: "image",
+      image: "https://example.com/x.png",
+      filename: "x.png",
+    });
+    expect(result).toMatchObject({
+      type: "image",
+      name: "x.png",
+      status: { type: "complete" },
+    });
+    expect(result.content).toEqual([
+      {
+        type: "image",
+        image: "https://example.com/x.png",
+        filename: "x.png",
+      },
+    ]);
+  });
+
+  it("falls back to 'image' when the image part has no filename", () => {
+    const result = partToCompleteAttachment({
+      type: "image",
+      image: "blob",
+    });
+    expect(result.name).toBe("image");
+  });
+
+  it("converts a file part to a document attachment with contentType", () => {
+    const result = partToCompleteAttachment({
+      type: "file",
+      data: "blob",
+      mimeType: "application/pdf",
+      filename: "report.pdf",
+    });
+    expect(result).toMatchObject({
+      type: "document",
+      name: "report.pdf",
+      contentType: "application/pdf",
+    });
+  });
+
+  it("falls back to 'document' when the file part has no filename", () => {
+    const result = partToCompleteAttachment({
+      type: "file",
+      data: "blob",
+      mimeType: "application/pdf",
+    });
+    expect(result.name).toBe("document");
+  });
+
+  it("converts an audio part with derived name and contentType", () => {
+    const mp3 = partToCompleteAttachment({
+      type: "audio",
+      audio: { data: "blob", format: "mp3" },
+    });
+    expect(mp3).toMatchObject({
+      type: "audio",
+      name: "audio.mp3",
+      contentType: "audio/mp3",
+    });
+
+    const wav = partToCompleteAttachment({
+      type: "audio",
+      audio: { data: "blob", format: "wav" },
+    });
+    expect(wav.name).toBe("audio.wav");
+    expect(wav.contentType).toBe("audio/wav");
+  });
+
+  it("converts a data part using its name", () => {
+    const result = partToCompleteAttachment({
+      type: "data",
+      name: "weather-widget",
+      data: { temp: 20 },
+    });
+    expect(result).toMatchObject({
+      type: "data",
+      name: "weather-widget",
+    });
+    expect(result.contentType).toBeUndefined();
+  });
+
+  it("generates a unique id for each call", () => {
+    const a = partToCompleteAttachment({
+      type: "file",
+      data: "x",
+      mimeType: "application/pdf",
+    });
+    const b = partToCompleteAttachment({
+      type: "file",
+      data: "x",
+      mimeType: "application/pdf",
+    });
+    expect(a.id).not.toBe(b.id);
+  });
+});
+
+describe("liftNonTextParts", () => {
+  it("returns an empty array for content of only text parts", () => {
+    expect(
+      liftNonTextParts([
+        { type: "text", text: "hello" },
+        { type: "text", text: "world" },
+      ]),
+    ).toEqual([]);
+  });
+
+  it("lifts mixed non-text types preserving order", () => {
+    const result = liftNonTextParts([
+      { type: "text", text: "mix" },
+      {
+        type: "image",
+        image: "url",
+        filename: "pic.png",
+      },
+      {
+        type: "file",
+        data: "d",
+        mimeType: "application/pdf",
+        filename: "doc.pdf",
+      },
+      { type: "audio", audio: { data: "a", format: "mp3" } },
+      { type: "data", name: "widget", data: {} },
+    ]);
+    expect(result.map((a) => a.type)).toEqual([
+      "image",
+      "document",
+      "audio",
+      "data",
+    ]);
+    expect(result.map((a) => a.name)).toEqual([
+      "pic.png",
+      "doc.pdf",
+      "audio.mp3",
+      "widget",
+    ]);
+  });
+});