ai 6.0.33 → 6.0.35

package/src/prompt/prepare-tools-and-tool-choice.test.ts

@@ -0,0 +1,461 @@
+import { z } from 'zod/v4';
+import { prepareToolsAndToolChoice } from './prepare-tools-and-tool-choice';
+import { Tool, tool } from '@ai-sdk/provider-utils';
+import { describe, it, expect } from 'vitest';
+
+const mockTools = {
+  tool1: tool({
+    description: 'Tool 1 description',
+    inputSchema: z.object({}),
+  }),
+  tool2: tool({
+    description: 'Tool 2 description',
+    inputSchema: z.object({ city: z.string() }),
+  }),
+};
+
+const mockProviderTool: Tool = {
+  type: 'provider',
+  id: 'provider.tool-id',
+  args: { key: 'value' },
+  inputSchema: z.object({}),
+};
+
+const mockToolsWithProviderDefined = {
+  ...mockTools,
+  providerTool: mockProviderTool,
+};
+
+describe('prepareToolsAndToolChoice', () => {
+  it('should return undefined for both tools and toolChoice when tools is not provided', async () => {
+    const result = await prepareToolsAndToolChoice({
+      tools: undefined,
+      toolChoice: undefined,
+      activeTools: undefined,
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "toolChoice": undefined,
+        "tools": undefined,
+      }
+    `);
+  });
+
+  it('should return all tools when activeTools is not provided', async () => {
+    const result = await prepareToolsAndToolChoice({
+      tools: mockTools,
+      toolChoice: undefined,
+      activeTools: undefined,
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "toolChoice": {
+          "type": "auto",
+        },
+        "tools": [
+          {
+            "description": "Tool 1 description",
+            "inputSchema": {
+              "$schema": "http://json-schema.org/draft-07/schema#",
+              "additionalProperties": false,
+              "properties": {},
+              "type": "object",
+            },
+            "name": "tool1",
+            "providerOptions": undefined,
+            "type": "function",
+          },
+          {
+            "description": "Tool 2 description",
+            "inputSchema": {
+              "$schema": "http://json-schema.org/draft-07/schema#",
+              "additionalProperties": false,
+              "properties": {
+                "city": {
+                  "type": "string",
+                },
+              },
+              "required": [
+                "city",
+              ],
+              "type": "object",
+            },
+            "name": "tool2",
+            "providerOptions": undefined,
+            "type": "function",
+          },
+        ],
+      }
+    `);
+  });
+
+  it('should filter tools based on activeTools', async () => {
+    const result = await prepareToolsAndToolChoice({
+      tools: mockTools,
+      toolChoice: undefined,
+      activeTools: ['tool1'],
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "toolChoice": {
+          "type": "auto",
+        },
+        "tools": [
+          {
+            "description": "Tool 1 description",
+            "inputSchema": {
+              "$schema": "http://json-schema.org/draft-07/schema#",
+              "additionalProperties": false,
+              "properties": {},
+              "type": "object",
+            },
+            "name": "tool1",
+            "providerOptions": undefined,
+            "type": "function",
+          },
+        ],
+      }
+    `);
+  });
+
+  it('should handle string toolChoice', async () => {
+    const result = await prepareToolsAndToolChoice({
+      tools: mockTools,
+      toolChoice: 'none',
+      activeTools: undefined,
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "toolChoice": {
+          "type": "none",
+        },
+        "tools": [
+          {
+            "description": "Tool 1 description",
+            "inputSchema": {
+              "$schema": "http://json-schema.org/draft-07/schema#",
+              "additionalProperties": false,
+              "properties": {},
+              "type": "object",
+            },
+            "name": "tool1",
+            "providerOptions": undefined,
+            "type": "function",
+          },
+          {
+            "description": "Tool 2 description",
+            "inputSchema": {
+              "$schema": "http://json-schema.org/draft-07/schema#",
+              "additionalProperties": false,
+              "properties": {
+                "city": {
+                  "type": "string",
+                },
+              },
+              "required": [
+                "city",
+              ],
+              "type": "object",
+            },
+            "name": "tool2",
+            "providerOptions": undefined,
+            "type": "function",
+          },
+        ],
+      }
+    `);
+  });
+
+  it('should handle object toolChoice', async () => {
+    const result = await prepareToolsAndToolChoice({
+      tools: mockTools,
+      toolChoice: { type: 'tool', toolName: 'tool2' },
+      activeTools: undefined,
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "toolChoice": {
+          "toolName": "tool2",
+          "type": "tool",
+        },
+        "tools": [
+          {
+            "description": "Tool 1 description",
+            "inputSchema": {
+              "$schema": "http://json-schema.org/draft-07/schema#",
+              "additionalProperties": false,
+              "properties": {},
+              "type": "object",
+            },
+            "name": "tool1",
+            "providerOptions": undefined,
+            "type": "function",
+          },
+          {
+            "description": "Tool 2 description",
+            "inputSchema": {
+              "$schema": "http://json-schema.org/draft-07/schema#",
+              "additionalProperties": false,
+              "properties": {
+                "city": {
+                  "type": "string",
+                },
+              },
+              "required": [
+                "city",
+              ],
+              "type": "object",
+            },
+            "name": "tool2",
+            "providerOptions": undefined,
+            "type": "function",
+          },
+        ],
+      }
+    `);
+  });
+
+  it('should correctly map tool properties', async () => {
+    const result = await prepareToolsAndToolChoice({
+      tools: mockTools,
+      toolChoice: undefined,
+      activeTools: undefined,
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "toolChoice": {
+          "type": "auto",
+        },
+        "tools": [
+          {
+            "description": "Tool 1 description",
+            "inputSchema": {
+              "$schema": "http://json-schema.org/draft-07/schema#",
+              "additionalProperties": false,
+              "properties": {},
+              "type": "object",
+            },
+            "name": "tool1",
+            "providerOptions": undefined,
+            "type": "function",
+          },
+          {
+            "description": "Tool 2 description",
+            "inputSchema": {
+              "$schema": "http://json-schema.org/draft-07/schema#",
+              "additionalProperties": false,
+              "properties": {
+                "city": {
+                  "type": "string",
+                },
+              },
+              "required": [
+                "city",
+              ],
+              "type": "object",
+            },
+            "name": "tool2",
+            "providerOptions": undefined,
+            "type": "function",
+          },
+        ],
+      }
+    `);
+  });
+
+  it('should handle provider-defined tool type', async () => {
+    const result = await prepareToolsAndToolChoice({
+      tools: mockToolsWithProviderDefined,
+      toolChoice: undefined,
+      activeTools: undefined,
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "toolChoice": {
+          "type": "auto",
+        },
+        "tools": [
+          {
+            "description": "Tool 1 description",
+            "inputSchema": {
+              "$schema": "http://json-schema.org/draft-07/schema#",
+              "additionalProperties": false,
+              "properties": {},
+              "type": "object",
+            },
+            "name": "tool1",
+            "providerOptions": undefined,
+            "type": "function",
+          },
+          {
+            "description": "Tool 2 description",
+            "inputSchema": {
+              "$schema": "http://json-schema.org/draft-07/schema#",
+              "additionalProperties": false,
+              "properties": {
+                "city": {
+                  "type": "string",
+                },
+              },
+              "required": [
+                "city",
+              ],
+              "type": "object",
+            },
+            "name": "tool2",
+            "providerOptions": undefined,
+            "type": "function",
+          },
+          {
+            "args": {
+              "key": "value",
+            },
+            "id": "provider.tool-id",
+            "name": "providerTool",
+            "type": "provider",
+          },
+        ],
+      }
+    `);
+  });
+
+  it('should pass through provider options', async () => {
+    const result = await prepareToolsAndToolChoice({
+      tools: {
+        tool1: tool({
+          description: 'Tool 1 description',
+          inputSchema: z.object({}),
+          providerOptions: {
+            aProvider: {
+              aSetting: 'aValue',
+            },
+          },
+        }),
+      },
+      toolChoice: undefined,
+      activeTools: undefined,
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "toolChoice": {
+          "type": "auto",
+        },
+        "tools": [
+          {
+            "description": "Tool 1 description",
+            "inputSchema": {
+              "$schema": "http://json-schema.org/draft-07/schema#",
+              "additionalProperties": false,
+              "properties": {},
+              "type": "object",
+            },
+            "name": "tool1",
+            "providerOptions": {
+              "aProvider": {
+                "aSetting": "aValue",
+              },
+            },
+            "type": "function",
+          },
+        ],
+      }
+    `);
+  });
+
+  it('should pass through strict mode setting', async () => {
+    const result = await prepareToolsAndToolChoice({
+      tools: {
+        tool1: tool({
+          description: 'Tool 1 description',
+          inputSchema: z.object({}),
+          strict: true,
+        }),
+      },
+      toolChoice: undefined,
+      activeTools: undefined,
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "toolChoice": {
+          "type": "auto",
+        },
+        "tools": [
+          {
+            "description": "Tool 1 description",
+            "inputSchema": {
+              "$schema": "http://json-schema.org/draft-07/schema#",
+              "additionalProperties": false,
+              "properties": {},
+              "type": "object",
+            },
+            "name": "tool1",
+            "providerOptions": undefined,
+            "strict": true,
+            "type": "function",
+          },
+        ],
+      }
+    `);
+  });
+
+  it('should pass through input examples', async () => {
+    const result = await prepareToolsAndToolChoice({
+      tools: {
+        tool1: tool({
+          description: 'Tool 1 description',
+          inputSchema: z.object({
+            city: z.string(),
+          }),
+          inputExamples: [{ input: { city: 'New York' } }],
+        }),
+      },
+      toolChoice: undefined,
+      activeTools: undefined,
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "toolChoice": {
+          "type": "auto",
+        },
+        "tools": [
+          {
+            "description": "Tool 1 description",
+            "inputExamples": [
+              {
+                "input": {
+                  "city": "New York",
+                },
+              },
+            ],
+            "inputSchema": {
+              "$schema": "http://json-schema.org/draft-07/schema#",
+              "additionalProperties": false,
+              "properties": {
+                "city": {
+                  "type": "string",
+                },
+              },
+              "required": [
+                "city",
+              ],
+              "type": "object",
+            },
+            "name": "tool1",
+            "providerOptions": undefined,
+            "type": "function",
+          },
+        ],
+      }
+    `);
+  });
+});

