@assistant-ui/ai-sdk 0.0.10 → 0.0.12

package/dist/converters/toolOutputConversion.js

@@ -1,31 +0,0 @@
-//#region src/converters/toolOutputConversion.ts
-const toAISDKContent = (parts) => ({
-	type: "content",
-	value: parts.map((part) => {
-		if (part.type === "text") return {
-			type: "text",
-			text: part.text
-		};
-		const mediaType = typeof part.mediaType === "string" ? part.mediaType : "application/octet-stream";
-		return {
-			type: "file",
-			data: {
-				type: "data",
-				data: part.data
-			},
-			mediaType,
-			...part.filename !== void 0 && { filename: part.filename }
-		};
-	})
-});
-const toAISDKDefaultOutput = (output) => typeof output === "string" ? {
-	type: "text",
-	value: output
-} : {
-	type: "json",
-	value: output ?? null
-};
-//#endregion
-export { toAISDKContent, toAISDKDefaultOutput };
-
-//# sourceMappingURL=toolOutputConversion.js.map

package/dist/converters/toolOutputConversion.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"toolOutputConversion.js","names":["JSONValue","ToolModelContentPart","toAISDKContent","parts","type","const","value","map","part","text","mediaType","data","filename","undefined","toAISDKDefaultOutput","output"],"sources":["../../src/converters/toolOutputConversion.ts"],"sourcesContent":["import type { JSONValue } from \"ai\";\nimport type { ToolModelContentPart } from \"assistant-stream\";\n\nexport const toAISDKContent = (parts: readonly ToolModelContentPart[]) => ({\n  type: \"content\" as const,\n  value: parts.map((part) => {\n    if (part.type === \"text\") {\n      return { type: \"text\" as const, text: part.text };\n    }\n    const mediaType =\n      typeof part.mediaType === \"string\"\n        ? part.mediaType\n        : \"application/octet-stream\";\n    return {\n      type: \"file\" as const,\n      data: { type: \"data\" as const, data: part.data },\n      mediaType,\n      ...(part.filename !== undefined && { filename: part.filename }),\n    };\n  }),\n});\n\nexport const toAISDKDefaultOutput = (output: unknown) =>\n  typeof output === \"string\"\n    ? { type: \"text\" as const, value: output }\n    : { type: \"json\" as const, value: (output ?? null) as JSONValue };\n"],"mappings":";AAGA,MAAaE,kBAAkBC,WAA4C;CACzEC,MAAM;CACNE,OAAOH,MAAMI,KAAKC,SAAS;EACzB,IAAIA,KAAKJ,SAAS,QAChB,OAAO;GAAEA,MAAM;GAAiBK,MAAMD,KAAKC;EAAK;EAElD,MAAMC,YACJ,OAAOF,KAAKE,cAAc,WACtBF,KAAKE,YACL;EACN,OAAO;GACLN,MAAM;GACNO,MAAM;IAAEP,MAAM;IAAiBO,MAAMH,KAAKG;GAAK;GAC/CD;GACA,GAAIF,KAAKI,aAAaC,KAAAA,KAAa,EAAED,UAAUJ,KAAKI,SAAS;EAC/D;CACF,CAAC;AACH;AAEA,MAAaE,wBAAwBC,WACnC,OAAOA,WAAW,WACd;CAAEX,MAAM;CAAiBE,OAAOS;AAAO,IACvC;CAAEX,MAAM;CAAiBE,OAAQS,UAAU;AAAmB"}

package/dist/tools/frontendTools.d.ts

