ai 6.0.32 → 6.0.34

package/src/middleware/add-tool-input-examples-middleware.test.ts

@@ -0,0 +1,476 @@
+import { JSONObject, LanguageModelV3CallOptions } from '@ai-sdk/provider';
+import { addToolInputExamplesMiddleware } from './add-tool-input-examples-middleware';
+import { MockLanguageModelV3 } from '../test/mock-language-model-v3';
+import { describe, it, expect } from 'vitest';
+
+const BASE_PARAMS: LanguageModelV3CallOptions = {
+  prompt: [
+    { role: 'user', content: [{ type: 'text', text: 'Hello, world!' }] },
+  ],
+};
+
+const MOCK_MODEL = new MockLanguageModelV3();
+
+describe('addToolInputExamplesMiddleware', () => {
+  describe('transformParams', () => {
+    it('should append examples to tool description', async () => {
+      const middleware = addToolInputExamplesMiddleware();
+
+      const result = await middleware.transformParams!({
+        type: 'generate',
+        params: {
+          ...BASE_PARAMS,
+          tools: [
+            {
+              type: 'function',
+              name: 'weather',
+              description: 'Get the weather in a location',
+              inputSchema: {
+                type: 'object',
+                properties: { location: { type: 'string' } },
+              },
+              inputExamples: [
+                { input: { location: 'San Francisco' } },
+                { input: { location: 'London' } },
+              ],
+            },
+          ],
+        },
+        model: MOCK_MODEL,
+      });
+
+      expect(result.tools).toMatchInlineSnapshot(`
+        [
+          {
+            "description": "Get the weather in a location
+
+        Input Examples:
+        {"location":"San Francisco"}
+        {"location":"London"}",
+            "inputExamples": undefined,
+            "inputSchema": {
+              "properties": {
+                "location": {
+                  "type": "string",
+                },
+              },
+              "type": "object",
+            },
+            "name": "weather",
+            "type": "function",
+          },
+        ]
+      `);
+    });
+
+    it('should handle tool without existing description', async () => {
+      const middleware = addToolInputExamplesMiddleware();
+
+      const result = await middleware.transformParams!({
+        type: 'generate',
+        params: {
+          ...BASE_PARAMS,
+          tools: [
+            {
+              type: 'function',
+              name: 'weather',
+              inputSchema: {
+                type: 'object',
+                properties: { location: { type: 'string' } },
+              },
+              inputExamples: [{ input: { location: 'Berlin' } }],
+            },
+          ],
+        },
+        model: MOCK_MODEL,
+      });
+
+      expect(result.tools).toMatchInlineSnapshot(`
+        [
+          {
+            "description": "Input Examples:
+        {"location":"Berlin"}",
+            "inputExamples": undefined,
+            "inputSchema": {
+              "properties": {
+                "location": {
+                  "type": "string",
+                },
+              },
+              "type": "object",
+            },
+            "name": "weather",
+            "type": "function",
+          },
+        ]
+      `);
+    });
+  });
+
+  describe('examplesPrefix', () => {
+    it('should use provided examplesPrefix as header', async () => {
+      const middleware = addToolInputExamplesMiddleware({
+        prefix: 'Here are some example inputs:',
+      });
+
+      const result = await middleware.transformParams!({
+        type: 'generate',
+        params: {
+          ...BASE_PARAMS,
+          tools: [
+            {
+              type: 'function',
+              name: 'weather',
+              description: 'Get the weather',
+              inputSchema: {
+                type: 'object',
+                properties: { location: { type: 'string' } },
+              },
+              inputExamples: [{ input: { location: 'Paris' } }],
+            },
+          ],
+        },
+        model: MOCK_MODEL,
+      });
+
+      expect((result.tools![0] as any).description).toMatchInlineSnapshot(`
+        "Get the weather
+
+        Here are some example inputs:
+        {"location":"Paris"}"
+      `);
+    });
+  });
+
+  describe('formatExample', () => {
+    it('should use default JSON.stringify format', async () => {
+      const middleware = addToolInputExamplesMiddleware();
+
+      const result = await middleware.transformParams!({
+        type: 'generate',
+        params: {
+          ...BASE_PARAMS,
+          tools: [
+            {
+              type: 'function',
+              name: 'search',
+              description: 'Search for items',
+              inputSchema: {
+                type: 'object',
+                properties: {
+                  query: { type: 'string' },
+                  limit: { type: 'number' },
+                },
+              },
+              inputExamples: [{ input: { query: 'test', limit: 10 } }],
+            },
+          ],
+        },
+        model: MOCK_MODEL,
+      });
+
+      expect((result.tools![0] as any).description).toMatchInlineSnapshot(`
+        "Search for items
+
+        Input Examples:
+        {"query":"test","limit":10}"
+      `);
+    });
+
+    it('should use custom format function', async () => {
+      const middleware = addToolInputExamplesMiddleware({
+        format: (example: { input: JSONObject }, index: number) =>
+          `${index + 1}. ${JSON.stringify(example.input)}`,
+      });
+
+      const result = await middleware.transformParams!({
+        type: 'generate',
+        params: {
+          ...BASE_PARAMS,
+          tools: [
+            {
+              type: 'function',
+              name: 'weather',
+              description: 'Get the weather',
+              inputSchema: {
+                type: 'object',
+                properties: { location: { type: 'string' } },
+              },
+              inputExamples: [
+                { input: { location: 'Paris' } },
+                { input: { location: 'Tokyo' } },
+              ],
+            },
+          ],
+        },
+        model: MOCK_MODEL,
+      });
+
+      expect((result.tools![0] as any).description).toMatchInlineSnapshot(`
+        "Get the weather
+
+        Input Examples:
+        1. {"location":"Paris"}
+        2. {"location":"Tokyo"}"
+      `);
+    });
+  });
+
+  describe('removeInputExamples', () => {
+    it('should remove inputExamples by default', async () => {
+      const middleware = addToolInputExamplesMiddleware();
+
+      const result = await middleware.transformParams!({
+        type: 'generate',
+        params: {
+          ...BASE_PARAMS,
+          tools: [
+            {
+              type: 'function',
+              name: 'weather',
+              description: 'Get the weather',
+              inputSchema: {
+                type: 'object',
+                properties: { location: { type: 'string' } },
+              },
+              inputExamples: [{ input: { location: 'NYC' } }],
+            },
+          ],
+        },
+        model: MOCK_MODEL,
+      });
+
+      expect((result.tools![0] as any).inputExamples).toBeUndefined();
+    });
+
+    it('should keep inputExamples when remove is false', async () => {
+      const middleware = addToolInputExamplesMiddleware({
+        remove: false,
+      });
+
+      const result = await middleware.transformParams!({
+        type: 'generate',
+        params: {
+          ...BASE_PARAMS,
+          tools: [
+            {
+              type: 'function',
+              name: 'weather',
+              description: 'Get the weather',
+              inputSchema: {
+                type: 'object',
+                properties: { location: { type: 'string' } },
+              },
+              inputExamples: [{ input: { location: 'NYC' } }],
+            },
+          ],
+        },
+        model: MOCK_MODEL,
+      });
+
+      expect((result.tools![0] as any).inputExamples).toMatchInlineSnapshot(`
+        [
+          {
+            "input": {
+              "location": "NYC",
+            },
+          },
+        ]
+      `);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should pass through tools without inputExamples', async () => {
+      const middleware = addToolInputExamplesMiddleware();
+
+      const result = await middleware.transformParams!({
+        type: 'generate',
+        params: {
+          ...BASE_PARAMS,
+          tools: [
+            {
+              type: 'function',
+              name: 'weather',
+              description: 'Get the weather',
+              inputSchema: {
+                type: 'object',
+                properties: { location: { type: 'string' } },
+              },
+            },
+          ],
+        },
+        model: MOCK_MODEL,
+      });
+
+      expect(result.tools).toMatchInlineSnapshot(`
+        [
+          {
+            "description": "Get the weather",
+            "inputSchema": {
+              "properties": {
+                "location": {
+                  "type": "string",
+                },
+              },
+              "type": "object",
+            },
+            "name": "weather",
+            "type": "function",
+          },
+        ]
+      `);
+    });
+
+    it('should pass through tools with empty inputExamples array', async () => {
+      const middleware = addToolInputExamplesMiddleware();
+
+      const result = await middleware.transformParams!({
+        type: 'generate',
+        params: {
+          ...BASE_PARAMS,
+          tools: [
+            {
+              type: 'function',
+              name: 'weather',
+              description: 'Get the weather',
+              inputSchema: {
+                type: 'object',
+                properties: { location: { type: 'string' } },
+              },
+              inputExamples: [],
+            },
+          ],
+        },
+        model: MOCK_MODEL,
+      });
+
+      expect((result.tools![0] as any).description).toBe('Get the weather');
+    });
+
+    it('should pass through provider tools unchanged', async () => {
+      const middleware = addToolInputExamplesMiddleware();
+
+      const result = await middleware.transformParams!({
+        type: 'generate',
+        params: {
+          ...BASE_PARAMS,
+          tools: [
+            {
+              type: 'provider',
+              name: 'web_search',
+              id: 'anthropic.web_search_20250305',
+              args: { maxUses: 5 },
+            },
+          ],
+        },
+        model: MOCK_MODEL,
+      });
+
+      expect(result.tools).toMatchInlineSnapshot(`
+        [
+          {
+            "args": {
+              "maxUses": 5,
+            },
+            "id": "anthropic.web_search_20250305",
+            "name": "web_search",
+            "type": "provider",
+          },
+        ]
+      `);
+    });
+
+    it('should handle multiple tools with mixed examples', async () => {
+      const middleware = addToolInputExamplesMiddleware();
+
+      const result = await middleware.transformParams!({
+        type: 'generate',
+        params: {
+          ...BASE_PARAMS,
+          tools: [
+            {
+              type: 'function',
+              name: 'weather',
+              description: 'Get the weather',
+              inputSchema: {
+                type: 'object',
+                properties: { location: { type: 'string' } },
+              },
+              inputExamples: [{ input: { location: 'NYC' } }],
+            },
+            {
+              type: 'function',
+              name: 'time',
+              description: 'Get the current time',
+              inputSchema: {
+                type: 'object',
+                properties: { timezone: { type: 'string' } },
+              },
+            },
+          ],
+        },
+        model: MOCK_MODEL,
+      });
+
+      expect(result.tools).toMatchInlineSnapshot(`
+        [
+          {
+            "description": "Get the weather
+
+        Input Examples:
+        {"location":"NYC"}",
+            "inputExamples": undefined,
+            "inputSchema": {
+              "properties": {
+                "location": {
+                  "type": "string",
+                },
+              },
+              "type": "object",
+            },
+            "name": "weather",
+            "type": "function",
+          },
+          {
+            "description": "Get the current time",
+            "inputSchema": {
+              "properties": {
+                "timezone": {
+                  "type": "string",
+                },
+              },
+              "type": "object",
+            },
+            "name": "time",
+            "type": "function",
+          },
+        ]
+      `);
+    });
+
+    it('should handle empty tools array', async () => {
+      const middleware = addToolInputExamplesMiddleware();
+
+      const result = await middleware.transformParams!({
+        type: 'generate',
+        params: { ...BASE_PARAMS, tools: [] },
+        model: MOCK_MODEL,
+      });
+
+      expect(result.tools).toEqual([]);
+    });
+
+    it('should handle undefined tools', async () => {
+      const middleware = addToolInputExamplesMiddleware();
+
+      const result = await middleware.transformParams!({
+        type: 'generate',
+        params: { ...BASE_PARAMS, tools: undefined },
+        model: MOCK_MODEL,
+      });
+
+      expect(result.tools).toBeUndefined();
+    });
+  });
+});