package/src/prompt/prepare-tools-and-tool-choice.ts

@@ -0,0 +1,86 @@
+import {
+  LanguageModelV3FunctionTool,
+  LanguageModelV3ProviderTool,
+  LanguageModelV3ToolChoice,
+} from '@ai-sdk/provider';
+import { asSchema } from '@ai-sdk/provider-utils';
+import { isNonEmptyObject } from '../util/is-non-empty-object';
+import { ToolSet } from '../generate-text';
+import { ToolChoice } from '../types/language-model';
+
+export async function prepareToolsAndToolChoice<TOOLS extends ToolSet>({
+  tools,
+  toolChoice,
+  activeTools,
+}: {
+  tools: TOOLS | undefined;
+  toolChoice: ToolChoice<TOOLS> | undefined;
+  activeTools: Array<keyof TOOLS> | undefined;
+}): Promise<{
+  tools:
+    | Array<LanguageModelV3FunctionTool | LanguageModelV3ProviderTool>
+    | undefined;
+  toolChoice: LanguageModelV3ToolChoice | undefined;
+}> {
+  if (!isNonEmptyObject(tools)) {
+    return {
+      tools: undefined,
+      toolChoice: undefined,
+    };
+  }
+
+  // when activeTools is provided, we only include the tools that are in the list:
+  const filteredTools =
+    activeTools != null
+      ? Object.entries(tools).filter(([name]) =>
+          activeTools.includes(name as keyof TOOLS),
+        )
+      : Object.entries(tools);
+
+  const languageModelTools: Array<
+    LanguageModelV3FunctionTool | LanguageModelV3ProviderTool
+  > = [];
+  for (const [name, tool] of filteredTools) {
+    const toolType = tool.type;
+
+    switch (toolType) {
+      case undefined:
+      case 'dynamic':
+      case 'function':
+        languageModelTools.push({
+          type: 'function' as const,
+          name,
+          description: tool.description,
+          inputSchema: await asSchema(tool.inputSchema).jsonSchema,
+          ...(tool.inputExamples != null
+            ? { inputExamples: tool.inputExamples }
+            : {}),
+          providerOptions: tool.providerOptions,
+          ...(tool.strict != null ? { strict: tool.strict } : {}),
+        });
+        break;
+      case 'provider':
+        languageModelTools.push({
+          type: 'provider' as const,
+          name,
+          id: tool.id,
+          args: tool.args,
+        });
+        break;
+      default: {
+        const exhaustiveCheck: never = toolType as never;
+        throw new Error(`Unsupported tool type: ${exhaustiveCheck}`);
+      }
+    }
+  }
+
+  return {
+    tools: languageModelTools,
+    toolChoice:
+      toolChoice == null
+        ? { type: 'auto' }
+        : typeof toolChoice === 'string'
+          ? { type: toolChoice }
+          : { type: 'tool' as const, toolName: toolChoice.toolName as string },
+  };
+}