@@ -1,30 +0,0 @@
-import { type ToolSet } from "ai";
-import type { ToolJSONSchema } from "assistant-stream";
-/** Frontend tool definitions uploaded by AssistantChatTransport. */
-export type FrontendTools = Record<string, ToolJSONSchema>;
-export declare const defaultToModelOutput: ({ output }: {
-    output: unknown;
-}) => {
-    type: "content";
-    value: ({
-        type: "text";
-        text: string;
-    } | {
-        filename?: string;
-        type: "file";
-        data: {
-            type: "data";
-            data: string;
-        };
-        mediaType: string;
-        text?: never;
-    })[];
-} | {
-    type: "text";
-    value: string;
-} | {
-    type: "json";
-    value: import("ai").JSONValue;
-};
-export declare const frontendTools: (tools: FrontendTools) => ToolSet;
-//# sourceMappingURL=frontendTools.d.ts.map

package/dist/tools/frontendTools.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"frontendTools.d.ts","sourceRoot":"","sources":["../../src/tools/frontendTools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,OAAO,EAAE,MAAM,IAAI,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAOvD,oEAAoE;AACpE,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AAE3D,eAAO,MAAM,oBAAoB,GAAI,YAAY;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;CAMnE,CAAC;AAiDF,eAAO,MAAM,aAAa,GAAI,OAAO,aAAa,KAAG,OAgBpD,CAAC"}

package/dist/tools/frontendTools.js

@@ -1,33 +0,0 @@
-import { unwrapModelContentEnvelope } from "../converters/modelContentEnvelope.js";
-import { toAISDKContent, toAISDKDefaultOutput } from "../converters/toolOutputConversion.js";
-import { jsonSchema } from "ai";
-//#region src/tools/frontendTools.ts
-const defaultToModelOutput = ({ output }) => {
-	const { result, modelContent } = unwrapModelContentEnvelope(output);
-	if (modelContent !== void 0) return toAISDKContent(modelContent);
-	return toAISDKDefaultOutput(result);
-};
-const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-function validateFrontendTool(name, tool) {
-	if (!isPlainObject(tool)) throw new Error(`frontendTools() expected tool "${name}" to be an object with a JSON Schema parameters object.`);
-	if (!isPlainObject(tool.parameters)) throw new Error(`frontendTools() expected tool "${name}" to include a JSON Schema parameters object.`);
-	if (tool.description !== void 0 && typeof tool.description !== "string") throw new Error(`frontendTools() expected tool "${name}" description to be a string.`);
-	if (tool.providerOptions !== void 0 && !isPlainObject(tool.providerOptions)) throw new Error(`frontendTools() expected tool "${name}" providerOptions to be an object.`);
-}
-function validateFrontendTools(tools) {
-	if (!isPlainObject(tools)) throw new Error("frontendTools() expected tools to be an object keyed by tool name.");
-	for (const [name, tool] of Object.entries(tools)) validateFrontendTool(name, tool);
-}
-const frontendTools = (tools) => {
-	validateFrontendTools(tools);
-	return Object.fromEntries(Object.entries(tools).map(([name, tool]) => [name, {
-		...tool.description !== void 0 && { description: tool.description },
-		inputSchema: jsonSchema(tool.parameters),
-		toModelOutput: defaultToModelOutput,
-		...tool.providerOptions && { providerOptions: tool.providerOptions }
-	}]));
-};
-//#endregion
-export { defaultToModelOutput, frontendTools };
-
-//# sourceMappingURL=frontendTools.js.map