package/src/middleware/add-tool-input-examples-middleware.ts

@@ -0,0 +1,90 @@
+import { JSONObject, LanguageModelV3FunctionTool } from '@ai-sdk/provider';
+import { LanguageModelMiddleware } from '../types';
+
+function defaultFormatExample(example: { input: JSONObject }): string {
+  return JSON.stringify(example.input);
+}
+
+/**
+ * Middleware that appends input examples to tool descriptions.
+ *
+ * This is useful for providers that don't natively support the `inputExamples`
+ * property. The middleware serializes examples into the tool's description text.
+ *
+ * @param options - Configuration options for the middleware.
+ * @param options.prefix - A prefix to prepend before the examples. Default: 'Input Examples:'
+ * @param options.format - Optional custom formatter for each example.
+ *   Receives the example object and its index. Default: JSON.stringify(example.input)
+ * @param options.remove - Whether to remove the inputExamples property
+ *   after adding them to the description. Default: true
+ *
+ * @example
+ * ```ts
+ * import { wrapLanguageModel, addToolInputExamplesMiddleware } from 'ai';
+ *
+ * const model = wrapLanguageModel({
+ *   model: yourModel,
+ *   middleware: addToolInputExamplesMiddleware(),
+ * });
+ * ```
+ */
+export function addToolInputExamplesMiddleware({
+  prefix = 'Input Examples:',
+  format = defaultFormatExample,
+  remove = true,
+}: {
+  /**
+   * A prefix to prepend before the examples.
+   */
+  prefix?: string;
+
+  /**
+   * Optional custom formatter for each example.
+   * Receives the example object and its index.
+   * Default: JSON.stringify(example.input)
+   */
+  format?: (example: { input: JSONObject }, index: number) => string;
+
+  /**
+   * Whether to remove the inputExamples property after adding them to the description.
+   * Default: true
+   */
+  remove?: boolean;
+} = {}): LanguageModelMiddleware {
+  return {
+    specificationVersion: 'v3',
+    transformParams: async ({ params }) => {
+      if (!params.tools?.length) {
+        return params;
+      }
+
+      const transformedTools = params.tools.map(tool => {
+        // Only transform function tools that have inputExamples
+        if (tool.type !== 'function' || !tool.inputExamples?.length) {
+          return tool;
+        }
+
+        const formattedExamples = tool.inputExamples
+          .map((example, index) => format(example, index))
+          .join('\n');
+
+        const examplesSection = `${prefix}\n${formattedExamples}`;
+
+        const toolDescription = tool.description
+          ? `${tool.description}\n\n${examplesSection}`
+          : examplesSection;
+
+        return {
+          ...tool,
+          description: toolDescription,
+          inputExamples: remove ? undefined : tool.inputExamples,
+        } satisfies LanguageModelV3FunctionTool;
+      });
+
+      return {
+        ...params,
+        tools: transformedTools,
+      };
+    },
+  };
+}

