@assistant-ui/react-ai-sdk 1.3.31 → 1.3.32

package/dist/ui/utils/toCreateMessage.js

@@ -21,6 +21,10 @@ const toCreateMessage = (message) => {
 				mediaType: part.mimeType,
 				...part.filename && { filename: part.filename }
 			};
+			case "data": return {
+				type: `data-${part.name}`,
+				data: part.data
+			};
 			default: throw new Error(`Unsupported part type: ${part.type}`);
 		}
 	});

package/dist/ui/utils/toCreateMessage.js.map

@@ -1 +1 @@
-{"version":3,"file":"toCreateMessage.js","names":[],"sources":["../../../src/ui/utils/toCreateMessage.ts"],"sourcesContent":["import type { AppendMessage } from \"@assistant-ui/core\";\nimport type {\n  CreateUIMessage,\n  UIDataTypes,\n  UIMessage,\n  UIMessagePart,\n  UITools,\n} from \"ai\";\n\nexport const toCreateMessage = <UI_MESSAGE extends UIMessage = UIMessage>(\n  message: AppendMessage,\n): CreateUIMessage<UI_MESSAGE> => {\n  const inputParts = [\n    ...message.content.filter((c) => c.type !== \"file\"),\n    ...(message.attachments?.flatMap((a) =>\n      a.content.map((c) => ({\n        ...c,\n        filename: a.name,\n      })),\n    ) ?? []),\n  ];\n\n  const parts = inputParts.map((part): UIMessagePart<UIDataTypes, UITools> => {\n    switch (part.type) {\n      case \"text\":\n        return {\n          type: \"text\",\n          text: part.text,\n        };\n      case \"image\":\n        return {\n          type: \"file\",\n          url: part.image,\n          ...(part.filename && { filename: part.filename }),\n          mediaType: \"image/png\",\n        };\n      case \"file\":\n        return {\n          type: \"file\",\n          url: part.data,\n          mediaType: part.mimeType,\n          ...(part.filename && { filename: part.filename }),\n        };\n      default:\n        throw new Error(`Unsupported part type: ${part.type}`);\n    }\n  });\n\n  return {\n    role: message.role,\n    parts,\n    metadata: message.metadata,\n  } satisfies CreateUIMessage<UIMessage> as CreateUIMessage<UI_MESSAGE>;\n};\n"],"mappings":";AASA,MAAa,mBACX,YACgC;CAWhC,MAAM,QAAQ,CATZ,GAAG,QAAQ,QAAQ,QAAQ,MAAM,EAAE,SAAS,MAAM,GAClD,GAAI,QAAQ,aAAa,SAAS,MAChC,EAAE,QAAQ,KAAK,OAAO;EACpB,GAAG;EACH,UAAU,EAAE;CACd,EAAE,CACJ,KAAK,CAAC,CAGe,EAAE,KAAK,SAA8C;EAC1E,QAAQ,KAAK,MAAb;GACE,KAAK,QACH,OAAO;IACL,MAAM;IACN,MAAM,KAAK;GACb;GACF,KAAK,SACH,OAAO;IACL,MAAM;IACN,KAAK,KAAK;IACV,GAAI,KAAK,YAAY,EAAE,UAAU,KAAK,SAAS;IAC/C,WAAW;GACb;GACF,KAAK,QACH,OAAO;IACL,MAAM;IACN,KAAK,KAAK;IACV,WAAW,KAAK;IAChB,GAAI,KAAK,YAAY,EAAE,UAAU,KAAK,SAAS;GACjD;GACF,SACE,MAAM,IAAI,MAAM,0BAA0B,KAAK,MAAM;EACzD;CACF,CAAC;CAED,OAAO;EACL,MAAM,QAAQ;EACd;EACA,UAAU,QAAQ;CACpB;AACF"}
+{"version":3,"file":"toCreateMessage.js","names":[],"sources":["../../../src/ui/utils/toCreateMessage.ts"],"sourcesContent":["import type { AppendMessage } from \"@assistant-ui/core\";\nimport type {\n  CreateUIMessage,\n  UIDataTypes,\n  UIMessage,\n  UIMessagePart,\n  UITools,\n} from \"ai\";\n\nexport const toCreateMessage = <UI_MESSAGE extends UIMessage = UIMessage>(\n  message: AppendMessage,\n): CreateUIMessage<UI_MESSAGE> => {\n  const inputParts = [\n    ...message.content.filter((c) => c.type !== \"file\"),\n    ...(message.attachments?.flatMap((a) =>\n      a.content.map((c) => ({\n        ...c,\n        filename: a.name,\n      })),\n    ) ?? []),\n  ];\n\n  const parts = inputParts.map((part): UIMessagePart<UIDataTypes, UITools> => {\n    switch (part.type) {\n      case \"text\":\n        return {\n          type: \"text\",\n          text: part.text,\n        };\n      case \"image\":\n        return {\n          type: \"file\",\n          url: part.image,\n          ...(part.filename && { filename: part.filename }),\n          mediaType: \"image/png\",\n        };\n      case \"file\":\n        return {\n          type: \"file\",\n          url: part.data,\n          mediaType: part.mimeType,\n          ...(part.filename && { filename: part.filename }),\n        };\n      case \"data\":\n        return {\n          type: `data-${part.name}`,\n          data: part.data,\n        };\n      default:\n        throw new Error(`Unsupported part type: ${part.type}`);\n    }\n  });\n\n  return {\n    role: message.role,\n    parts,\n    metadata: message.metadata,\n  } satisfies CreateUIMessage<UIMessage> as CreateUIMessage<UI_MESSAGE>;\n};\n"],"mappings":";AASA,MAAa,mBACX,YACgC;CAWhC,MAAM,QAAQ,CATZ,GAAG,QAAQ,QAAQ,QAAQ,MAAM,EAAE,SAAS,MAAM,GAClD,GAAI,QAAQ,aAAa,SAAS,MAChC,EAAE,QAAQ,KAAK,OAAO;EACpB,GAAG;EACH,UAAU,EAAE;CACd,EAAE,CACJ,KAAK,CAAC,CAGe,EAAE,KAAK,SAA8C;EAC1E,QAAQ,KAAK,MAAb;GACE,KAAK,QACH,OAAO;IACL,MAAM;IACN,MAAM,KAAK;GACb;GACF,KAAK,SACH,OAAO;IACL,MAAM;IACN,KAAK,KAAK;IACV,GAAI,KAAK,YAAY,EAAE,UAAU,KAAK,SAAS;IAC/C,WAAW;GACb;GACF,KAAK,QACH,OAAO;IACL,MAAM;IACN,KAAK,KAAK;IACV,WAAW,KAAK;IAChB,GAAI,KAAK,YAAY,EAAE,UAAU,KAAK,SAAS;GACjD;GACF,KAAK,QACH,OAAO;IACL,MAAM,QAAQ,KAAK;IACnB,MAAM,KAAK;GACb;GACF,SACE,MAAM,IAAI,MAAM,0BAA0B,KAAK,MAAM;EACzD;CACF,CAAC;CAED,OAAO;EACL,MAAM,QAAQ;EACd;EACA,UAAU,QAAQ;CACpB;AACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/react-ai-sdk",
-  "version": "1.3.31",
+  "version": "1.3.32",
   "description": "Vercel AI SDK adapter for assistant-ui",
   "keywords": [
     "ai-sdk",
@@ -30,8 +30,9 @@
   ],
   "sideEffects": false,
   "dependencies": {
+    "@ai-sdk/mcp": "^1.0.45",
     "@ai-sdk/react": "^3.0.195",
-    "@assistant-ui/core": "^0.2.8",
+    "@assistant-ui/core": "^0.2.10",
     "@assistant-ui/store": "^0.2.13",
     "ai": "^6.0.193",
     "assistant-cloud": "*"
@@ -53,8 +54,8 @@
     "jsdom": "^29.1.1",
     "react": "^19.2.6",
     "vitest": "^4.1.7",
-    "@assistant-ui/x-buildutils": "0.0.10",
-    "assistant-stream": "0.3.18"
+    "assistant-stream": "0.3.20",
+    "@assistant-ui/x-buildutils": "0.0.11"
   },
   "publishConfig": {
     "access": "public",

package/src/frontendTools.ts

@@ -1,37 +1,14 @@
 import { jsonSchema, type ToolSet } from "ai";
-import type { ToolJSONSchema, ToolModelContentPart } from "assistant-stream";
+import type { ToolJSONSchema } from "assistant-stream";
 import { unwrapModelContentEnvelope } from "./modelContentEnvelope";
-
-const toAISDKContent = (parts: readonly ToolModelContentPart[]) => ({
-  type: "content" as const,
-  value: parts.map((part) => {
-    if (part.type === "text") {
-      return { type: "text" as const, text: part.text };
-    }
-    const isImage = part.mediaType.startsWith("image/");
-    return isImage
-      ? {
-          type: "image-data" as const,
-          data: part.data,
-          mediaType: part.mediaType,
-        }
-      : {
-          type: "file-data" as const,
-          data: part.data,
-          mediaType: part.mediaType,
-          ...(part.filename !== undefined && { filename: part.filename }),
-        };
-  }),
-});
+import { toAISDKContent, toAISDKDefaultOutput } from "./toolOutputConversion";
 
 export const defaultToModelOutput = ({ output }: { output: unknown }) => {
-  const { modelContent } = unwrapModelContentEnvelope(output);
+  const { result, modelContent } = unwrapModelContentEnvelope(output);
   if (modelContent !== undefined) {
     return toAISDKContent(modelContent);
   }
-  return typeof output === "string"
-    ? { type: "text" as const, value: output }
-    : { type: "json" as const, value: (output ?? null) as any };
+  return toAISDKDefaultOutput(result);
 };
 
 export const frontendTools = (tools: Record<string, ToolJSONSchema>): ToolSet =>

package/src/generativeTools.test.ts

@@ -0,0 +1,407 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { AISDKToolkit, generativeTools } from "./generativeTools";
+import { wrapModelContentEnvelope } from "./modelContentEnvelope";
+
+const mocks = vi.hoisted(() => ({
+  close: vi.fn(),
+  tools: vi.fn(),
+  createMCPClient: vi.fn(),
+}));
+
+vi.mock("@ai-sdk/mcp", () => ({
+  createMCPClient: mocks.createMCPClient,
+}));
+
+vi.mock("@ai-sdk/mcp/mcp-stdio", () => ({
+  Experimental_StdioMCPTransport: vi.fn((config) => ({
+    type: "stdio",
+    config,
+  })),
+}));
+
+describe("generativeTools", () => {
+  beforeEach(() => {
+    mocks.close.mockReset();
+    mocks.tools.mockReset();
+    mocks.createMCPClient.mockReset();
+  });
+
+  it("merges frontend tools with toolkit tools", () => {
+    const toolSet = generativeTools({
+      frontendTools: {
+        clientTool: {
+          parameters: { type: "object", properties: {} },
+        },
+      },
+      toolkit: {
+        serverTool: {
+          type: "backend",
+          description: "Server tool",
+          parameters: { type: "object", properties: {} },
+          execute: async () => "ok",
+        } as never,
+      },
+    });
+
+    expect(toolSet.clientTool).toBeDefined();
+    expect(toolSet.serverTool?.description).toBe("Server tool");
+    expect(toolSet.serverTool?.execute).toBeTypeOf("function");
+  });
+
+  it("keeps a flat toolkit tool named tools", () => {
+    const toolSet = generativeTools({
+      toolkit: {
+        tools: {
+          type: "backend",
+          description: "Actually a tool, not config",
+          parameters: { type: "object", properties: {} },
+          execute: async () => "ok",
+        } as never,
+      },
+    });
+
+    expect(toolSet.tools?.description).toBe("Actually a tool, not config");
+    expect(toolSet.tools?.execute).toBeTypeOf("function");
+  });
+
+  it("rejects MCP entries because they require pooled clients", () => {
+    expect(() =>
+      generativeTools({
+        toolkit: {
+          docs: {
+            type: "mcp",
+            server: { type: "http", url: "http://localhost:3001/mcp" },
+          },
+        },
+      }),
+    ).toThrow(/requires AISDKToolkit/);
+  });
+
+  it("converts provider tools without an execute function", () => {
+    const toolSet = generativeTools({
+      toolkit: {
+        web_search: {
+          type: "provider",
+          providerId: "openai.web_search_preview",
+          args: { searchContextSize: "low" },
+        },
+      },
+    });
+
+    expect(toolSet.web_search).toMatchObject({
+      type: "provider",
+      id: "openai.web_search_preview",
+      args: { searchContextSize: "low" },
+    });
+    expect(toolSet.web_search).not.toHaveProperty("inputSchema");
+    expect(toolSet.web_search).not.toHaveProperty("execute");
+  });
+
+  it("forwards provider tool parameters and providerOptions when present", () => {
+    const toolSet = generativeTools({
+      toolkit: {
+        web_search: {
+          type: "provider",
+          providerId: "openai.web_search_preview",
+          args: { searchContextSize: "low" },
+          parameters: {
+            type: "object",
+            properties: {
+              query: { type: "string" },
+            },
+            required: ["query"],
+          },
+          providerOptions: {
+            openai: { rankingOptions: { scoreThreshold: 0.5 } },
+          },
+        },
+      },
+    });
+
+    expect(toolSet.web_search).toMatchObject({
+      type: "provider",
+      id: "openai.web_search_preview",
+      args: { searchContextSize: "low" },
+      providerOptions: {
+        openai: { rankingOptions: { scoreThreshold: 0.5 } },
+      },
+    });
+    expect(toolSet.web_search).toHaveProperty("inputSchema");
+  });
+
+  it("forwards explicit false supportsDeferredResults", () => {
+    const toolSet = generativeTools({
+      toolkit: {
+        web_search: {
+          type: "provider",
+          providerId: "openai.web_search_preview",
+          args: { searchContextSize: "low" },
+          supportsDeferredResults: false,
+        },
+      },
+    });
+
+    expect(toolSet.web_search).toMatchObject({
+      supportsDeferredResults: false,
+    });
+  });
+});
+
+describe("AISDKToolkit", () => {
+  beforeEach(() => {
+    mocks.close.mockReset();
+    mocks.tools.mockReset();
+    mocks.createMCPClient.mockReset();
+  });
+
+  it("loads MCP tools through pooled clients", async () => {
+    mocks.tools.mockResolvedValue({ echo: { inputSchema: {} } });
+    mocks.createMCPClient.mockResolvedValue({
+      tools: mocks.tools,
+      close: mocks.close,
+    });
+
+    const toolkit = new AISDKToolkit({
+      toolkit: {
+        local: {
+          type: "mcp",
+          server: { type: "http", url: "http://localhost:3001/mcp" },
+        },
+      },
+    });
+
+    await expect(toolkit.tools()).resolves.toHaveProperty("echo");
+    await toolkit.tools();
+
+    expect(mocks.createMCPClient).toHaveBeenCalledTimes(1);
+    expect(mocks.createMCPClient).toHaveBeenCalledWith({
+      transport: {
+        type: "http",
+        url: "http://localhost:3001/mcp",
+      },
+    });
+    expect(mocks.tools).toHaveBeenCalledTimes(2);
+  });
+
+  it("closes pooled MCP clients", async () => {
+    mocks.tools.mockResolvedValue({});
+    mocks.createMCPClient.mockResolvedValue({
+      tools: mocks.tools,
+      close: mocks.close,
+    });
+
+    const toolkit = new AISDKToolkit({
+      toolkit: {
+        local: {
+          type: "mcp",
+          server: { type: "sse", url: "http://localhost:3001/sse" },
+        },
+      },
+    });
+
+    await toolkit.tools();
+    await toolkit.close();
+
+    expect(mocks.close).toHaveBeenCalledTimes(1);
+  });
+
+  it("clears pooled MCP clients even when initialization fails", async () => {
+    const error = new Error("connect failed");
+    const closeError = new Error("close failed");
+    const close = vi.fn().mockRejectedValue(closeError);
+    mocks.tools.mockResolvedValue({});
+    mocks.createMCPClient
+      .mockResolvedValueOnce({
+        tools: mocks.tools,
+        close,
+      })
+      .mockRejectedValueOnce(error);
+
+    const toolkit = new AISDKToolkit({
+      toolkit: {
+        first: {
+          type: "mcp",
+          server: { type: "http", url: "http://localhost:3001/mcp" },
+        },
+        second: {
+          type: "mcp",
+          server: { type: "http", url: "http://localhost:3002/mcp" },
+        },
+      },
+    });
+
+    const toolsPromise = toolkit.tools();
+    await expect(toolkit.close()).rejects.toMatchObject({
+      errors: [error, closeError],
+    });
+    await expect(toolsPromise).rejects.toThrow(error);
+    expect(close).toHaveBeenCalledTimes(1);
+
+    await expect(toolkit.close()).resolves.toBeUndefined();
+  });
+
+  it("evicts failed MCP client initialization so later calls can retry", async () => {
+    const error = new Error("connect failed");
+    mocks.createMCPClient.mockRejectedValueOnce(error).mockResolvedValueOnce({
+      tools: vi.fn().mockResolvedValue({ echo: { inputSchema: {} } }),
+      close: mocks.close,
+    });
+
+    const toolkit = new AISDKToolkit({
+      toolkit: {
+        local: {
+          type: "mcp",
+          server: { type: "http", url: "http://localhost:3001/mcp" },
+        },
+      },
+    });
+
+    await expect(toolkit.tools()).rejects.toThrow(error);
+    await expect(toolkit.tools()).resolves.toHaveProperty("echo");
+    expect(mocks.createMCPClient).toHaveBeenCalledTimes(2);
+  });
+
+  it("rejects duplicate MCP tool names", async () => {
+    mocks.createMCPClient
+      .mockResolvedValueOnce({
+        tools: vi.fn().mockResolvedValue({ echo: { inputSchema: {} } }),
+        close: mocks.close,
+      })
+      .mockResolvedValueOnce({
+        tools: vi.fn().mockResolvedValue({ echo: { inputSchema: {} } }),
+        close: mocks.close,
+      });
+
+    const toolkit = new AISDKToolkit({
+      toolkit: {
+        first: {
+          type: "mcp",
+          server: { type: "http", url: "http://localhost:3001/mcp" },
+        },
+        second: {
+          type: "mcp",
+          server: { type: "http", url: "http://localhost:3002/mcp" },
+        },
+      },
+    });
+
+    await expect(toolkit.tools()).rejects.toThrow(
+      /MCP tool name collision: "echo"/,
+    );
+  });
+
+  it("includes provider tools alongside MCP tools", async () => {
+    mocks.tools.mockResolvedValue({ echo: { inputSchema: {} } });
+    mocks.createMCPClient.mockResolvedValue({
+      tools: mocks.tools,
+      close: mocks.close,
+    });
+
+    const toolkit = new AISDKToolkit({
+      toolkit: {
+        local: {
+          type: "mcp",
+          server: { type: "http", url: "http://localhost:3001/mcp" },
+        },
+        web_search: {
+          type: "provider",
+          providerId: "openai.web_search_preview",
+          args: { searchContextSize: "low" },
+          supportsDeferredResults: false,
+        },
+      },
+    });
+
+    await expect(toolkit.tools()).resolves.toMatchObject({
+      echo: { inputSchema: {} },
+      web_search: {
+        type: "provider",
+        id: "openai.web_search_preview",
+        args: { searchContextSize: "low" },
+        supportsDeferredResults: false,
+      },
+    });
+  });
+});
+
+describe("generativeTools toModelOutput", () => {
+  const createWeatherTools = (toModelOutput?: any) =>
+    generativeTools({
+      toolkit: {
+        get_weather: {
+          ...(toModelOutput && { toModelOutput }),
+        },
+      } as any,
+    });
+
+  it("adapts assistant-ui model content parts to the AI SDK tool output shape", async () => {
+    const tools = createWeatherTools(({ output }: any) => [
+      { type: "text", text: `Weather card displayed: ${output.location}` },
+    ]);
+
+    const output = await tools.get_weather!.toModelOutput!({
+      toolCallId: "tc-weather",
+      input: {},
+      output: { location: "San Francisco" },
+    });
+
+    expect(output).toEqual({
+      type: "content",
+      value: [{ type: "text", text: "Weather card displayed: San Francisco" }],
+    });
+  });
+
+  it("uses stored model content envelopes without re-running the custom projector", async () => {
+    let called = false;
+    const tools = createWeatherTools(() => {
+      called = true;
+      return [{ type: "text", text: "recomputed" }];
+    });
+
+    const output = await tools.get_weather!.toModelOutput!({
+      toolCallId: "tc-weather",
+      input: {},
+      output: wrapModelContentEnvelope({ location: "San Francisco" }, [
+        { type: "text", text: "cached weather receipt" },
+      ]),
+    });
+
+    expect(called).toBe(false);
+    expect(output).toEqual({
+      type: "content",
+      value: [{ type: "text", text: "cached weather receipt" }],
+    });
+  });
+
+  it("falls back to default model output when no custom projector is defined", async () => {
+    const tools = createWeatherTools();
+
+    const output = await tools.get_weather!.toModelOutput!({
+      toolCallId: "tc-weather",
+      input: {},
+      output: { location: "San Francisco" },
+    });
+
+    expect(output).toEqual({
+      type: "json",
+      value: { location: "San Francisco" },
+    });
+  });
+
+  it("uses stored model content envelopes when no custom projector is defined", async () => {
+    const tools = createWeatherTools();
+
+    const output = await tools.get_weather!.toModelOutput!({
+      toolCallId: "tc-weather",
+      input: {},
+      output: wrapModelContentEnvelope({ location: "San Francisco" }, [
+        { type: "text", text: "cached weather receipt" },
+      ]),
+    });
+
+    expect(output).toEqual({
+      type: "content",
+      value: [{ type: "text", text: "cached weather receipt" }],
+    });
+  });
+});