package/dist/tools/frontendTools.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"frontendTools.js","names":["jsonSchema","ToolSet","ToolJSONSchema","unwrapModelContentEnvelope","toAISDKContent","toAISDKDefaultOutput","FrontendTools","Record","defaultToModelOutput","output","result","modelContent","undefined","isPlainObject","value","Array","isArray","validateFrontendTool","name","tool","Error","parameters","description","providerOptions","validateFrontendTools","tools","Object","entries","frontendTools","fromEntries","map","inputSchema","toModelOutput"],"sources":["../../src/tools/frontendTools.ts"],"sourcesContent":["import { jsonSchema, type ToolSet } from \"ai\";\nimport type { ToolJSONSchema } from \"assistant-stream\";\nimport { unwrapModelContentEnvelope } from \"../converters/modelContentEnvelope\";\nimport {\n  toAISDKContent,\n  toAISDKDefaultOutput,\n} from \"../converters/toolOutputConversion\";\n\n/** Frontend tool definitions uploaded by AssistantChatTransport. */\nexport type FrontendTools = Record<string, ToolJSONSchema>;\n\nexport const defaultToModelOutput = ({ output }: { output: unknown }) => {\n  const { result, modelContent } = unwrapModelContentEnvelope(output);\n  if (modelContent !== undefined) {\n    return toAISDKContent(modelContent);\n  }\n  return toAISDKDefaultOutput(result);\n};\n\nconst isPlainObject = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value);\n\nfunction validateFrontendTool(\n  name: string,\n  tool: unknown,\n): asserts tool is ToolJSONSchema {\n  if (!isPlainObject(tool)) {\n    throw new Error(\n      `frontendTools() expected tool \"${name}\" to be an object with a JSON Schema parameters object.`,\n    );\n  }\n\n  if (!isPlainObject(tool.parameters)) {\n    throw new Error(\n      `frontendTools() expected tool \"${name}\" to include a JSON Schema parameters object.`,\n    );\n  }\n\n  if (tool.description !== undefined && typeof tool.description !== \"string\") {\n    throw new Error(\n      `frontendTools() expected tool \"${name}\" description to be a string.`,\n    );\n  }\n\n  if (\n    tool.providerOptions !== undefined &&\n    !isPlainObject(tool.providerOptions)\n  ) {\n    throw new Error(\n      `frontendTools() expected tool \"${name}\" providerOptions to be an object.`,\n    );\n  }\n}\n\nfunction validateFrontendTools(tools: unknown): asserts tools is FrontendTools {\n  if (!isPlainObject(tools)) {\n    throw new Error(\n      \"frontendTools() expected tools to be an object keyed by tool name.\",\n    );\n  }\n\n  for (const [name, tool] of Object.entries(tools)) {\n    validateFrontendTool(name, tool);\n  }\n}\n\nexport const frontendTools = (tools: FrontendTools): ToolSet => {\n  validateFrontendTools(tools);\n\n  return Object.fromEntries(\n    Object.entries(tools).map(([name, tool]) => [\n      name,\n      {\n        ...(tool.description !== undefined && {\n          description: tool.description,\n        }),\n        inputSchema: jsonSchema(tool.parameters),\n        toModelOutput: defaultToModelOutput,\n        ...(tool.providerOptions && { providerOptions: tool.providerOptions }),\n      },\n    ]),\n  ) as ToolSet;\n};\n"],"mappings":";;;;AAWA,MAAaQ,wBAAwB,EAAEC,aAAkC;CACvE,MAAM,EAAEC,QAAQC,iBAAiBR,2BAA2BM,MAAM;CAClE,IAAIE,iBAAiBC,KAAAA,GACnB,OAAOR,eAAeO,YAAY;CAEpC,OAAON,qBAAqBK,MAAM;AACpC;AAEA,MAAMG,iBAAiBC,UACrB,OAAOA,UAAU,YAAYA,UAAU,QAAQ,CAACC,MAAMC,QAAQF,KAAK;AAErE,SAASG,qBACPC,MACAC,MACgC;CAChC,IAAI,CAACN,cAAcM,IAAI,GACrB,MAAM,IAAIC,MACR,kCAAkCF,KAAI,wDACxC;CAGF,IAAI,CAACL,cAAcM,KAAKE,UAAU,GAChC,MAAM,IAAID,MACR,kCAAkCF,KAAI,8CACxC;CAGF,IAAIC,KAAKG,gBAAgBV,KAAAA,KAAa,OAAOO,KAAKG,gBAAgB,UAChE,MAAM,IAAIF,MACR,kCAAkCF,KAAI,8BACxC;CAGF,IACEC,KAAKI,oBAAoBX,KAAAA,KACzB,CAACC,cAAcM,KAAKI,eAAe,GAEnC,MAAM,IAAIH,MACR,kCAAkCF,KAAI,mCACxC;AAEJ;AAEA,SAASM,sBAAsBC,OAAgD;CAC7E,IAAI,CAACZ,cAAcY,KAAK,GACtB,MAAM,IAAIL,MACR,oEACF;CAGF,KAAK,MAAM,CAACF,MAAMC,SAASO,OAAOC,QAAQF,KAAK,GAC7CR,qBAAqBC,MAAMC,IAAI;AAEnC;AAEA,MAAaS,iBAAiBH,UAAkC;CAC9DD,sBAAsBC,KAAK;CAE3B,OAAOC,OAAOG,YACZH,OAAOC,QAAQF,KAAK,CAAC,CAACK,KAAK,CAACZ,MAAMC,UAAU,CAC1CD,MACA;EACE,GAAIC,KAAKG,gBAAgBV,KAAAA,KAAa,EACpCU,aAAaH,KAAKG,YACpB;EACAS,aAAa/B,WAAWmB,KAAKE,UAAU;EACvCW,eAAexB;EACf,GAAIW,KAAKI,mBAAmB,EAAEA,iBAAiBJ,KAAKI,gBAAgB;CACtE,CAAC,CACF,CACH;AACF"}