package/src/middleware/default-embedding-settings-middleware.test.ts

@@ -0,0 +1,126 @@
+import { EmbeddingModelV3CallOptions } from '@ai-sdk/provider';
+import { defaultEmbeddingSettingsMiddleware } from './default-embedding-settings-middleware';
+import { MockEmbeddingModelV3 } from '../test/mock-embedding-model-v3';
+import { describe, it, expect } from 'vitest';
+
+const params: EmbeddingModelV3CallOptions = {
+  values: ['hello world'],
+};
+
+const mockModel = new MockEmbeddingModelV3();
+
+describe('headers', () => {
+  it('should merge headers', async () => {
+    const middleware = defaultEmbeddingSettingsMiddleware({
+      settings: {
+        headers: { 'X-Custom-Header': 'test', 'X-Another-Header': 'test2' },
+      },
+    });
+    const result = await middleware.transformParams!({
+      params: {
+        ...params,
+        headers: { 'X-Custom-Header': 'test2' },
+      },
+      model: mockModel,
+    });
+    expect(result.headers).toEqual({
+      'X-Custom-Header': 'test2',
+      'X-Another-Header': 'test2',
+    });
+  });
+
+  it('should handle empty default headers', async () => {
+    const middleware = defaultEmbeddingSettingsMiddleware({
+      settings: { headers: {} },
+    });
+    const result = await middleware.transformParams!({
+      params: { ...params, headers: { 'X-Param-Header': 'param' } },
+      model: mockModel,
+    });
+    expect(result.headers).toEqual({ 'X-Param-Header': 'param' });
+  });
+
+  it('should handle empty param headers', async () => {
+    const middleware = defaultEmbeddingSettingsMiddleware({
+      settings: { headers: { 'X-Default-Header': 'default' } },
+    });
+    const result = await middleware.transformParams!({
+      params: { ...params, headers: {} },
+      model: mockModel,
+    });
+    expect(result.headers).toEqual({ 'X-Default-Header': 'default' });
+  });
+
+  it('should handle both headers being undefined', async () => {
+    const middleware = defaultEmbeddingSettingsMiddleware({
+      settings: {},
+    });
+    const result = await middleware.transformParams!({
+      params: { ...params },
+      model: mockModel,
+    });
+    expect(result.headers).toBeUndefined();
+  });
+});
+
+describe('providerOptions', () => {
+  it('should handle empty default providerOptions', async () => {
+    const middleware = defaultEmbeddingSettingsMiddleware({
+      settings: {
+        providerOptions: {},
+      },
+    });
+    const result = await middleware.transformParams!({
+      params: {
+        ...params,
+        providerOptions: {
+          google: {
+            outputDimensionality: 512,
+            taskType: 'SEMANTIC_SIMILARITY',
+          },
+        },
+      },
+      model: mockModel,
+    });
+    expect(result.providerOptions).toEqual({
+      google: {
+        outputDimensionality: 512,
+        taskType: 'SEMANTIC_SIMILARITY',
+      },
+    });
+  });
+
+  it('should handle empty param providerOptions', async () => {
+    const middleware = defaultEmbeddingSettingsMiddleware({
+      settings: {
+        providerOptions: {
+          google: {
+            outputDimensionality: 512,
+            taskType: 'SEMANTIC_SIMILARITY',
+          },
+        },
+      },
+    });
+    const result = await middleware.transformParams!({
+      params: { ...params, providerOptions: {} },
+      model: mockModel,
+    });
+    expect(result.providerOptions).toEqual({
+      google: {
+        outputDimensionality: 512,
+        taskType: 'SEMANTIC_SIMILARITY',
+      },
+    });
+  });
+
+  it('should handle both providerOptions being undefined', async () => {
+    const middleware = defaultEmbeddingSettingsMiddleware({
+      settings: {},
+    });
+    const result = await middleware.transformParams!({
+      params: { ...params },
+      model: mockModel,
+    });
+    expect(result.providerOptions).toBeUndefined();
+  });
+});

package/src/middleware/default-embedding-settings-middleware.ts

@@ -0,0 +1,22 @@
+import { EmbeddingModelV3CallOptions } from '@ai-sdk/provider';
+import { EmbeddingModelMiddleware } from '../types';
+import { mergeObjects } from '../util/merge-objects';
+
+/**
+ * Applies default settings for a embedding model.
+ */
+export function defaultEmbeddingSettingsMiddleware({
+  settings,
+}: {
+  settings: Partial<{
+    headers?: EmbeddingModelV3CallOptions['headers'];
+    providerOptions?: EmbeddingModelV3CallOptions['providerOptions'];
+  }>;
+}): EmbeddingModelMiddleware {
+  return {
+    specificationVersion: 'v3',
+    transformParams: async ({ params }) => {
+      return mergeObjects(settings, params) as EmbeddingModelV3CallOptions;
+    },
+  };
+}