@assistant-ui/core 0.3.18 → 0.3.20

package/src/react/runtimes/cloud/auiV0DecodeSafely.test.ts

@@ -0,0 +1,522 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { CloudMessage } from "assistant-cloud";
+import type { ThreadAssistantMessage, ThreadUserMessage } from "../../../types";
+import { auiV0DecodeSafely, auiV0Encode } from "./auiV0";
+
+const storedRow = (content: unknown) =>
+  ({
+    id: "message-1",
+    parent_id: null,
+    format: "aui/v0",
+    created_at: new Date(0),
+    content,
+  }) as unknown as CloudMessage & { format: "aui/v0" };
+
+const assistantRow = (content: unknown, rest: Record<string, unknown> = {}) =>
+  storedRow({ role: "assistant", content, ...rest });
+
+beforeEach(() => {
+  vi.spyOn(console, "warn").mockImplementation(() => {});
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("auiV0DecodeSafely", () => {
+  it("drops an unreadable part and keeps its readable siblings", () => {
+    const item = auiV0DecodeSafely(
+      assistantRow([
+        { type: "text", text: "before" },
+        null,
+        { type: "text", text: 42 },
+        { type: "text", text: "after" },
+      ]),
+    );
+
+    expect(item?.message.content).toEqual([
+      { type: "text", text: "before" },
+      { type: "text", text: "after" },
+    ]);
+  });
+
+  it("keeps a row whose every part was unreadable so its descendants survive", () => {
+    const item = auiV0DecodeSafely(assistantRow([null]));
+
+    expect(item?.message.content).toEqual([]);
+  });
+
+  it("preserves a requires-action status", () => {
+    const item = auiV0DecodeSafely(
+      assistantRow([{ type: "text", text: "approve?" }], {
+        status: { type: "requires-action", reason: "tool-calls" },
+      }),
+    );
+
+    expect(item?.message.status).toEqual({
+      type: "requires-action",
+      reason: "tool-calls",
+    });
+  });
+
+  it("keeps both one-sided tool call encodings", () => {
+    const item = auiV0DecodeSafely(
+      assistantRow([
+        {
+          type: "tool-call",
+          toolCallId: "call-1",
+          toolName: "search",
+          args: { query: "a" },
+        },
+        {
+          type: "tool-call",
+          toolCallId: "call-2",
+          toolName: "search",
+          argsText: '{"query":"b"}',
+        },
+      ]),
+    );
+
+    expect(item?.message.content).toMatchObject([
+      { toolCallId: "call-1", args: { query: "a" } },
+      { toolCallId: "call-2", args: { query: "b" } },
+    ]);
+  });
+
+  it("keeps a data prefixed part the decoder can still convert", () => {
+    const item = auiV0DecodeSafely(
+      assistantRow([{ type: "data-weather", data: { city: "Berlin" } }]),
+    );
+
+    expect(item?.message.content).toHaveLength(1);
+  });
+
+  it("drops an unknown part type the decoder would throw on", () => {
+    const item = auiV0DecodeSafely(
+      assistantRow([
+        { type: "widget", spec: {} },
+        { type: "text", text: "kept" },
+      ]),
+    );
+
+    expect(item?.message.content).toEqual([{ type: "text", text: "kept" }]);
+  });
+
+  it("drops a tool call whose stored args are not an object", () => {
+    const item = auiV0DecodeSafely(
+      assistantRow([
+        {
+          type: "tool-call",
+          toolCallId: "call-1",
+          toolName: "search",
+          args: "bad",
+          argsText: "{}",
+        },
+        { type: "text", text: "kept" },
+      ]),
+    );
+
+    expect(item?.message.content).toEqual([{ type: "text", text: "kept" }]);
+  });
+
+  it("drops an unreadable attachment and keeps the message", () => {
+    const item = auiV0DecodeSafely(
+      storedRow({
+        role: "user",
+        content: [{ type: "text", text: "look" }],
+        attachments: [
+          null,
+          {
+            id: "attachment-1",
+            type: "document",
+            name: "notes.txt",
+            status: { type: "complete" },
+            content: [{ type: "text", text: "notes" }],
+          },
+        ],
+      }),
+    );
+
+    expect(item?.message.content).toEqual([{ type: "text", text: "look" }]);
+    expect(item?.message).toMatchObject({
+      attachments: [{ id: "attachment-1" }],
+    });
+  });
+
+  it("drops an unreadable nested message and keeps the tool call", () => {
+    const item = auiV0DecodeSafely(
+      assistantRow([
+        {
+          type: "tool-call",
+          toolCallId: "call-1",
+          toolName: "delegate",
+          args: {},
+          messages: [
+            null,
+            {
+              id: "nested-1",
+              role: "assistant",
+              content: [{ type: "text", text: "nested" }],
+            },
+          ],
+        },
+      ]),
+    );
+
+    expect(item?.message.content[0]).toMatchObject({
+      type: "tool-call",
+      messages: [{ id: "nested-1" }],
+    });
+  });
+
+  it("drops a part the row's role cannot carry and keeps its siblings", () => {
+    const item = auiV0DecodeSafely(
+      storedRow({
+        role: "user",
+        content: [
+          { type: "reasoning", text: "assistant only" },
+          { type: "text", text: "kept" },
+        ],
+        metadata: { custom: {} },
+      }),
+    );
+
+    expect(item?.message.content).toEqual([{ type: "text", text: "kept" }]);
+  });
+
+  it("drops an audio part from an assistant row", () => {
+    const item = auiV0DecodeSafely(
+      assistantRow([
+        { type: "audio", audio: { data: "abc", format: "mp3" } },
+        { type: "text", text: "kept" },
+      ]),
+    );
+
+    expect(item?.message.content).toEqual([{ type: "text", text: "kept" }]);
+  });
+
+  it("drops attachments stored on a row that cannot carry them", () => {
+    const item = auiV0DecodeSafely(
+      assistantRow([{ type: "text", text: "kept" }], {
+        attachments: [
+          {
+            id: "attachment-1",
+            type: "document",
+            name: "notes.txt",
+            status: { type: "complete" },
+            content: [],
+          },
+        ],
+      }),
+    );
+
+    expect(item?.message.content).toEqual([{ type: "text", text: "kept" }]);
+  });
+
+  it("drops a tool call whose stored argsText is not a string", () => {
+    const item = auiV0DecodeSafely(
+      assistantRow([
+        {
+          type: "tool-call",
+          toolCallId: "call-1",
+          toolName: "search",
+          args: { query: "a" },
+          argsText: 42,
+        },
+        { type: "text", text: "kept" },
+      ]),
+    );
+
+    expect(item?.message.content).toEqual([{ type: "text", text: "kept" }]);
+  });
+
+  it("keeps a data prefixed attachment part", () => {
+    const item = auiV0DecodeSafely(
+      storedRow({
+        role: "user",
+        content: [{ type: "text", text: "look" }],
+        metadata: { custom: {} },
+        attachments: [
+          {
+            id: "attachment-1",
+            type: "document",
+            name: "notes.txt",
+            status: { type: "complete" },
+            content: [{ type: "data-weather", data: { city: "Berlin" } }],
+          },
+        ],
+      }),
+    );
+
+    expect(item?.message).toMatchObject({
+      attachments: [{ id: "attachment-1", content: [{ type: "data" }] }],
+    });
+  });
+
+  it("drops a nested message whose role is unreadable", () => {
+    const item = auiV0DecodeSafely(
+      assistantRow([
+        {
+          type: "tool-call",
+          toolCallId: "call-1",
+          toolName: "delegate",
+          args: {},
+          messages: [
+            { id: "nested-1", role: "moderator", content: [] },
+            {
+              id: "nested-2",
+              role: "assistant",
+              content: [{ type: "text", text: "nested" }],
+            },
+          ],
+        },
+      ]),
+    );
+
+    expect(item?.message.content[0]).toMatchObject({
+      type: "tool-call",
+      messages: [{ id: "nested-2" }],
+    });
+  });
+
+  it("drops a reasoning part whose other field is not a string", () => {
+    const item = auiV0DecodeSafely(
+      assistantRow([
+        { type: "reasoning", text: 42, unstable_summary: "valid" },
+        { type: "text", text: "kept" },
+      ]),
+    );
+
+    expect(item?.message.content).toEqual([{ type: "text", text: "kept" }]);
+  });
+
+  it("keeps only the text part of a system row", () => {
+    const item = auiV0DecodeSafely(
+      storedRow({
+        role: "system",
+        content: [
+          { type: "data-weather", data: { city: "Berlin" } },
+          { type: "text", text: "be brief" },
+        ],
+        metadata: { custom: {} },
+      }),
+    );
+
+    expect(item?.message.content).toEqual([{ type: "text", text: "be brief" }]);
+  });
+
+  it("drops a nested system message the decoder would reject", () => {
+    const item = auiV0DecodeSafely(
+      assistantRow([
+        {
+          type: "tool-call",
+          toolCallId: "call-1",
+          toolName: "delegate",
+          args: {},
+          messages: [
+            {
+              id: "nested-1",
+              role: "system",
+              content: [{ type: "reasoning", text: "not a system part" }],
+            },
+            {
+              id: "nested-2",
+              role: "assistant",
+              content: [{ type: "text", text: "nested" }],
+            },
+          ],
+        },
+      ]),
+    );
+
+    expect(item?.message.content[0]).toMatchObject({
+      type: "tool-call",
+      messages: [{ id: "nested-2" }],
+    });
+  });
+
+  it("keeps a nested message with an unreadable createdAt re-encodable", () => {
+    const item = auiV0DecodeSafely(
+      assistantRow([
+        {
+          type: "tool-call",
+          toolCallId: "call-1",
+          toolName: "delegate",
+          args: {},
+          messages: [
+            {
+              id: "nested-1",
+              role: "assistant",
+              createdAt: "nonsense",
+              content: [{ type: "text", text: "nested" }],
+            },
+          ],
+        },
+      ]),
+    );
+
+    expect(item?.message.content[0]).toMatchObject({
+      messages: [{ id: "nested-1" }],
+    });
+    expect(() => auiV0Encode(item!.message)).not.toThrow();
+  });
+
+  it("drops a status and metadata steps a non-assistant row cannot carry", () => {
+    const item = auiV0DecodeSafely(
+      storedRow({
+        role: "user",
+        content: [{ type: "text", text: "kept" }],
+        status: { type: "complete", reason: "stop" },
+        metadata: { custom: {}, steps: [{ usage: {} }] },
+      }),
+    );
+
+    expect(item?.message.content).toEqual([{ type: "text", text: "kept" }]);
+    expect(item?.message).not.toHaveProperty("status");
+  });
+
+  it("returns null for a row that does not hold a message", () => {
+    expect(auiV0DecodeSafely(storedRow(null))).toBeNull();
+    expect(auiV0DecodeSafely(storedRow({ role: "assistant" }))).toBeNull();
+  });
+
+  it("returns null for a row the decoder cannot read back", () => {
+    expect(
+      auiV0DecodeSafely(storedRow({ role: "moderator", content: [] })),
+    ).toBeNull();
+  });
+
+  it("bounds nesting so a deeply nested row cannot overflow the stack", () => {
+    let content: unknown = [{ type: "text", text: "bottom" }];
+    for (let i = 0; i < 5000; i++) {
+      content = [
+        {
+          type: "tool-call",
+          toolCallId: `call-${i}`,
+          toolName: "delegate",
+          args: {},
+          messages: [{ id: `nested-${i}`, role: "assistant", content }],
+        },
+      ];
+    }
+
+    const item = auiV0DecodeSafely(assistantRow(content));
+
+    expect(item?.message.content[0]).toMatchObject({ type: "tool-call" });
+  });
+});
+
+describe("auiV0DecodeSafely against encoder output", () => {
+  const encodedRow = (message: ThreadAssistantMessage | ThreadUserMessage) =>
+    ({
+      id: message.id,
+      parent_id: null,
+      format: "aui/v0",
+      created_at: message.createdAt,
+      content: auiV0Encode(message),
+    }) as unknown as CloudMessage & { format: "aui/v0" };
+
+  it("keeps every assistant part the encoder writes", () => {
+    const message: ThreadAssistantMessage = {
+      id: "assistant-1",
+      role: "assistant",
+      status: { type: "complete", reason: "stop" },
+      createdAt: new Date(0),
+      metadata: {
+        unstable_state: null,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom: {},
+      },
+      content: [
+        { type: "text", text: "answer" },
+        { type: "reasoning", text: "thinking" },
+        {
+          type: "source",
+          sourceType: "url",
+          id: "src-1",
+          url: "https://x.dev",
+        },
+        { type: "image", image: "https://x.dev/a.png" },
+        { type: "file", data: "abc", mimeType: "text/plain" },
+        { type: "data", name: "weather", data: { city: "Berlin" } },
+        { type: "generative-ui", spec: { root: "a" } },
+        {
+          type: "tool-call",
+          toolCallId: "call-1",
+          toolName: "search",
+          args: { query: "a" },
+          argsText: '{"query":"a"}',
+        },
+        {
+          type: "tool-call",
+          toolCallId: "call-2",
+          toolName: "search",
+          args: { query: "b" },
+          argsText: '{"query":"b"',
+          messages: [
+            {
+              id: "nested-1",
+              role: "assistant",
+              status: { type: "complete", reason: "stop" },
+              createdAt: new Date(0),
+              content: [{ type: "text", text: "nested" }],
+              metadata: {
+                unstable_state: null,
+                unstable_annotations: [],
+                unstable_data: [],
+                steps: [],
+                custom: {},
+              },
+            },
+          ],
+        },
+      ],
+    };
+
+    const item = auiV0DecodeSafely(encodedRow(message));
+
+    expect(item?.message.content.map((part) => part.type)).toEqual(
+      message.content.map((part) => part.type),
+    );
+    // encodeNestedMessage writes an id and an ISO createdAt that no flat
+    // fixture carries, so the nested guard stack is only pinned here.
+    expect(item?.message.content.at(-1)).toMatchObject({
+      messages: [{ id: "nested-1", content: [{ type: "text" }] }],
+    });
+  });
+
+  it("keeps every user attachment part the encoder writes", () => {
+    const message: ThreadUserMessage = {
+      id: "user-1",
+      role: "user",
+      createdAt: new Date(0),
+      metadata: { custom: {} },
+      content: [{ type: "text", text: "look" }],
+      attachments: [
+        {
+          id: "attachment-1",
+          type: "document",
+          name: "notes.txt",
+          status: { type: "complete" },
+          content: [
+            { type: "text", text: "notes" },
+            { type: "image", image: "https://x.dev/a.png" },
+            { type: "file", data: "abc", mimeType: "text/plain" },
+            { type: "data", name: "weather", data: { city: "Berlin" } },
+            { type: "audio", audio: { data: "abc", format: "mp3" } },
+          ],
+        },
+      ],
+    };
+
+    const item = auiV0DecodeSafely(encodedRow(message));
+
+    expect(
+      (item?.message as ThreadUserMessage).attachments[0]?.content.map(
+        (part) => part.type,
+      ),
+    ).toEqual(message.attachments[0]?.content.map((part) => part.type));
+  });
+});

package/src/react/runtimes/cloud/createCloudThreadListAdapter.test.ts

@@ -4,6 +4,7 @@ import { describe, expect, it, vi } from "vitest";
 import { renderHook } from "@testing-library/react";
 import type { AssistantCloud } from "assistant-cloud";
 import { createCloudThreadListAdapter } from "./createCloudThreadListAdapter";
+import { CORE_SDK } from "./sdkIdentity";
 
 vi.mock("@assistant-ui/store", async (importOriginal) => ({
   ...(await importOriginal<typeof import("@assistant-ui/store")>()),
@@ -30,6 +31,7 @@ const makeCloud = () =>
       get: vi.fn(),
     },
     runs: { stream: vi.fn(async () => new ReadableStream()) },
+    registerSdk: vi.fn(),
   }) as unknown as AssistantCloud;
 
 describe("createCloudThreadListAdapter", () => {
@@ -83,6 +85,25 @@ describe("createCloudThreadListAdapter", () => {
     expect(adapter.unstable_Provider).toBeUndefined();
   });
 
+  it("registers core and the calling integration identities", () => {
+    const cloud = makeCloud();
+    const sdk = { name: "@assistant-ui/ai-sdk", version: "0.0.5" };
+
+    createCloudThreadListAdapter({ cloud, sdk });
+
+    expect(cloud.registerSdk).toHaveBeenNthCalledWith(1, CORE_SDK);
+    expect(cloud.registerSdk).toHaveBeenNthCalledWith(2, sdk);
+  });
+
+  it("registers only core without a calling integration identity", () => {
+    const cloud = makeCloud();
+
+    createCloudThreadListAdapter({ cloud });
+
+    expect(cloud.registerSdk).toHaveBeenCalledOnce();
+    expect(cloud.registerSdk).toHaveBeenCalledWith(CORE_SDK);
+  });
+
   it("constructs stable history and attachment adapters when the hook runs", () => {
     const cloud = makeCloud();
     const adapter = createCloudThreadListAdapter({ cloud });

package/src/react/runtimes/cloud/createCloudThreadListAdapter.ts

@@ -1,7 +1,7 @@
 declare const process: { env: Record<string, string | undefined> };
 
 import { type RefObject, useMemo, useState } from "react";
-import { AssistantCloud } from "assistant-cloud";
+import { AssistantCloud, type SdkIdentity } from "assistant-cloud";
 import type {
   RemoteThreadListAdapter,
   RuntimeAdapters,
@@ -10,6 +10,7 @@ import { InMemoryThreadListAdapter } from "../../../runtimes/remote-thread-list/
 import { useAssistantCloudThreadHistoryAdapter } from "./AssistantCloudThreadHistoryAdapter";
 import { CloudFileAttachmentAdapter } from "./CloudFileAttachmentAdapter";
 import { isRecord } from "../../../utils/json/is-json";
+import { CORE_SDK } from "./sdkIdentity";
 
 type ThreadData = {
   externalId: string | undefined;
@@ -17,6 +18,7 @@ type ThreadData = {
 
 export type CloudThreadListAdapterOptions = {
   cloud?: AssistantCloud | undefined;
+  sdk?: SdkIdentity | undefined;
 
   create?: (() => Promise<ThreadData>) | undefined;
   delete?: ((threadId: string) => Promise<void>) | undefined;
@@ -116,6 +118,10 @@ export const createCloudThreadListAdapter = (
     return inMemory;
   }
 
+  cloud.registerSdk?.(CORE_SDK);
+  const sdk = getOptions().sdk;
+  if (sdk) cloud.registerSdk?.(sdk);
+
   return {
     list: async ({ after } = {}) => {
       const {

package/src/react/runtimes/cloud/sdkIdentity.ts

@@ -0,0 +1,9 @@
+import type { SdkIdentity } from "assistant-cloud";
+
+export const CORE_SDK: SdkIdentity = {
+  name: "@assistant-ui/core",
+  version:
+    typeof __AUI_PACKAGE_VERSION__ === "string"
+      ? __AUI_PACKAGE_VERSION__
+      : "0.0.0",
+};

package/src/react/runtimes/cloud/useCloudThreadListAdapter.test.tsx

@@ -36,9 +36,11 @@ describe("useCloudThreadListAdapter", () => {
     const cloudDeleteA = vi.fn(async () => {});
     const cloudDeleteB = vi.fn(async () => {});
     const cloudA = {
+      registerSdk: vi.fn(),
       threads: { delete: cloudDeleteA },
     } as unknown as AssistantCloud;
     const cloudB = {
+      registerSdk: vi.fn(),
       threads: { delete: cloudDeleteB },
     } as unknown as AssistantCloud;
     const committed: { current: RemoteThreadListAdapter | null } = {
@@ -117,7 +119,10 @@ describe("useCloudThreadListAdapter", () => {
       .fn()
       .mockResolvedValueOnce({ threads: activeThreads })
       .mockResolvedValueOnce({ threads: archivedThreads });
-    const cloud = { threads: { list } } as unknown as AssistantCloud;
+    const cloud = {
+      registerSdk: vi.fn(),
+      threads: { list },
+    } as unknown as AssistantCloud;
     const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
 
     const page = await result.current.list();
@@ -149,7 +154,10 @@ describe("useCloudThreadListAdapter", () => {
       .mockResolvedValueOnce({ threads: firstPage })
       .mockResolvedValueOnce({ threads: [] })
       .mockResolvedValueOnce({ threads: secondPage });
-    const cloud = { threads: { list } } as unknown as AssistantCloud;
+    const cloud = {
+      registerSdk: vi.fn(),
+      threads: { list },
+    } as unknown as AssistantCloud;
     const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
 
     const first = await result.current.list();
@@ -186,7 +194,10 @@ describe("useCloudThreadListAdapter", () => {
       .mockResolvedValueOnce({ threads: archivedPage1 })
       .mockResolvedValueOnce({ threads: activePage2 })
       .mockResolvedValueOnce({ threads: archivedPage2 });
-    const cloud = { threads: { list } } as unknown as AssistantCloud;
+    const cloud = {
+      registerSdk: vi.fn(),
+      threads: { list },
+    } as unknown as AssistantCloud;
     const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
 
     const page1 = await result.current.list();
@@ -213,7 +224,10 @@ describe("useCloudThreadListAdapter", () => {
       .fn()
       .mockResolvedValueOnce({ threads: activeThreads })
       .mockResolvedValueOnce({ threads: [] });
-    const cloud = { threads: { list } } as unknown as AssistantCloud;
+    const cloud = {
+      registerSdk: vi.fn(),
+      threads: { list },
+    } as unknown as AssistantCloud;
     const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
 
     const page = await result.current.list({ after: "thread-20" });