@assistant-ui/ai-sdk 0.0.8 → 0.0.10

package/src/converters/convertMessage.test.ts

@@ -970,6 +970,69 @@ describe("AISDKMessageConverter", () => {
     expect(toolCall?.argsText).toBe('{"city":"NYC');
   });
 
+  it("strips exactly the trailing run of closing characters", () => {
+    const convertArgsText = (text: string) => {
+      stableStringifySpy.mockReturnValueOnce(text);
+      const converted = AISDKMessageConverter.toThreadMessages([
+        {
+          id: "a1",
+          role: "assistant",
+          parts: [
+            {
+              type: "tool-weather",
+              toolCallId: "tc-1",
+              state: "input-streaming",
+              input: {},
+            },
+          ],
+        },
+      ] as any);
+      return (converted[0]?.content[0] as any)?.argsText;
+    };
+    const alphabet = ["}", "]", '"', "a", "\\", "{", "[", "\n", " ", "😀"];
+    let seed = 7;
+    const next = () => (seed = (seed * 48271) % 0x7fffffff);
+    const texts = ["", "}", '"]}', '{"a":"x"}', '{"a":"}}x"}', "\uD800}"];
+    for (let i = 0; i < 300; i++) {
+      texts.push(
+        Array.from(
+          { length: next() % 12 },
+          () => alphabet[next() % alphabet.length],
+        ).join(""),
+      );
+    }
+
+    for (const text of texts) {
+      expect(convertArgsText(text)).toBe(text.replace(/[}\]"]+$/, ""));
+    }
+  });
+
+  it(
+    "strips a long run of closing characters inside streaming input",
+    { timeout: 5_000 },
+    () => {
+      const run = "}".repeat(200_000);
+      const converted = AISDKMessageConverter.toThreadMessages([
+        {
+          id: "a1",
+          role: "assistant",
+          parts: [
+            {
+              type: "tool-weather",
+              toolCallId: "tc-1",
+              state: "input-streaming",
+              input: { code: `${run}x` },
+            },
+          ],
+        },
+      ] as any);
+
+      expect((converted[0]?.content[0] as any)?.argsText).toBe(
+        `{"code":"${run}x`,
+      );
+    },
+  );
+
   it("attaches partial-JSON meta marking the trailing streaming field", () => {
     const converted = AISDKMessageConverter.toThreadMessages([
       {
@@ -1420,6 +1483,42 @@ describe("AISDKMessageConverter", () => {
     expect(converted[0]?.content[2]).not.toHaveProperty("providerMetadata");
   });
 
+  it("keeps a step scoped reasoning block id off the part", () => {
+    const converted = AISDKMessageConverter.toThreadMessages([
+      {
+        id: "a1",
+        role: "assistant",
+        parts: [
+          { type: "reasoning", id: "reasoning-0", text: "first step" },
+          { type: "text", text: "answer" },
+          { type: "reasoning", id: "reasoning-0", text: "second step" },
+        ],
+      } as any,
+    ]);
+
+    expect(converted[0]?.content[0]).toMatchObject({ type: "reasoning" });
+    expect(converted[0]?.content[0]).not.toHaveProperty("id");
+    expect(converted[0]?.content[1]).not.toHaveProperty("id");
+    expect(converted[0]?.content[2]).not.toHaveProperty("id");
+  });
+
+  it("forwards data part ids", () => {
+    const converted = AISDKMessageConverter.toThreadMessages([
+      {
+        id: "a1",
+        role: "assistant",
+        parts: [{ type: "data-chart", id: "data-1", data: { x: 1 } }],
+      } as any,
+    ]);
+
+    expect(converted[0]?.content[0]).toMatchObject({
+      type: "data",
+      id: "data-1",
+      name: "chart",
+      data: { x: 1 },
+    });
+  });
+
   it("maps TextUIPart.state onto the per-part status", () => {
     const converted = AISDKMessageConverter.toThreadMessages([
       {

package/src/converters/convertMessage.ts

@@ -76,12 +76,16 @@ export type AISDKMessageConverterMetadata =
     toolInteractions?: ReadonlyMap<string, Unstable_ToolInteractionLog>;
     supportsRichToolApprovalResponses?: boolean;
     toolApprovalResponses?: ReadonlyMap<string, RespondToToolApprovalOptions>;
+    cancelledToolApprovalIds?: ReadonlySet<string>;
+    cancelledStatusMessageIds?: ReadonlySet<string>;
     /** Id of the currently-streaming message, flagged optimistic (#4037). */
     optimisticMessageId?: string | undefined;
   };
 
 function stripClosingDelimiters(json: string): string {
-  return json.replace(/[}\]"]+$/, "");
+  let end = json.length;
+  while (end > 0 && '}]"'.includes(json[end - 1]!)) end--;
+  return json.slice(0, end);
 }
 
 const MCP_APP_METADATA_CACHE_MAX = 100;
@@ -258,15 +262,23 @@ function getToolApprovalAndInterrupt(
   toolApprovalResponses:
     | ReadonlyMap<string, RespondToToolApprovalOptions>
     | undefined,
+  cancelledToolApprovalIds: ReadonlySet<string> | undefined,
 ): {
   approval?: NonNullable<ToolCallMessagePart["approval"]>;
   interrupt?: NonNullable<ToolCallMessagePart["interrupt"]>;
 } {
   if (part.approval) {
-    const approval = {
+    const rawApproval = {
       ...readApprovalDescriptor(part.approval.descriptor),
       ...part.approval,
     };
+    const approval =
+      typeof rawApproval.id === "string" &&
+      rawApproval.approved === undefined &&
+      rawApproval.resolution === undefined &&
+      cancelledToolApprovalIds?.has(rawApproval.id)
+        ? { ...rawApproval, resolution: "cancelled" as const }
+        : rawApproval;
     const response =
       typeof approval.id === "string" &&
       approval.approved === undefined &&
@@ -523,6 +535,7 @@ function convertParts(
             toolStatus,
             metadata.supportsRichToolApprovalResponses === true,
             metadata.toolApprovalResponses,
+            metadata.cancelledToolApprovalIds,
           ),
         } satisfies ToolCallMessagePart;
       }
@@ -572,6 +585,9 @@ function convertParts(
       if (part.type.startsWith("data-")) {
         return {
           type: "data",
+          ...("id" in part && typeof part.id === "string"
+            ? { id: part.id }
+            : undefined),
           name: part.type.substring(5),
           data: (part as any).data,
         } satisfies DataMessagePart;
@@ -661,6 +677,15 @@ export const AISDKMessageConverter = unstable_createMessageConverter(
           id: message.id,
           createdAt,
           content,
+          ...(message.role === "assistant" &&
+          metadata.cancelledStatusMessageIds?.has(message.id)
+            ? {
+                status: {
+                  type: "incomplete" as const,
+                  reason: "cancelled" as const,
+                },
+              }
+            : undefined),
           metadata: {
             ...toThreadMetadata(message.metadata),
             ...(timing && { timing }),

package/src/converters/toCreateMessage.test.ts

@@ -185,6 +185,19 @@ describe("toCreateMessage", () => {
     ]);
   });
 
+  it("forwards a data part id", () => {
+    const message = {
+      ...baseMessage,
+      content: [
+        { type: "data", name: "workflow", id: "p1", data: { field: 1 } },
+      ],
+    } as unknown as AppendMessage;
+
+    expect(toCreateMessage(message).parts).toEqual([
+      { type: "data-workflow", id: "p1", data: { field: 1 } },
+    ]);
+  });
+
   it("converts a data part inside an attachment without throwing", () => {
     const message = {
       ...baseMessage,

package/src/converters/toCreateMessage.ts

@@ -86,6 +86,7 @@ export const toCreateMessage = <UI_MESSAGE extends UIMessage = UIMessage>(
         return {
           type: `data-${part.name}`,
           data: part.data,
+          ...(part.id !== undefined && { id: part.id }),
         };
       default:
         throw new Error(`Unsupported part type: ${part.type}`);

package/src/runtime/AISDKChat.ts

@@ -18,10 +18,6 @@ const useAISDKChat = <UI_MESSAGE extends UIMessage = UIMessage>(
   options?: AISDKChatOptions<UI_MESSAGE>,
 ) => {
   const [id] = useState(() => options?.id ?? generateId());
-  // The transport resolves the request id from the thread list item, falling
-  // back to the runtime's main item, whose id here is the external store's
-  // placeholder constant. The single thread of this entry is the chat itself,
-  // so the handed-over item initializes to the chat id.
   const [threadListItem] = useState(() => ({
     initialize: async () => ({ remoteId: id, externalId: undefined }),
   }));

package/src/runtime/AISDKThreads.test.ts

@@ -56,6 +56,32 @@ const chatCallbacks = () => ({
 });
 
 describe("AISDKThreads", () => {
+  it("emits the selected thread id when its composer sends", async () => {
+    const { transport } = createControlledTransport();
+    const handle = createAssistantClient(
+      AuiConfig({ threads: AISDKThreads({ transport }) }),
+    );
+    try {
+      handle.subscribe(() => {});
+      const aui = handle.getClient();
+      const sent = vi.fn();
+      aui.on({ scope: "thread", event: "composer.send" }, sent);
+
+      flushTapSync(() => aui.composer.setText("hello"));
+      flushTapSync(() => aui.composer.send());
+
+      await vi.waitFor(() => {
+        expect(sent).toHaveBeenCalledWith(
+          expect.objectContaining({
+            threadId: aui.threads.getState().mainThreadId,
+          }),
+        );
+      });
+    } finally {
+      handle.destroy();
+    }
+  });
+
   it("runs one chat per thread and keeps histories isolated across switches", async () => {
     const { transport, emit, close } = createControlledTransport();
     const handle = createAssistantClient(