package/src/converters/modelContentEnvelope.ts

@@ -1,41 +0,0 @@
-import type { ToolModelContentPart } from "assistant-stream";
-
-const ENVELOPE_KEY = "__aui_modelContent";
-
-export type ModelContentEnvelope<TResult = unknown> = {
-  readonly [ENVELOPE_KEY]: readonly ToolModelContentPart[];
-  readonly value: TResult;
-};
-
-export function isModelContentEnvelope<TResult = unknown>(
-  value: TResult | ModelContentEnvelope<TResult>,
-): value is ModelContentEnvelope<TResult> {
-  return (
-    value != null &&
-    typeof value === "object" &&
-    ENVELOPE_KEY in value &&
-    Array.isArray((value as Record<string, unknown>)[ENVELOPE_KEY])
-  );
-}
-
-export function wrapModelContentEnvelope<TResult>(
-  result: TResult,
-  modelContent: readonly ToolModelContentPart[],
-): ModelContentEnvelope<TResult> {
-  return { [ENVELOPE_KEY]: modelContent, value: result };
-}
-
-export function unwrapModelContentEnvelope<TResult>(
-  output: TResult | ModelContentEnvelope<TResult>,
-): {
-  result: TResult;
-  modelContent?: readonly ToolModelContentPart[];
-} {
-  if (isModelContentEnvelope(output)) {
-    return {
-      result: output.value,
-      modelContent: output[ENVELOPE_KEY],
-    };
-  }
-  return { result: output };
-}

package/src/converters/toolOutputConversion.ts

@@ -1,26 +0,0 @@
-import type { JSONValue } from "ai";
-import type { ToolModelContentPart } from "assistant-stream";
-
-export 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 mediaType =
-      typeof part.mediaType === "string"
-        ? part.mediaType
-        : "application/octet-stream";
-    return {
-      type: "file" as const,
-      data: { type: "data" as const, data: part.data },
-      mediaType,
-      ...(part.filename !== undefined && { filename: part.filename }),
-    };
-  }),
-});
-
-export const toAISDKDefaultOutput = (output: unknown) =>
-  typeof output === "string"
-    ? { type: "text" as const, value: output }
-    : { type: "json" as const, value: (output ?? null) as JSONValue };

package/src/tools/frontendTools.test.ts

