ai 6.0.32 → 6.0.34

package/src/prompt/create-tool-model-output.test.ts

@@ -0,0 +1,508 @@
+import { tool, Tool } from '@ai-sdk/provider-utils';
+import { createToolModelOutput } from './create-tool-model-output';
+import z from 'zod/v4';
+import { describe, it, expect } from 'vitest';
+
+describe('createToolModelOutput', () => {
+  describe('error cases', () => {
+    it('should return error type with string value when isError is true and output is string', async () => {
+      const result = await createToolModelOutput({
+        toolCallId: '123',
+        input: {},
+        output: 'Error message',
+        tool: undefined,
+        errorMode: 'text',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "error-text",
+          "value": "Error message",
+        }
+      `);
+    });
+
+    it('should return error type with JSON stringified value when isError is true and output is not string', async () => {
+      const errorOutput = { error: 'Something went wrong', code: 500 };
+      const result = await createToolModelOutput({
+        toolCallId: '123',
+        input: {},
+        output: errorOutput,
+        tool: undefined,
+        errorMode: 'text',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "error-text",
+          "value": "{"error":"Something went wrong","code":500}",
+        }
+      `);
+    });
+
+    it('should return error type with JSON stringified value for complex objects', async () => {
+      const complexError = {
+        message: 'Complex error',
+        details: {
+          timestamp: '2023-01-01T00:00:00Z',
+          stack: ['line1', 'line2'],
+        },
+      };
+      const result = await createToolModelOutput({
+        toolCallId: '123',
+        input: {},
+        output: complexError,
+        tool: undefined,
+        errorMode: 'text',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "error-text",
+          "value": "{"message":"Complex error","details":{"timestamp":"2023-01-01T00:00:00Z","stack":["line1","line2"]}}",
+        }
+      `);
+    });
+  });
+
+  describe('tool with toModelOutput', () => {
+    it('should use tool.toModelOutput when available', async () => {
+      const mockTool = tool({
+        inputSchema: z.object({}),
+        toModelOutput: ({ output }) => ({
+          type: 'text',
+          value: `Custom output: ${output}`,
+        }),
+      });
+
+      const result = await createToolModelOutput({
+        toolCallId: '123',
+        input: {},
+        output: 'test output',
+        tool: mockTool,
+        errorMode: 'none',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "text",
+          "value": "Custom output: test output",
+        }
+      `);
+    });
+
+    it('should use tool.toModelOutput with complex output', async () => {
+      const mockTool = tool({
+        inputSchema: z.object({}),
+        toModelOutput: ({ output }) => ({
+          type: 'json',
+          value: { processed: output, timestamp: '2023-01-01' },
+        }),
+      });
+
+      const result = await createToolModelOutput({
+        toolCallId: '123',
+        input: {},
+        output: { data: [1, 2, 3], status: 'success' },
+        tool: mockTool,
+        errorMode: 'none',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "json",
+          "value": {
+            "processed": {
+              "data": [
+                1,
+                2,
+                3,
+              ],
+              "status": "success",
+            },
+            "timestamp": "2023-01-01",
+          },
+        }
+      `);
+    });
+
+    it('should use tool.toModelOutput returning content type', async () => {
+      const mockTool: Tool = {
+        toModelOutput: () => ({
+          type: 'content',
+          value: [
+            { type: 'text', text: 'Here is the result:' },
+            { type: 'text', text: 'Additional information' },
+          ],
+        }),
+        inputSchema: z.object({}),
+      };
+
+      const result = await createToolModelOutput({
+        toolCallId: '123',
+        input: {},
+        output: 'any output',
+        tool: mockTool,
+        errorMode: 'none',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "content",
+          "value": [
+            {
+              "text": "Here is the result:",
+              "type": "text",
+            },
+            {
+              "text": "Additional information",
+              "type": "text",
+            },
+          ],
+        }
+      `);
+    });
+  });
+
+  describe('string output without toModelOutput', () => {
+    it('should return text type for string output', async () => {
+      const result = await createToolModelOutput({
+        toolCallId: '123',
+        input: {},
+        output: 'Simple string output',
+        tool: undefined,
+        errorMode: 'none',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "text",
+          "value": "Simple string output",
+        }
+      `);
+    });
+
+    it('should return text type for string output even with tool that has no toModelOutput', async () => {
+      const result = await createToolModelOutput({
+        toolCallId: '123',
+        input: {},
+        output: 'String output',
+        tool: {
+          description: 'A tool without toModelOutput',
+          inputSchema: z.object({}),
+        },
+        errorMode: 'none',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "text",
+          "value": "String output",
+        }
+      `);
+    });
+
+    it('should return text type for empty string', async () => {
+      const result = await createToolModelOutput({
+        toolCallId: '123',
+        input: {},
+        output: '',
+        tool: undefined,
+        errorMode: 'none',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "text",
+          "value": "",
+        }
+      `);
+    });
+  });
+
+  describe('non-string output without toModelOutput', () => {
+    it('should return json type for object output', async () => {
+      const result = await createToolModelOutput({
+        toolCallId: '123',
+        input: {},
+        output: { result: 'success', data: [1, 2, 3] },
+        tool: undefined,
+        errorMode: 'none',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "json",
+          "value": {
+            "data": [
+              1,
+              2,
+              3,
+            ],
+            "result": "success",
+          },
+        }
+      `);
+    });
+
+    it('should return json type for array output', async () => {
+      const result = await createToolModelOutput({
+        toolCallId: '123',
+        input: {},
+        output: [1, 2, 3, 'test'],
+        tool: undefined,
+        errorMode: 'none',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "json",
+          "value": [
+            1,
+            2,
+            3,
+            "test",
+          ],
+        }
+      `);
+    });
+
+    it('should return json type for number output', async () => {
+      const result = await createToolModelOutput({
+        toolCallId: '123',
+        input: {},
+        output: 42,
+        tool: undefined,
+        errorMode: 'none',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "json",
+          "value": 42,
+        }
+      `);
+    });
+
+    it('should return json type for boolean output', async () => {
+      const result = await createToolModelOutput({
+        toolCallId: '123',
+        input: {},
+        output: true,
+        tool: undefined,
+        errorMode: 'none',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "json",
+          "value": true,
+        }
+      `);
+    });
+
+    it('should return json type for null output', async () => {
+      const result = await createToolModelOutput({
+        toolCallId: '123',
+        input: {},
+        output: null,
+        tool: undefined,
+        errorMode: 'none',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "json",
+          "value": null,
+        }
+      `);
+    });
+
+    it('should return json type for complex nested object', async () => {
+      const result = await createToolModelOutput({
+        toolCallId: '123',
+        input: {},
+        output: {
+          user: {
+            id: 123,
+            name: 'John Doe',
+            preferences: {
+              theme: 'dark',
+              notifications: true,
+            },
+          },
+          metadata: {
+            timestamp: '2023-01-01T00:00:00Z',
+            version: '1.0.0',
+          },
+          items: [
+            { id: 1, name: 'Item 1' },
+            { id: 2, name: 'Item 2' },
+          ],
+        },
+        tool: undefined,
+        errorMode: 'none',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "json",
+          "value": {
+            "items": [
+              {
+                "id": 1,
+                "name": "Item 1",
+              },
+              {
+                "id": 2,
+                "name": "Item 2",
+              },
+            ],
+            "metadata": {
+              "timestamp": "2023-01-01T00:00:00Z",
+              "version": "1.0.0",
+            },
+            "user": {
+              "id": 123,
+              "name": "John Doe",
+              "preferences": {
+                "notifications": true,
+                "theme": "dark",
+              },
+            },
+          },
+        }
+      `);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should prioritize isError over tool.toModelOutput', async () => {
+      const mockTool: Tool = {
+        inputSchema: z.object({}),
+        toModelOutput: () => ({
+          type: 'text',
+          value: 'This should not be called',
+        }),
+      };
+
+      const result = await createToolModelOutput({
+        toolCallId: '123',
+        input: {},
+        output: 'Error occurred',
+        tool: mockTool,
+        errorMode: 'text',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "error-text",
+          "value": "Error occurred",
+        }
+      `);
+    });
+
+    it('should handle undefined output in error text case', async () => {
+      const result = await createToolModelOutput({
+        toolCallId: '123',
+        input: {},
+        output: undefined,
+        tool: undefined,
+        errorMode: 'text',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "error-text",
+          "value": "unknown error",
+        }
+      `);
+    });
+
+    it('should use null for undefined output in error json case', async () => {
+      const result = await createToolModelOutput({
+        toolCallId: '123',
+        input: {},
+        output: undefined,
+        tool: undefined,
+        errorMode: 'json',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "error-json",
+          "value": null,
+        }
+      `);
+    });
+
+    it('should use null for undefined output in non-error case', async () => {
+      const result = await createToolModelOutput({
+        toolCallId: '123',
+        input: {},
+        output: undefined,
+        tool: undefined,
+        errorMode: 'none',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "json",
+          "value": null,
+        }
+      `);
+    });
+  });
+
+  describe('arguments', () => {
+    it('should pass toolCallId to tool.toModelOutput', async () => {
+      const mockTool: Tool = {
+        inputSchema: z.object({}),
+        toModelOutput: ({ toolCallId }) => ({
+          type: 'text',
+          value: `Tool call ID: ${toolCallId}`,
+        }),
+      };
+
+      const result = await createToolModelOutput({
+        toolCallId: '2344',
+        input: {},
+        output: 'test',
+        tool: mockTool,
+        errorMode: 'none',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "text",
+          "value": "Tool call ID: 2344",
+        }
+      `);
+    });
+
+    it('should pass input to tool.toModelOutput', async () => {
+      const mockTool: Tool = {
+        inputSchema: z.object({ number: z.number() }),
+        toModelOutput: ({ input }) => ({
+          type: 'text',
+          value: `Input: ${input.number}`,
+        }),
+      };
+
+      const result = await createToolModelOutput({
+        toolCallId: '2344',
+        input: { number: 8877 },
+        output: 'test',
+        tool: mockTool,
+        errorMode: 'none',
+      });
+
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "type": "text",
+          "value": "Input: 8877",
+        }
+      `);
+    });
+  });
+});

package/src/prompt/create-tool-model-output.ts

@@ -0,0 +1,34 @@
+import { getErrorMessage, JSONValue } from '@ai-sdk/provider';
+import { Tool, ToolResultOutput } from '@ai-sdk/provider-utils';
+
+export async function createToolModelOutput({
+  toolCallId,
+  input,
+  output,
+  tool,
+  errorMode,
+}: {
+  toolCallId: string;
+  input: unknown;
+  output: unknown;
+  tool: Tool | undefined;
+  errorMode: 'none' | 'text' | 'json';
+}): Promise<ToolResultOutput> {
+  if (errorMode === 'text') {
+    return { type: 'error-text', value: getErrorMessage(output) };
+  } else if (errorMode === 'json') {
+    return { type: 'error-json', value: toJSONValue(output) };
+  }
+
+  if (tool?.toModelOutput) {
+    return await tool.toModelOutput({ toolCallId, input, output });
+  }
+
+  return typeof output === 'string'
+    ? { type: 'text', value: output }
+    : { type: 'json', value: toJSONValue(output) };
+}
+
+function toJSONValue(value: unknown): JSONValue {
+  return value === undefined ? null : (value as JSONValue);
+}

package/src/prompt/data-content.test.ts

@@ -0,0 +1,15 @@
+import { dataContentSchema } from './data-content';
+import { describe, it, expect } from 'vitest';
+
+describe('dataContentSchema', () => {
+  it('should validate a Buffer', () => {
+    const buffer = Buffer.from('Hello, world!');
+    const result = dataContentSchema.parse(buffer);
+    expect(result).toEqual(buffer);
+  });
+
+  it('should reject a non-matching object', () => {
+    const nonMatchingObject = { foo: 'bar' };
+    expect(() => dataContentSchema.parse(nonMatchingObject)).toThrow();
+  });
+});

package/src/prompt/data-content.ts

@@ -0,0 +1,134 @@
+import { AISDKError, LanguageModelV3DataContent } from '@ai-sdk/provider';
+import {
+  convertBase64ToUint8Array,
+  convertUint8ArrayToBase64,
+  DataContent,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { InvalidDataContentError } from './invalid-data-content-error';
+import { splitDataUrl } from './split-data-url';
+
+/**
+@internal
+ */
+export const dataContentSchema: z.ZodType<DataContent> = z.union([
+  z.string(),
+  z.instanceof(Uint8Array),
+  z.instanceof(ArrayBuffer),
+  z.custom<Buffer>(
+    // Buffer might not be available in some environments such as CloudFlare:
+    (value: unknown): value is Buffer =>
+      globalThis.Buffer?.isBuffer(value) ?? false,
+    { message: 'Must be a Buffer' },
+  ),
+]);
+
+export function convertToLanguageModelV3DataContent(
+  content: DataContent | URL,
+): {
+  data: LanguageModelV3DataContent;
+  mediaType: string | undefined;
+} {
+  // Buffer & Uint8Array:
+  if (content instanceof Uint8Array) {
+    return { data: content, mediaType: undefined };
+  }
+
+  // ArrayBuffer needs conversion to Uint8Array (lightweight):
+  if (content instanceof ArrayBuffer) {
+    return { data: new Uint8Array(content), mediaType: undefined };
+  }
+
+  // Attempt to create a URL from the data. If it fails, we can assume the data
+  // is not a URL and likely some other sort of data.
+  if (typeof content === 'string') {
+    try {
+      content = new URL(content);
+    } catch (error) {
+      // ignored
+    }
+  }
+
+  // Extract data from data URL:
+  if (content instanceof URL && content.protocol === 'data:') {
+    const { mediaType: dataUrlMediaType, base64Content } = splitDataUrl(
+      content.toString(),
+    );
+
+    if (dataUrlMediaType == null || base64Content == null) {
+      throw new AISDKError({
+        name: 'InvalidDataContentError',
+        message: `Invalid data URL format in content ${content.toString()}`,
+      });
+    }
+
+    return { data: base64Content, mediaType: dataUrlMediaType };
+  }
+
+  return { data: content, mediaType: undefined };
+}
+
+/**
+Converts data content to a base64-encoded string.
+
+@param content - Data content to convert.
+@returns Base64-encoded string.
+*/
+export function convertDataContentToBase64String(content: DataContent): string {
+  if (typeof content === 'string') {
+    return content;
+  }
+
+  if (content instanceof ArrayBuffer) {
+    return convertUint8ArrayToBase64(new Uint8Array(content));
+  }
+
+  return convertUint8ArrayToBase64(content);
+}
+
+/**
+Converts data content to a Uint8Array.
+
+@param content - Data content to convert.
+@returns Uint8Array.
+ */
+export function convertDataContentToUint8Array(
+  content: DataContent,
+): Uint8Array {
+  if (content instanceof Uint8Array) {
+    return content;
+  }
+
+  if (typeof content === 'string') {
+    try {
+      return convertBase64ToUint8Array(content);
+    } catch (error) {
+      throw new InvalidDataContentError({
+        message:
+          'Invalid data content. Content string is not a base64-encoded media.',
+        content,
+        cause: error,
+      });
+    }
+  }
+
+  if (content instanceof ArrayBuffer) {
+    return new Uint8Array(content);
+  }
+
+  throw new InvalidDataContentError({ content });
+}
+
+/**
+ * Converts a Uint8Array to a string of text.
+ *
+ * @param uint8Array - The Uint8Array to convert.
+ * @returns The converted string.
+ */
+export function convertUint8ArrayToText(uint8Array: Uint8Array): string {
+  try {
+    return new TextDecoder().decode(uint8Array);
+  } catch (error) {
+    throw new Error('Error decoding Uint8Array to text');
+  }
+}

package/src/prompt/index.ts

@@ -0,0 +1,27 @@
+export type { CallSettings, TimeoutConfiguration } from './call-settings';
+export {
+  assistantModelMessageSchema,
+  modelMessageSchema,
+  systemModelMessageSchema,
+  toolModelMessageSchema,
+  userModelMessageSchema,
+} from './message';
+export type { Prompt } from './prompt';
+
+// re-export types from provider-utils
+export type {
+  AssistantContent,
+  AssistantModelMessage,
+  DataContent,
+  FilePart,
+  ImagePart,
+  ModelMessage,
+  SystemModelMessage,
+  TextPart,
+  ToolCallPart,
+  ToolContent,
+  ToolModelMessage,
+  ToolResultPart,
+  UserContent,
+  UserModelMessage,
+} from '@ai-sdk/provider-utils';