@assistant-ui/ai-sdk 0.0.11 → 0.0.12

package/src/converters/convertMessage.test.ts

@@ -1390,7 +1390,9 @@ describe("AISDKMessageConverter", () => {
     const call = terminal[0]?.content.find(
       (part): part is any => part.type === "tool-call",
     );
-    expect(call?.args).toEqual({ city: "NYC" });
+    expect(Object.fromEntries(Object.entries(call?.args ?? {}))).toEqual({
+      city: "NYC",
+    });
     expect(call?.result).toEqual({ temp: 70 });
   });
 
@@ -2094,7 +2096,10 @@ describe("AISDKMessageConverter", () => {
     const toolCall = converted[0]?.content.find(
       (part): part is any => part.type === "tool-call",
     );
-    expect(toolCall?.args).toEqual({ city: "NYC", units: "F" });
+    expect(Object.fromEntries(Object.entries(toolCall?.args ?? {}))).toEqual({
+      city: "NYC",
+      units: "F",
+    });
     expect(toolCall?.argsText).toBe('{"city":"NYC","units":"F"}');
   });
 
@@ -2168,6 +2173,7 @@ describe("AISDKMessageConverter", () => {
 
     expect(a.argsText).toBe('{"a":1,"b":2}');
     expect(b.argsText).toBe('{"b":2,"a":1}');
+    expect(Object.keys(b.args)).toEqual(["a", "b"]);
 
     // Both entries must survive a reconversion: the key-order entries are gone
     // by now, so a cache miss would re-serialize B in raw key order.
@@ -2207,4 +2213,116 @@ describe("AISDKMessageConverter", () => {
     }
     expect(stableStringifySpy).toHaveBeenCalledTimes(1);
   });
+
+  it("skips null parts and parts without a type", () => {
+    const converted = AISDKMessageConverter.toThreadMessages([
+      {
+        id: "u1",
+        role: "user",
+        parts: [null, { text: "no type" }, { type: "text", text: "hi" }],
+      },
+      {
+        id: "a1",
+        role: "assistant",
+        parts: [null, { text: "no type" }, { type: "text", text: "yo" }],
+      },
+    ] as any);
+
+    expect(converted[0]?.content).toMatchObject([{ type: "text", text: "hi" }]);
+    expect(converted[0]?.attachments).toEqual([]);
+    expect(converted[1]?.content).toMatchObject([{ type: "text", text: "yo" }]);
+  });
+
+  it("joins the text parts of a system message into one text part", () => {
+    const converted = AISDKMessageConverter.toThreadMessages([
+      {
+        id: "s1",
+        role: "system",
+        parts: [
+          {
+            type: "text",
+            text: "be ",
+            providerMetadata: { p1: { k: "a" }, p2: { k: "b" } },
+          },
+          { type: "text", text: "brief", providerMetadata: { p2: { k: "c" } } },
+        ],
+      },
+      { id: "s2", role: "system", parts: [] },
+    ] as any);
+
+    expect(converted[0]?.content).toMatchObject([
+      {
+        type: "text",
+        text: "be brief",
+        providerMetadata: { p1: { k: "a" }, p2: { k: "c" } },
+      },
+    ]);
+    expect(converted[1]?.content).toMatchObject([{ type: "text", text: "" }]);
+    expect(converted[1]?.content[0]).not.toHaveProperty("providerMetadata");
+  });
+
+  it("reads a user text part without text as empty text", () => {
+    const converted = AISDKMessageConverter.toThreadMessages([
+      { id: "u1", role: "user", parts: [{ type: "text" }] },
+    ] as any);
+
+    expect(converted[0]?.content).toMatchObject([{ type: "text", text: "" }]);
+  });
+
+  it("skips a file part without a url and floors a missing mediaType", () => {
+    const converted = AISDKMessageConverter.toThreadMessages([
+      {
+        id: "u1",
+        role: "user",
+        parts: [{ type: "file", mediaType: "image/png", filename: "a.png" }],
+      },
+      {
+        id: "a1",
+        role: "assistant",
+        parts: [
+          { type: "file", mediaType: "image/png" },
+          { type: "file", url: "https://cdn/file.bin" },
+          { type: "reasoning-file", mediaType: "image/png" },
+          { type: "reasoning-file", url: "https://cdn/thought.bin" },
+        ],
+      },
+    ] as any);
+
+    expect(converted[0]?.attachments).toEqual([]);
+    expect(converted[1]?.content).toMatchObject([
+      {
+        type: "file",
+        data: "https://cdn/file.bin",
+        mimeType: "unknown/unknown",
+      },
+      {
+        type: "file",
+        data: "https://cdn/thought.bin",
+        mimeType: "unknown/unknown",
+      },
+    ]);
+  });
+
+  it("gives a dynamic tool call without a toolName an empty name", () => {
+    const converted = AISDKMessageConverter.toThreadMessages([
+      {
+        id: "a1",
+        role: "assistant",
+        parts: [
+          {
+            type: "dynamic-tool",
+            toolCallId: "tc-1",
+            state: "input-available",
+            input: {},
+          },
+        ],
+      },
+    ] as any);
+
+    expect(converted[0]?.content[0]).toMatchObject({
+      type: "tool-call",
+      toolCallId: "tc-1",
+      toolName: "",
+    });
+  });
 });