@@ -1,205 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { frontendTools } from "./frontendTools";
-import { wrapModelContentEnvelope } from "../converters/modelContentEnvelope";
-
-describe("frontendTools", () => {
-  it("forwards description and inputSchema for each tool", () => {
-    const tools = frontendTools({
-      getWeather: {
-        description: "Get the weather",
-        parameters: {
-          type: "object",
-          properties: { city: { type: "string" } },
-        },
-      },
-    });
-
-    expect(tools.getWeather?.description).toBe("Get the weather");
-    expect(tools.getWeather?.inputSchema).toBeDefined();
-  });
-
-  it("registers a toModelOutput that unwraps the modelContent envelope", async () => {
-    const tools = frontendTools({
-      readPdf: {
-        parameters: { type: "object" },
-      },
-    });
-
-    const envelope = wrapModelContentEnvelope(
-      { mediaType: "application/pdf", base64: "JVBERi0xLjQK" },
-      [
-        { type: "text", text: "PDF contents:" },
-        {
-          type: "file",
-          data: "JVBERi0xLjQK",
-          mediaType: "application/pdf",
-          filename: "doc.pdf",
-        },
-      ],
-    );
-
-    const output = await tools.readPdf!.toModelOutput!({
-      toolCallId: "tc-1",
-      input: {},
-      output: envelope,
-    });
-
-    expect(output).toEqual({
-      type: "content",
-      value: [
-        { type: "text", text: "PDF contents:" },
-        {
-          type: "file",
-          mediaType: "application/pdf",
-          data: { type: "data", data: "JVBERi0xLjQK" },
-          filename: "doc.pdf",
-        },
-      ],
-    });
-  });
-
-  it("emits a file part for image media types", async () => {
-    const tools = frontendTools({
-      screenshot: {
-        parameters: { type: "object" },
-      },
-    });
-
-    const envelope = wrapModelContentEnvelope(
-      { mediaType: "image/png", base64: "iVBORw0KGgo=" },
-      [
-        {
-          type: "file",
-          data: "iVBORw0KGgo=",
-          mediaType: "image/png",
-        },
-      ],
-    );
-
-    const output = await tools.screenshot!.toModelOutput!({
-      toolCallId: "tc-1",
-      input: {},
-      output: envelope,
-    });
-
-    expect(output).toEqual({
-      type: "content",
-      value: [
-        {
-          type: "file",
-          data: { type: "data", data: "iVBORw0KGgo=" },
-          mediaType: "image/png",
-        },
-      ],
-    });
-  });
-
-  it("falls back to a JSON output for plain (non-envelope) results", async () => {
-    const tools = frontendTools({
-      getWeather: {
-        parameters: { type: "object" },
-      },
-    });
-
-    const output = await tools.getWeather!.toModelOutput!({
-      toolCallId: "tc-1",
-      input: {},
-      output: { temp: 72 },
-    });
-
-    expect(output).toEqual({ type: "json", value: { temp: 72 } });
-  });
-
-  it("falls back to a text output for plain string results", async () => {
-    const tools = frontendTools({
-      echo: {
-        parameters: { type: "object" },
-      },
-    });
-
-    const output = await tools.echo!.toModelOutput!({
-      toolCallId: "tc-1",
-      input: {},
-      output: "hello",
-    });
-
-    expect(output).toEqual({ type: "text", value: "hello" });
-  });
-
-  it("forwards providerOptions verbatim when present", () => {
-    const tools = frontendTools({
-      getWeather: {
-        description: "Get the weather",
-        parameters: { type: "object", properties: {} },
-        providerOptions: { anthropic: { deferLoading: true } },
-      },
-    });
-
-    expect(tools.getWeather?.providerOptions).toEqual({
-      anthropic: { deferLoading: true },
-    });
-  });
-
-  it("omits providerOptions when absent", () => {
-    const tools = frontendTools({
-      getWeather: {
-        parameters: { type: "object", properties: {} },
-      },
-    });
-
-    expect(tools.getWeather).not.toHaveProperty("providerOptions");
-  });
-
-  it("names the malformed frontend tool when parameters are missing", () => {
-    expect(() =>
-      frontendTools({
-        getWeather: {
-          description: "Get the weather",
-        },
-      } as never),
-    ).toThrow(
-      'frontendTools() expected tool "getWeather" to include a JSON Schema parameters object.',
-    );
-  });
-
-  it("rejects non-object tools request bodies", () => {
-    expect(() => frontendTools(null as never)).toThrow(
-      "frontendTools() expected tools to be an object keyed by tool name.",
-    );
-    expect(() => frontendTools([] as never)).toThrow(
-      "frontendTools() expected tools to be an object keyed by tool name.",
-    );
-  });
-
-  it("names frontend tool entries with malformed field types", () => {
-    expect(() =>
-      frontendTools({
-        getWeather: null,
-      } as never),
-    ).toThrow(
-      'frontendTools() expected tool "getWeather" to be an object with a JSON Schema parameters object.',
-    );
-
-    expect(() =>
-      frontendTools({
-        getWeather: {
-          description: 123,
-          parameters: { type: "object" },
-        },
-      } as never),
-    ).toThrow(
-      'frontendTools() expected tool "getWeather" description to be a string.',
-    );
-
-    expect(() =>
-      frontendTools({
-        getWeather: {
-          parameters: { type: "object" },
-          providerOptions: "anthropic",
-        },
-      } as never),
-    ).toThrow(
-      'frontendTools() expected tool "getWeather" providerOptions to be an object.',
-    );
-  });
-});