package/src/prompt/prompt.ts

@@ -0,0 +1,43 @@
+import { ModelMessage, SystemModelMessage } from '@ai-sdk/provider-utils';
+
+/**
+Prompt part of the AI function options.
+It contains a system message, a simple text prompt, or a list of messages.
+ */
+export type Prompt = {
+  /**
+System message to include in the prompt. Can be used with `prompt` or `messages`.
+   */
+  system?: string | SystemModelMessage | Array<SystemModelMessage>;
+} & (
+  | {
+      /**
+A prompt. It can be either a text prompt or a list of messages.
+
+You can either use `prompt` or `messages` but not both.
+*/
+      prompt: string | Array<ModelMessage>;
+
+      /**
+A list of messages.
+
+You can either use `prompt` or `messages` but not both.
+   */
+      messages?: never;
+    }
+  | {
+      /**
+A list of messages.
+
+You can either use `prompt` or `messages` but not both.
+   */
+      messages: Array<ModelMessage>;
+
+      /**
+A prompt. It can be either a text prompt or a list of messages.
+
+You can either use `prompt` or `messages` but not both.
+*/
+      prompt?: never;
+    }
+);

package/src/prompt/split-data-url.ts

@@ -0,0 +1,17 @@
+export function splitDataUrl(dataUrl: string): {
+  mediaType: string | undefined;
+  base64Content: string | undefined;
+} {
+  try {
+    const [header, base64Content] = dataUrl.split(',');
+    return {
+      mediaType: header.split(';')[0].split(':')[1],
+      base64Content,
+    };
+  } catch (error) {
+    return {
+      mediaType: undefined,
+      base64Content: undefined,
+    };
+  }
+}