package/src/converters/convertMessage.tool-args-status.test.tsx

@@ -0,0 +1,185 @@
+import { describe, expect, it } from "vitest";
+import {
+  getPartialJsonObjectFieldState,
+  getPartialJsonObjectMeta,
+} from "assistant-stream/utils";
+import {
+  AISDKMessageConverter,
+  type AISDKMessageConverterMetadata,
+} from "./convertMessage";
+
+describe("AI SDK tool argument completion", () => {
+  it.each([{}, { city: "Paris", unit: "c" }])(
+    "marks input-available arguments complete before tool execution ends for %j",
+    (input) => {
+      const convert = (toolState: "input-streaming" | "input-available") => {
+        const message = AISDKMessageConverter.toThreadMessages(
+          [
+            {
+              id: "a1",
+              role: "assistant",
+              parts: [
+                {
+                  type: "tool-weather",
+                  toolCallId: "tc-1",
+                  state: toolState,
+                  input,
+                },
+              ],
+            },
+          ],
+          true,
+        )[0]!;
+        return message.content.find((part) => part.type === "tool-call")!;
+      };
+
+      const streaming = convert("input-streaming");
+      expect(getPartialJsonObjectMeta(streaming.args)?.state).toBe("partial");
+
+      const available = convert("input-available");
+      expect(Object.fromEntries(Object.entries(available.args))).toEqual(input);
+      expect(JSON.parse(available.argsText)).toEqual(input);
+      expect(getPartialJsonObjectMeta(available.args)?.state).toBe("complete");
+      for (const key of Object.keys(input)) {
+        expect(getPartialJsonObjectFieldState(available.args, [key])).toBe(
+          "complete",
+        );
+      }
+    },
+  );
+
+  it("keeps the streaming frontier partial until input becomes available", () => {
+    const message = AISDKMessageConverter.toThreadMessages(
+      [
+        {
+          id: "a1",
+          role: "assistant",
+          parts: [
+            {
+              type: "tool-weather",
+              toolCallId: "tc-1",
+              state: "input-streaming",
+              input: { city: "Paris", unit: "c" },
+            },
+          ],
+        },
+      ],
+      true,
+    )[0]!;
+    const part = message.content.find((item) => item.type === "tool-call")!;
+    expect(getPartialJsonObjectMeta(part.args)?.state).toBe("partial");
+    expect(getPartialJsonObjectFieldState(part.args, ["city"])).toBe(
+      "complete",
+    );
+    expect(getPartialJsonObjectFieldState(part.args, ["unit"])).toBe("partial");
+  });
+
+  it.each([
+    {
+      state: "approval-responded",
+      approval: { id: "approval-1", approved: true },
+    },
+    {
+      state: "output-available",
+      output: { progress: 50 },
+      preliminary: true,
+    },
+  ])("marks settled $state input complete while the part runs", (tool) => {
+    const message = AISDKMessageConverter.toThreadMessages(
+      [
+        {
+          id: "a1",
+          role: "assistant",
+          parts: [
+            {
+              type: "tool-weather",
+              toolCallId: "tc-1",
+              input: { city: "Paris" },
+              ...tool,
+            },
+          ],
+        },
+      ] as any,
+      true,
+    )[0]!;
+    const part = message.content.find((item) => item.type === "tool-call")!;
+    expect(message.status?.type).toBe("running");
+    expect(getPartialJsonObjectMeta(part.args)?.state).toBe("complete");
+    expect(getPartialJsonObjectFieldState(part.args, ["city"])).toBe(
+      "complete",
+    );
+  });
+
+  it("reuses marked arguments when the settled input object is unchanged", () => {
+    const input = { weather: { city: "Paris" } };
+    const metadata: AISDKMessageConverterMetadata = {
+      toolArgsTextCache: new WeakMap(),
+    };
+    const convert = () =>
+      AISDKMessageConverter.toThreadMessages(
+        [
+          {
+            id: "a1",
+            role: "assistant",
+            parts: [
+              {
+                type: "tool-weather",
+                toolCallId: "tc-1",
+                state: "input-available",
+                input,
+              },
+            ],
+          },
+        ],
+        true,
+        metadata,
+      )[0]!.content.find((part) => part.type === "tool-call")!;
+
+    const first = convert();
+    const second = convert();
+    expect(first.args).toBe(second.args);
+    expect(first.args).not.toBe(input);
+    expect(first.args.weather).toBe(input.weather);
+    expect(first.argsText).toBe(second.argsText);
+    expect(getPartialJsonObjectMeta(second.args)?.state).toBe("complete");
+  });
+
+  it.each([
+    '{"__proto__":{"polluted":true}}',
+    '{"constructor":{"prototype":{"polluted":true}}}',
+  ])(
+    "marks settled prototype-named input complete while the tool runs: %s",
+    (json) => {
+      const input = JSON.parse(json);
+      const message = AISDKMessageConverter.toThreadMessages(
+        [
+          {
+            id: "a1",
+            role: "assistant",
+            parts: [
+              {
+                type: "tool-weather",
+                toolCallId: "tc-1",
+                state: "input-available",
+                input,
+              },
+            ],
+          },
+        ],
+        true,
+      )[0]!;
+      const part = message.content.find((item) => item.type === "tool-call")!;
+
+      expect(message.status?.type).toBe("running");
+      expect(part.args).not.toBe(input);
+      expect(Object.entries(part.args)).toEqual(Object.entries(input));
+      expect(Object.getPrototypeOf(part.args)).toBe(Object.prototype);
+      expect(Object.prototype).not.toHaveProperty("polluted");
+      expect(JSON.parse(part.argsText)).toEqual(input);
+      expect(getPartialJsonObjectMeta(part.args)?.state).toBe("complete");
+      expect(
+        getPartialJsonObjectFieldState(part.args, [Object.keys(input)[0]!]),
+      ).toBe("complete");
+    },
+  );
+});