package/src/tools/frontendTools.ts

@@ -1,83 +0,0 @@
-import { jsonSchema, type ToolSet } from "ai";
-import type { ToolJSONSchema } from "assistant-stream";
-import { unwrapModelContentEnvelope } from "../converters/modelContentEnvelope";
-import {
-  toAISDKContent,
-  toAISDKDefaultOutput,
-} from "../converters/toolOutputConversion";
-
-/** Frontend tool definitions uploaded by AssistantChatTransport. */
-export type FrontendTools = Record<string, ToolJSONSchema>;
-
-export const defaultToModelOutput = ({ output }: { output: unknown }) => {
-  const { result, modelContent } = unwrapModelContentEnvelope(output);
-  if (modelContent !== undefined) {
-    return toAISDKContent(modelContent);
-  }
-  return toAISDKDefaultOutput(result);
-};
-
-const isPlainObject = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null && !Array.isArray(value);
-
-function validateFrontendTool(
-  name: string,
-  tool: unknown,
-): asserts tool is ToolJSONSchema {
-  if (!isPlainObject(tool)) {
-    throw new Error(
-      `frontendTools() expected tool "${name}" to be an object with a JSON Schema parameters object.`,
-    );
-  }
-
-  if (!isPlainObject(tool.parameters)) {
-    throw new Error(
-      `frontendTools() expected tool "${name}" to include a JSON Schema parameters object.`,
-    );
-  }
-
-  if (tool.description !== undefined && typeof tool.description !== "string") {
-    throw new Error(
-      `frontendTools() expected tool "${name}" description to be a string.`,
-    );
-  }
-
-  if (
-    tool.providerOptions !== undefined &&
-    !isPlainObject(tool.providerOptions)
-  ) {
-    throw new Error(
-      `frontendTools() expected tool "${name}" providerOptions to be an object.`,
-    );
-  }
-}
-
-function validateFrontendTools(tools: unknown): asserts tools is FrontendTools {
-  if (!isPlainObject(tools)) {
-    throw new Error(
-      "frontendTools() expected tools to be an object keyed by tool name.",
-    );
-  }
-
-  for (const [name, tool] of Object.entries(tools)) {
-    validateFrontendTool(name, tool);
-  }
-}
-
-export const frontendTools = (tools: FrontendTools): ToolSet => {
-  validateFrontendTools(tools);
-
-  return Object.fromEntries(
-    Object.entries(tools).map(([name, tool]) => [
-      name,
-      {
-        ...(tool.description !== undefined && {
-          description: tool.description,
-        }),
-        inputSchema: jsonSchema(tool.parameters),
-        toModelOutput: defaultToModelOutput,
-        ...(tool.providerOptions && { providerOptions: tool.providerOptions }),
-      },
-    ]),
-  ) as ToolSet;
-};