package/src/prompt/standardize-prompt.test.ts

@@ -0,0 +1,82 @@
+import { InvalidPromptError } from '@ai-sdk/provider';
+import { standardizePrompt } from './standardize-prompt';
+import { describe, it, expect } from 'vitest';
+
+describe('standardizePrompt', () => {
+  it('should throw InvalidPromptError when system message has parts', async () => {
+    await expect(async () => {
+      await standardizePrompt({
+        messages: [
+          {
+            role: 'system',
+            content: [{ type: 'text', text: 'test' }] as any,
+          },
+        ],
+      });
+    }).rejects.toThrow(InvalidPromptError);
+  });
+
+  it('should throw InvalidPromptError when messages array is empty', async () => {
+    await expect(async () => {
+      await standardizePrompt({
+        messages: [],
+      });
+    }).rejects.toThrow(InvalidPromptError);
+  });
+
+  it('should support SystemModelMessage system message', async () => {
+    const result = await standardizePrompt({
+      system: {
+        role: 'system',
+        content: 'INSTRUCTIONS',
+      },
+      prompt: 'Hello, world!',
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "messages": [
+          {
+            "content": "Hello, world!",
+            "role": "user",
+          },
+        ],
+        "system": {
+          "content": "INSTRUCTIONS",
+          "role": "system",
+        },
+      }
+    `);
+  });
+
+  it('should support array of SystemModelMessage system messages', async () => {
+    const result = await standardizePrompt({
+      system: [
+        { role: 'system', content: 'INSTRUCTIONS' },
+        { role: 'system', content: 'INSTRUCTIONS 2' },
+      ],
+      prompt: 'Hello, world!',
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "messages": [
+          {
+            "content": "Hello, world!",
+            "role": "user",
+          },
+        ],
+        "system": [
+          {
+            "content": "INSTRUCTIONS",
+            "role": "system",
+          },
+          {
+            "content": "INSTRUCTIONS 2",
+            "role": "system",
+          },
+        ],
+      }
+    `);
+  });
+});