ai 6.0.32 → 6.0.34

package/dist/internal/index.js

@@ -153,7 +153,7 @@ var import_provider_utils2 = require("@ai-sdk/provider-utils");
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
 
 // src/version.ts
-var VERSION = true ? "6.0.32" : "0.0.0-test";
+var VERSION = true ? "6.0.34" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({ url }) => {

package/dist/internal/index.mjs

@@ -128,7 +128,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "6.0.32" : "0.0.0-test";
+var VERSION = true ? "6.0.34" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({ url }) => {

package/docs/02-foundations/03-prompts.mdx

@@ -153,7 +153,7 @@ const messages: ModelMessage[] = [
       {
         type: 'image',
         image:
-          'https://github.com/vercel/ai/blob/main/examples/ai-core/data/comic-cat.png?raw=true',
+          'https://github.com/vercel/ai/blob/main/examples/ai-functions/data/comic-cat.png?raw=true',
         // Sets image detail configuration for image part:
         providerOptions: {
           openai: { imageDetail: 'low' },
@@ -268,7 +268,7 @@ const result = await generateText({
         {
           type: 'image',
           image:
-            'https://github.com/vercel/ai/blob/main/examples/ai-core/data/comic-cat.png?raw=true',
+            'https://github.com/vercel/ai/blob/main/examples/ai-functions/data/comic-cat.png?raw=true',
         },
       ],
     },

package/docs/03-ai-sdk-core/15-tools-and-tool-calling.mdx

@@ -22,7 +22,7 @@ The `tools` parameter of `generateText` and `streamText` is an object that has t
 
 ```ts highlight="6-17"
 import { z } from 'zod';
-import { generateText, tool, stopWhen } from 'ai';
+import { generateText, tool, stepCountIs } from 'ai';
 __PROVIDER_IMPORT__;
 
 const result = await generateText({

package/docs/07-reference/01-ai-sdk-core/28-output.mdx

@@ -217,7 +217,7 @@ import { generateText, Output } from 'ai';
 const { output } = await generateText({
   model: yourModel,
   output: Output.choice({
-    options: ['sunny', 'rainy', 'snowy'],
+    options: ['sunny', 'rainy', 'snowy'] as const,
   }),
   prompt: 'Is the weather sunny, rainy, or snowy today?',
 });

package/package.json

@@ -1,15 +1,17 @@
 {
   "name": "ai",
-  "version": "6.0.32",
+  "version": "6.0.34",
   "description": "AI SDK by Vercel - The AI Toolkit for TypeScript and JavaScript",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
+  "source": "./src/index.ts",
   "files": [
     "dist/**/*",
     "docs/**/*",
+    "src",
     "CHANGELOG.md",
     "internal.d.ts",
     "README.md",
@@ -40,9 +42,9 @@
   },
   "dependencies": {
     "@opentelemetry/api": "1.9.0",
-    "@ai-sdk/gateway": "3.0.13",
-    "@ai-sdk/provider": "3.0.2",
-    "@ai-sdk/provider-utils": "4.0.5"
+    "@ai-sdk/gateway": "3.0.14",
+    "@ai-sdk/provider": "3.0.3",
+    "@ai-sdk/provider-utils": "4.0.6"
   },
   "devDependencies": {
     "@edge-runtime/vm": "^5.0.0",

package/src/agent/agent.ts

@@ -0,0 +1,116 @@
+import { ModelMessage } from '@ai-sdk/provider-utils';
+import { GenerateTextResult } from '../generate-text/generate-text-result';
+import { Output } from '../generate-text/output';
+import { StreamTextTransform } from '../generate-text/stream-text';
+import { StreamTextResult } from '../generate-text/stream-text-result';
+import { ToolSet } from '../generate-text/tool-set';
+import { TimeoutConfiguration } from '../prompt/call-settings';
+
+/**
+ * Parameters for calling an agent.
+ */
+export type AgentCallParameters<CALL_OPTIONS> = ([CALL_OPTIONS] extends [never]
+  ? { options?: never }
+  : { options: CALL_OPTIONS }) &
+  (
+    | {
+        /**
+         * 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;
+      }
+  ) & {
+    /**
+     * Abort signal.
+     */
+    abortSignal?: AbortSignal;
+
+    /**
+     * Timeout in milliseconds. Can be specified as a number or as an object with `totalMs`.
+     */
+    timeout?: TimeoutConfiguration;
+  };
+
+/**
+ * Parameters for streaming an output from an agent.
+ */
+export type AgentStreamParameters<
+  CALL_OPTIONS,
+  TOOLS extends ToolSet,
+> = AgentCallParameters<CALL_OPTIONS> & {
+  /**
+   * Optional stream transformations.
+   * They are applied in the order they are provided.
+   * The stream transformations must maintain the stream structure for streamText to work correctly.
+   */
+  experimental_transform?:
+    | StreamTextTransform<TOOLS>
+    | Array<StreamTextTransform<TOOLS>>;
+};
+
+/**
+ * An Agent receives a prompt (text or messages) and generates or streams an output
+ * that consists of steps, tool calls, data parts, etc.
+ *
+ * You can implement your own Agent by implementing the `Agent` interface,
+ * or use the `ToolLoopAgent` class.
+ */
+export interface Agent<
+  CALL_OPTIONS = never,
+  TOOLS extends ToolSet = {},
+  OUTPUT extends Output = never,
+> {
+  /**
+   * The specification version of the agent interface. This will enable
+   * us to evolve the agent interface and retain backwards compatibility.
+   */
+  readonly version: 'agent-v1';
+
+  /**
+   * The id of the agent.
+   */
+  readonly id: string | undefined;
+
+  /**
+   * The tools that the agent can use.
+   */
+  readonly tools: TOOLS;
+
+  /**
+   * Generates an output from the agent (non-streaming).
+   */
+  generate(
+    options: AgentCallParameters<CALL_OPTIONS>,
+  ): PromiseLike<GenerateTextResult<TOOLS, OUTPUT>>;
+
+  /**
+   * Streams an output from the agent (streaming).
+   */
+  stream(
+    options: AgentStreamParameters<CALL_OPTIONS, TOOLS>,
+  ): PromiseLike<StreamTextResult<TOOLS, OUTPUT>>;
+}

package/src/agent/create-agent-ui-stream-response.test.ts

@@ -0,0 +1,258 @@
+import { LanguageModelV3CallOptions } from '@ai-sdk/provider';
+import { tool } from '@ai-sdk/provider-utils';
+import {
+  convertArrayToReadableStream,
+  convertReadableStreamToArray,
+} from '@ai-sdk/provider-utils/test';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { z } from 'zod/v4';
+import { MockLanguageModelV3 } from '../test/mock-language-model-v3';
+import { createAgentUIStreamResponse } from './create-agent-ui-stream-response';
+import { ToolLoopAgent } from './tool-loop-agent';
+
+describe('createAgentUIStreamResponse', () => {
+  describe('when using tools toModelOutput', () => {
+    let recordedInputs: LanguageModelV3CallOptions[];
+    let response: Response;
+    let decodedChunks: string[];
+
+    beforeEach(async () => {
+      recordedInputs = [];
+
+      const agent = new ToolLoopAgent({
+        model: new MockLanguageModelV3({
+          doStream: async input => {
+            recordedInputs.push(input);
+            return {
+              stream: convertArrayToReadableStream([
+                {
+                  type: 'stream-start',
+                  warnings: [],
+                },
+                {
+                  type: 'response-metadata',
+                  id: 'id-0',
+                  modelId: 'mock-model-id',
+                  timestamp: new Date(0),
+                },
+                { type: 'text-start', id: '1' },
+                { type: 'text-delta', id: '1', delta: 'Hello' },
+                { type: 'text-delta', id: '1', delta: ', ' },
+                { type: 'text-delta', id: '1', delta: `world!` },
+                { type: 'text-end', id: '1' },
+                {
+                  type: 'finish',
+                  finishReason: { unified: 'stop', raw: 'stop' },
+                  usage: {
+                    inputTokens: {
+                      total: 10,
+                      noCache: 10,
+                      cacheRead: undefined,
+                      cacheWrite: undefined,
+                    },
+                    outputTokens: {
+                      total: 10,
+                      text: 10,
+                      reasoning: undefined,
+                    },
+                  },
+                  providerMetadata: {
+                    testProvider: { testKey: 'testValue' },
+                  },
+                },
+              ]),
+            };
+          },
+        }),
+        tools: {
+          example: tool({
+            description: 'Example tool',
+            inputSchema: z.object({
+              input: z.string(),
+            }),
+            outputSchema: z.object({
+              value: z.string(),
+            }),
+            // important: tool has toModelOutput that needs to be called
+            toModelOutput: ({ output }) => ({
+              type: 'content',
+              value: [{ type: 'text', text: output.value }],
+            }),
+          }),
+        },
+      });
+
+      response = await createAgentUIStreamResponse({
+        agent,
+        uiMessages: [
+          {
+            role: 'user',
+            id: 'msg-1',
+            parts: [
+              {
+                type: 'text' as const,
+                text: 'Hello, world!',
+              },
+            ],
+          },
+          {
+            role: 'assistant',
+            id: 'msg-2',
+            parts: [
+              {
+                type: 'tool-example' as const,
+                toolCallId: 'call-1',
+                state: 'output-available',
+                input: {
+                  input: 'Hello, world!',
+                },
+                output: {
+                  value: 'Example tool: Hello, world!',
+                },
+              },
+            ],
+          },
+        ],
+      });
+
+      // consume the response
+      const decoder = new TextDecoder();
+      const encodedStream = response.body!;
+      const chunks = await convertReadableStreamToArray(encodedStream);
+      decodedChunks = chunks.map(chunk => decoder.decode(chunk));
+    });
+
+    it('should have a single call that contains the tool result as text', () => {
+      expect(recordedInputs).toMatchInlineSnapshot(`
+          [
+            {
+              "abortSignal": undefined,
+              "frequencyPenalty": undefined,
+              "headers": undefined,
+              "includeRawChunks": false,
+              "maxOutputTokens": undefined,
+              "presencePenalty": undefined,
+              "prompt": [
+                {
+                  "content": [
+                    {
+                      "providerOptions": undefined,
+                      "text": "Hello, world!",
+                      "type": "text",
+                    },
+                  ],
+                  "providerOptions": undefined,
+                  "role": "user",
+                },
+                {
+                  "content": [
+                    {
+                      "input": {
+                        "input": "Hello, world!",
+                      },
+                      "providerExecuted": undefined,
+                      "providerOptions": undefined,
+                      "toolCallId": "call-1",
+                      "toolName": "example",
+                      "type": "tool-call",
+                    },
+                  ],
+                  "providerOptions": undefined,
+                  "role": "assistant",
+                },
+                {
+                  "content": [
+                    {
+                      "output": {
+                        "type": "content",
+                        "value": [
+                          {
+                            "text": "Example tool: Hello, world!",
+                            "type": "text",
+                          },
+                        ],
+                      },
+                      "providerOptions": undefined,
+                      "toolCallId": "call-1",
+                      "toolName": "example",
+                      "type": "tool-result",
+                    },
+                  ],
+                  "providerOptions": undefined,
+                  "role": "tool",
+                },
+              ],
+              "providerOptions": undefined,
+              "responseFormat": undefined,
+              "seed": undefined,
+              "stopSequences": undefined,
+              "temperature": undefined,
+              "toolChoice": {
+                "type": "auto",
+              },
+              "tools": [
+                {
+                  "description": "Example tool",
+                  "inputSchema": {
+                    "$schema": "http://json-schema.org/draft-07/schema#",
+                    "additionalProperties": false,
+                    "properties": {
+                      "input": {
+                        "type": "string",
+                      },
+                    },
+                    "required": [
+                      "input",
+                    ],
+                    "type": "object",
+                  },
+                  "name": "example",
+                  "providerOptions": undefined,
+                  "type": "function",
+                },
+              ],
+              "topK": undefined,
+              "topP": undefined,
+            },
+          ]
+        `);
+    });
+
+    it('should return the UI message stream response', () => {
+      expect(decodedChunks).toMatchInlineSnapshot(`
+        [
+          "data: {"type":"start"}
+
+        ",
+          "data: {"type":"start-step"}
+
+        ",
+          "data: {"type":"text-start","id":"1"}
+
+        ",
+          "data: {"type":"text-delta","id":"1","delta":"Hello"}
+
+        ",
+          "data: {"type":"text-delta","id":"1","delta":", "}
+
+        ",
+          "data: {"type":"text-delta","id":"1","delta":"world!"}
+
+        ",
+          "data: {"type":"text-end","id":"1"}
+
+        ",
+          "data: {"type":"finish-step"}
+
+        ",
+          "data: {"type":"finish","finishReason":"stop"}
+
+        ",
+          "data: [DONE]
+
+        ",
+        ]
+      `);
+    });
+  });
+});

package/src/agent/create-agent-ui-stream-response.ts

@@ -0,0 +1,50 @@
+import { StreamTextTransform, UIMessageStreamOptions } from '../generate-text';
+import { Output } from '../generate-text/output';
+import { ToolSet } from '../generate-text/tool-set';
+import { TimeoutConfiguration } from '../prompt/call-settings';
+import { createUIMessageStreamResponse } from '../ui-message-stream';
+import { UIMessageStreamResponseInit } from '../ui-message-stream/ui-message-stream-response-init';
+import { InferUITools, UIMessage } from '../ui/ui-messages';
+import { Agent } from './agent';
+import { createAgentUIStream } from './create-agent-ui-stream';
+
+/**
+ * Runs the agent and returns a response object with a UI message stream.
+ *
+ * @param agent - The agent to run.
+ * @param uiMessages - The input UI messages.
+ *
+ * @returns The response object.
+ */
+export async function createAgentUIStreamResponse<
+  CALL_OPTIONS = never,
+  TOOLS extends ToolSet = {},
+  OUTPUT extends Output = never,
+  MESSAGE_METADATA = unknown,
+>({
+  headers,
+  status,
+  statusText,
+  consumeSseStream,
+  ...options
+}: {
+  agent: Agent<CALL_OPTIONS, TOOLS, OUTPUT>;
+  uiMessages: unknown[];
+  abortSignal?: AbortSignal;
+  timeout?: TimeoutConfiguration;
+  options?: CALL_OPTIONS;
+  experimental_transform?:
+    | StreamTextTransform<TOOLS>
+    | Array<StreamTextTransform<TOOLS>>;
+} & UIMessageStreamResponseInit &
+  UIMessageStreamOptions<
+    UIMessage<MESSAGE_METADATA, never, InferUITools<TOOLS>>
+  >): Promise<Response> {
+  return createUIMessageStreamResponse({
+    headers,
+    status,
+    statusText,
+    consumeSseStream,
+    stream: await createAgentUIStream(options),
+  });
+}

package/src/agent/create-agent-ui-stream.ts

@@ -0,0 +1,73 @@
+import { StreamTextTransform, UIMessageStreamOptions } from '../generate-text';
+import { Output } from '../generate-text/output';
+import { ToolSet } from '../generate-text/tool-set';
+import { TimeoutConfiguration } from '../prompt/call-settings';
+import { InferUIMessageChunk } from '../ui-message-stream';
+import { convertToModelMessages } from '../ui/convert-to-model-messages';
+import { InferUITools, UIMessage } from '../ui/ui-messages';
+import { validateUIMessages } from '../ui/validate-ui-messages';
+import { AsyncIterableStream } from '../util/async-iterable-stream';
+import { Agent } from './agent';
+
+/**
+ * Runs the agent and stream the output as a UI message stream.
+ *
+ * @param agent - The agent to run.
+ * @param uiMessages - The input UI messages.
+ * @param abortSignal - The abort signal. Optional.
+ * @param timeout - Timeout in milliseconds. Optional.
+ * @param options - The options for the agent.
+ * @param experimental_transform - The stream transformations. Optional.
+ *
+ * @returns The UI message stream.
+ */
+export async function createAgentUIStream<
+  CALL_OPTIONS = never,
+  TOOLS extends ToolSet = {},
+  OUTPUT extends Output = never,
+  MESSAGE_METADATA = unknown,
+>({
+  agent,
+  uiMessages,
+  options,
+  abortSignal,
+  timeout,
+  experimental_transform,
+  ...uiMessageStreamOptions
+}: {
+  agent: Agent<CALL_OPTIONS, TOOLS, OUTPUT>;
+  uiMessages: unknown[];
+  abortSignal?: AbortSignal;
+  timeout?: TimeoutConfiguration;
+  options?: CALL_OPTIONS;
+  experimental_transform?:
+    | StreamTextTransform<TOOLS>
+    | Array<StreamTextTransform<TOOLS>>;
+} & UIMessageStreamOptions<
+  UIMessage<MESSAGE_METADATA, never, InferUITools<TOOLS>>
+>): Promise<
+  AsyncIterableStream<
+    InferUIMessageChunk<UIMessage<MESSAGE_METADATA, never, InferUITools<TOOLS>>>
+  >
+> {
+  const validatedMessages = await validateUIMessages<
+    UIMessage<MESSAGE_METADATA, never, InferUITools<TOOLS>>
+  >({
+    messages: uiMessages,
+    tools: agent.tools,
+  });
+
+  const modelMessages = await convertToModelMessages(validatedMessages, {
+    tools: agent.tools,
+  });
+
+  const result = await agent.stream({
+    prompt: modelMessages,
+    options: options as CALL_OPTIONS,
+    abortSignal,
+    timeout,
+    experimental_transform,
+  });
+
+  return result.toUIMessageStream(uiMessageStreamOptions);
+}

package/src/agent/index.ts

@@ -0,0 +1,33 @@
+export {
+  type Agent,
+  type AgentCallParameters,
+  type AgentStreamParameters,
+} from './agent';
+export { type ToolLoopAgentOnFinishCallback } from './tool-loop-agent-on-finish-callback';
+export { type ToolLoopAgentOnStepFinishCallback } from './tool-loop-agent-on-step-finish-callback';
+export {
+  type ToolLoopAgentSettings,
+
+  /**
+   * @deprecated Use `ToolLoopAgentSettings` instead.
+   */
+  type ToolLoopAgentSettings as Experimental_AgentSettings,
+} from './tool-loop-agent-settings';
+export {
+  ToolLoopAgent,
+
+  /**
+   * @deprecated Use `ToolLoopAgent` instead.
+   */
+  ToolLoopAgent as Experimental_Agent,
+} from './tool-loop-agent';
+export {
+  /**
+   * @deprecated Use `InferAgentUIMessage` instead.
+   */
+  type InferAgentUIMessage as Experimental_InferAgentUIMessage,
+  type InferAgentUIMessage,
+} from './infer-agent-ui-message';
+export { createAgentUIStreamResponse } from './create-agent-ui-stream-response';
+export { createAgentUIStream } from './create-agent-ui-stream';
+export { pipeAgentUIStreamToResponse } from './pipe-agent-ui-stream-to-response';

package/src/agent/infer-agent-tools.ts

@@ -0,0 +1,7 @@
+import { Agent } from './agent';
+
+/**
+ * Infer the type of the tools of an agent.
+ */
+export type InferAgentTools<AGENT> =
+  AGENT extends Agent<any, infer TOOLS, any> ? TOOLS : never;

package/src/agent/infer-agent-ui-message.test-d.ts

@@ -0,0 +1,54 @@
+import { describe, expectTypeOf, it } from 'vitest';
+import {
+  DataUIPart,
+  DynamicToolUIPart,
+  FileUIPart,
+  ReasoningUIPart,
+  SourceDocumentUIPart,
+  SourceUrlUIPart,
+  StepStartUIPart,
+  TextUIPart,
+  UIMessage,
+} from '../ui/ui-messages';
+import { ToolLoopAgent } from './tool-loop-agent';
+import { InferAgentUIMessage } from './infer-agent-ui-message';
+
+describe('InferAgentUIMessage', () => {
+  it('should not contain arbitrary static tools when no tools are provided', () => {
+    const agent = new ToolLoopAgent({
+      model: 'openai/gpt-4o',
+      // no tools
+    });
+
+    type Message = InferAgentUIMessage<typeof agent>;
+
+    expectTypeOf<Message>().toMatchTypeOf<UIMessage<unknown, never, {}>>();
+
+    type MessagePart = Message['parts'][number];
+
+    expectTypeOf<MessagePart>().toMatchTypeOf<
+      | TextUIPart
+      | ReasoningUIPart
+      // No static tools, so no ToolUIPart
+      | DynamicToolUIPart
+      | SourceUrlUIPart
+      | SourceDocumentUIPart
+      | FileUIPart
+      | DataUIPart<never>
+      | StepStartUIPart
+    >();
+  });
+
+  it('should include metadata when provided', () => {
+    const agent = new ToolLoopAgent({
+      model: 'openai/gpt-4o',
+      // no tools
+    });
+
+    type Message = InferAgentUIMessage<typeof agent, { foo: string }>;
+
+    expectTypeOf<Message>().toMatchTypeOf<
+      UIMessage<{ foo: string }, never, {}>
+    >();
+  });
+});