package/src/converters/convertMessage.ts

@@ -3,6 +3,7 @@ import {
   isReasoningFileUIPart,
   isCustomContentUIPart,
   getToolName,
+  type FileUIPart,
   type UIMessage,
 } from "ai";
 import {
@@ -30,11 +31,12 @@ import {
 } from "@assistant-ui/core";
 import { normalizeToolApprovalAnswers } from "./toolApprovalAnswers";
 import { stableStringifyToolArgs } from "@assistant-ui/core/internal";
+import { markPartialJsonObjectComplete } from "assistant-stream/internal";
 import {
   parsePartialJsonObject,
   type ReadonlyJSONObject,
 } from "assistant-stream/utils";
-import { unwrapModelContentEnvelope } from "./modelContentEnvelope";
+import { unwrapModelContentEnvelope } from "assistant-stream/internal";
 
 type MessageMetadata = ThreadMessageLike["metadata"];
 
@@ -66,13 +68,15 @@ export type AISDKMessageConverterMetadata =
   useExternalMessageConverter.Metadata & {
     toolArgsKeyOrderCache?: Map<string, Map<string, string[]>>;
     /**
-     * Frozen `argsText` keyed weakly by a settled tool call's input object, then
-     * by call, since the text carries the call's streamed key order. A known
-     * call/input pair skips serialization; the entries become collectible once
-     * the input is unreachable. A fresh input object re-serializes in its own
-     * deterministic key order.
+     * Frozen text and completion-marked args keyed weakly by a settled tool
+     * call's input object, then by call, since the text carries its streamed key
+     * order. A known call/input pair skips serialization and parsing; entries
+     * become collectible once the input is unreachable.
      */
-    toolArgsTextCache?: WeakMap<ReadonlyJSONObject, Map<string, string>>;
+    toolArgsTextCache?: WeakMap<
+      ReadonlyJSONObject,
+      Map<string, { argsText: string; args: ReadonlyJSONObject }>
+    >;
     toolLastInputCache?: Map<string, ReadonlyJSONObject>;
     mcpAppMetadataCache?: Map<string, McpAppMetadata>;
     toolArtifacts?: ReadonlyMap<string, unknown>;
@@ -457,6 +461,25 @@ const uiPartStateToStatus = (
   return undefined;
 };
 
+const toSystemContent = (content: MessageContent): MessageContent => {
+  const text = content.filter((part) => part.type === "text");
+  if (text.length === 1) return text;
+  const providerMetadata = text.reduce<PartProviderMetadata>(
+    (merged, part) =>
+      part.providerMetadata != null
+        ? { ...merged, ...part.providerMetadata }
+        : merged,
+    {},
+  );
+  return [
+    {
+      type: "text",
+      text: text.map((part) => part.text).join(""),
+      ...(Object.keys(providerMetadata).length > 0 && { providerMetadata }),
+    },
+  ];
+};
+
 function convertParts(
   message: UIMessage,
   metadata: AISDKMessageConverterMetadata,
@@ -468,6 +491,7 @@ function convertParts(
   const converted = message.parts
     .filter(
       (p) =>
+        typeof p?.type === "string" &&
         p.type !== "step-start" &&
         (message.role !== "user" || p.type !== "file"),
     )
@@ -476,7 +500,7 @@ function convertParts(
         const status = uiPartStateToStatus(part.state);
         return {
           type: "text",
-          text: part.text,
+          text: part.text ?? "",
           ...(status != null ? { status } : undefined),
           ...(part.providerMetadata != null
             ? {
@@ -501,7 +525,7 @@ function convertParts(
       }
 
       if (isToolUIPart(part)) {
-        const toolName = getToolName(part);
+        const toolName = getToolName(part) ?? "";
         const toolCallId = part.toolCallId;
         const argsKeyOrderCacheKey = `${message.id}:${toolCallId}`;
 
@@ -565,20 +589,31 @@ function convertParts(
           // re-serializing large args while the call keeps that input. Arrival
           // order only matters while args stream, so the key-order entry is
           // released.
+          const inputArgs = args;
           const frozen =
-            metadata.toolArgsTextCache?.get(args) ?? new Map<string, string>();
-          const frozenText = frozen.get(argsKeyOrderCacheKey);
-          if (frozenText !== undefined) {
-            argsText = frozenText;
+            metadata.toolArgsTextCache?.get(inputArgs) ??
+            new Map<string, { argsText: string; args: ReadonlyJSONObject }>();
+          const frozenEntry = frozen.get(argsKeyOrderCacheKey);
+          if (frozenEntry !== undefined) {
+            argsText = frozenEntry.argsText;
+            args = frozenEntry.args;
           } else {
             argsText = stableStringifyToolArgs(
               metadata.toolArgsKeyOrderCache,
               argsKeyOrderCacheKey,
               args,
             );
+            // The input is final even while execution keeps the part running.
+            // Other runtimes can synthesize complete JSON text from an
+            // accumulating snapshot, so only this converter supplies the
+            // completion signal it knows from the AI SDK part state.
+            // A complete root marker settles every field without parsing the
+            // serialized text again. Keep the SDK input's nested identities
+            // and own fields, including prototype-named JSON keys.
+            args = markPartialJsonObjectComplete(args);
             metadata.toolArgsTextCache?.set(
-              args,
-              frozen.set(argsKeyOrderCacheKey, argsText),
+              inputArgs,
+              frozen.set(argsKeyOrderCacheKey, { argsText, args }),
             );
           }
           metadata.toolArgsKeyOrderCache?.delete(argsKeyOrderCacheKey);
@@ -647,10 +682,11 @@ function convertParts(
       }
 
       if (part.type === "file") {
+        if (typeof part.url !== "string") return null;
         return {
           type: "file",
           data: part.url,
-          mimeType: part.mediaType,
+          mimeType: part.mediaType ?? "unknown/unknown",
           ...(part.filename != null && { filename: part.filename }),
         } satisfies FileMessagePart;
       }
@@ -684,10 +720,11 @@ function convertParts(
       }
 
       if (isReasoningFileUIPart(part)) {
+        if (typeof part.url !== "string") return null;
         return {
           type: "file",
           data: part.url,
-          mimeType: part.mediaType,
+          mimeType: part.mediaType ?? "unknown/unknown",
         } satisfies FileMessagePart;
       }
 
@@ -727,7 +764,10 @@ export const AISDKMessageConverter = unstable_createMessageConverter(
           createdAt,
           content,
           attachments: message.parts
-            ?.filter((p) => p.type === "file")
+            ?.filter(
+              (p): p is FileUIPart =>
+                p?.type === "file" && typeof p.url === "string",
+            )
             .map((part, idx) => {
               const mediaType = part.mediaType ?? "unknown/unknown";
               const isImage = mediaType.startsWith("image/");
@@ -766,7 +806,8 @@ export const AISDKMessageConverter = unstable_createMessageConverter(
           role: message.role,
           id: message.id,
           createdAt,
-          content,
+          content:
+            message.role === "system" ? toSystemContent(content) : content,
           ...(message.role === "assistant" &&
           metadata.cancelledStatusMessageIds?.has(message.id)
             ? {

package/src/converters/toCreateMessage.test.ts

@@ -11,6 +11,33 @@ const baseMessage = {
 } as const;
 
 describe("toCreateMessage", () => {
+  it.each([
+    [
+      "data:;base64,SGVsbG8=",
+      "data:application/octet-stream;base64,SGVsbG8=",
+      "application/octet-stream",
+    ],
+    [
+      "data:;charset=utf-8,hello",
+      "data:text/plain;charset=utf-8,hello",
+      "text/plain",
+    ],
+    [
+      "data:;base64,",
+      "data:application/octet-stream;base64,",
+      "application/octet-stream",
+    ],
+  ])("uses the resolved media type for %s", (data, url, mediaType) => {
+    const message = {
+      ...baseMessage,
+      content: [{ type: "file", data, mimeType: "" }],
+    } as unknown as AppendMessage;
+
+    expect(toCreateMessage(message).parts).toEqual([
+      { type: "file", url, mediaType },
+    ]);
+  });
+
   it("converts a direct file part in message content", () => {
     const message = {
       ...baseMessage,

package/src/index.native.ts

@@ -12,7 +12,7 @@ export type {
   AssistantChatResumableOptions,
   ResumableClientStorage,
 } from "./transport/resumable";
-export { frontendTools, type FrontendTools } from "./tools/frontendTools";
+export { frontendTools, type FrontendTools } from "assistant-stream/ai-sdk";
 export { injectQuoteContext } from "./model-context/injectQuoteContext";
 export { unstable_injectInteractableContext } from "./model-context/injectInteractableContext";
 export type { ThreadTokenUsage, TokenUsageExtractableMessage } from "./usage";

package/src/index.ts

@@ -12,7 +12,7 @@ export type {
   AssistantChatResumableOptions,
   ResumableClientStorage,
 } from "./transport/resumable";
-export { frontendTools, type FrontendTools } from "./tools/frontendTools";
+export { frontendTools, type FrontendTools } from "assistant-stream/ai-sdk";
 export { injectQuoteContext } from "./model-context/injectQuoteContext";
 export { unstable_injectInteractableContext } from "./model-context/injectInteractableContext";
 export type { ThreadTokenUsage, TokenUsageExtractableMessage } from "./usage";

package/src/model-context/injectInteractableContext.ts

@@ -20,6 +20,8 @@ import {
  * `format` must also handle entries with `partial: true`, whose `state` carries
  * only the fields that changed since the model's last known state.
  *
+ * @deprecated Experimental since 2026-06-23. Not scheduled for removal; the API may change in any release.
+ *
  * @example
  * ```ts
  * import { convertToModelMessages, streamText } from "ai";
@@ -28,6 +30,7 @@ import {
  * export async function POST(req: Request) {
  *   const { messages } = await req.json();
  *   const result = streamText({
+ *     abortSignal: req.signal,
  *     model: myModel,
  *     messages: await convertToModelMessages(unstable_injectInteractableContext(messages)),
  *   });

package/src/model-context/injectQuoteContext.ts

@@ -27,6 +27,7 @@ const getQuoteText = (metadata: unknown): string | undefined => {
  * export async function POST(req: Request) {
  *   const { messages } = await req.json();
  *   const result = streamText({
+ *     abortSignal: req.signal,
  *     model: myModel,
  *     messages: await convertToModelMessages(injectQuoteContext(messages)),
  *   });

package/src/runtime/AISDKChat.integration.test.tsx

@@ -1,10 +1,11 @@
+import { flushTapSync } from "@assistant-ui/tap";
 // @vitest-environment jsdom
 
-import { StrictMode, type ReactNode } from "react";
+import { StrictMode, useLayoutEffect, type ReactNode } from "react";
 import { act, render, waitFor } from "@testing-library/react";
 import { AuiConfig, AuiProvider, useAui } from "@assistant-ui/store";
 import type { ChatTransport, UIMessage } from "ai";
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import { AISDKChat } from "./AISDKChat";
 import {
   createCancellableTransport,
@@ -66,3 +67,57 @@ describe("AISDKChat legacy useAui host integration", () => {
     await waitFor(() => expect(getCancelCount()).toBe(1));
   });
 });
+
+describe("replacement transports", () => {
+  it("routes sends through a replacement transport", async () => {
+    const emptyStream = () =>
+      new ReadableStream({ start: (controller) => controller.close() });
+    const sendA = vi.fn(async () => emptyStream());
+    const sendB = vi.fn(async () => emptyStream());
+    const transportA: ChatTransport<UIMessage> = {
+      sendMessages: sendA,
+      reconnectToStream: vi.fn(),
+    };
+    const transportB: ChatTransport<UIMessage> = {
+      sendMessages: sendB,
+      reconnectToStream: vi.fn(),
+    };
+    let initialClient: ReturnType<typeof useAui> | undefined;
+    let currentClient: ReturnType<typeof useAui> | undefined;
+    const CaptureClient = () => {
+      const aui = useAui();
+      initialClient ??= aui;
+      currentClient = aui;
+      return null;
+    };
+    const SendOnLayout = () => {
+      const aui = useAui();
+      useLayoutEffect(() => {
+        flushTapSync(() => {
+          aui.composer.setText("hello");
+          aui.composer.send();
+        });
+      }, [aui]);
+      return null;
+    };
+    const App = ({
+      transport,
+      send = false,
+    }: {
+      transport: ChatTransport<UIMessage>;
+      send?: boolean;
+    }) => (
+      <AuiProvider config={AuiConfig({ threads: AISDKChat({ transport }) })}>
+        <CaptureClient />
+        {send && <SendOnLayout />}
+      </AuiProvider>
+    );
+
+    const view = render(<App transport={transportA} />);
+    view.rerender(<App transport={transportB} send />);
+
+    await waitFor(() => expect(sendB).toHaveBeenCalledOnce());
+    expect(sendA).not.toHaveBeenCalled();
+    expect(currentClient).toBe(initialClient);
+  });
+});

package/src/runtime/AISDKThreads.cloud.test.ts

@@ -79,10 +79,12 @@ import { AI_SDK_SDK } from "./sdkIdentity";
 describe("AISDKThreads cloud", () => {
   it("reloads history when switching a keyed cloud thread", async () => {
     const cloud = {} as AssistantCloud;
+    const scopeId = "workspace-1";
     const handle = createAssistantClient(
       AuiConfig({
         threads: AISDKThreads({
           cloud,
+          scopeId,
           threadId: "t1",
         }),
       }),
@@ -98,6 +100,7 @@ describe("AISDKThreads cloud", () => {
     });
     expect(mocks.useCloudThreadListAdapter).toHaveBeenCalledWith({
       cloud,
+      scopeId,
       sdk: AI_SDK_SDK,
     });
     const afterFirst = load.mock.calls.length;