ai 6.0.92 → 6.0.94

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

@@ -25,14 +25,9 @@ AI SDK Core contains the following main functions:
       href: '/docs/reference/ai-sdk-core/stream-text',
     },
     {
-      title: 'generateObject()',
-      description: 'Generate structured data from a language model.',
-      href: '/docs/reference/ai-sdk-core/generate-object',
-    },
-    {
-      title: 'streamObject()',
-      description: 'Stream structured data from a language model.',
-      href: '/docs/reference/ai-sdk-core/stream-object',
+      title: 'Output',
+      description: 'Structured output types for generateText and streamText.',
+      href: '/docs/reference/ai-sdk-core/output',
     },
     {
       title: 'embed()',

package/docs/07-reference/05-ai-sdk-errors/ai-no-object-generated-error.mdx

@@ -26,10 +26,10 @@ It can arise due to the following reasons:
 You can check if an error is an instance of `AI_NoObjectGeneratedError` using:
 
 ```typescript
-import { generateObject, NoObjectGeneratedError } from 'ai';
+import { generateText, NoObjectGeneratedError, Output } from 'ai';
 
 try {
-  await generateObject({ model, schema, prompt });
+  await generateText({ model, output: Output.object({ schema }), prompt });
 } catch (error) {
   if (NoObjectGeneratedError.isInstance(error)) {
     console.log('NoObjectGeneratedError');

package/docs/09-troubleshooting/09-client-stream-error.mdx

@@ -7,7 +7,7 @@ description: Troubleshooting errors related to using AI SDK Core functions with
 
 ## Issue
 
-I am using [`streamText`](/docs/reference/ai-sdk-core/stream-text) or [`streamObject`](/docs/reference/ai-sdk-core/stream-object) with Server Actions, and I am getting a `"only plain objects and a few built ins can be passed from client components"` error.
+I am using [`streamText`](/docs/reference/ai-sdk-core/stream-text) with Server Actions, and I am getting a `"only plain objects and a few built ins can be passed from client components"` error.
 
 ## Background
 

package/docs/09-troubleshooting/14-tool-calling-with-structured-outputs.mdx

@@ -1,13 +1,13 @@
 ---
-title: Tool calling with generateObject and streamObject
-description: Troubleshooting tool calling when combined with generateObject and streamObject
+title: Tool calling with structured outputs
+description: Troubleshooting tool calling when combined with structured output generation
 ---
 
-# Tool calling with generateObject and streamObject (structured outputs)
+# Tool calling with structured outputs
 
 ## Issue
 
-You may want to combine tool calling with structured output generation. While `generateObject` and `streamObject` are designed specifically for structured outputs, they don't support tool calling.
+You may want to combine tool calling with structured output generation.
 
 ## Background
 

package/docs/09-troubleshooting/20-no-object-generated-content-filter.mdx

@@ -7,20 +7,22 @@ description: Troubleshooting NoObjectGeneratedError with finish-reason content-f
 
 ## Issue
 
-When using `generateObject` or `streamObject` with OpenAI's structured output generation, you may encounter a `NoObjectGeneratedError` with the finish reason `content-filter`. This error occurs when your Zod schema contains incompatible types that OpenAI's structured output feature cannot process.
+When using structured output generation with OpenAI, you may encounter a `NoObjectGeneratedError` with the finish reason `content-filter`. This error occurs when your Zod schema contains incompatible types that OpenAI's structured output feature cannot process.
 
 ```typescript
 // Problematic code - incompatible schema types
-import { generateObject } from 'ai';
+import { generateText, Output } from 'ai';
 import { openai } from '@ai-sdk/openai';
 import { z } from 'zod';
 
-const result = await generateObject({
+const result = await generateText({
   model: openai('gpt-4o-2024-08-06'),
-  schema: z.object({
-    name: z.string().nullish(), // ❌ .nullish() is not supported
-    email: z.string().optional(), // ❌ .optional() is not supported
-    age: z.number().nullable(), // ✅ .nullable() is supported
+  output: Output.object({
+    schema: z.object({
+      name: z.string().nullish(), // ❌ .nullish() is not supported
+      email: z.string().optional(), // ❌ .optional() is not supported
+      age: z.number().nullable(), // ✅ .nullable() is supported
+    }),
   }),
   prompt: 'Generate a user profile',
 });
@@ -38,22 +40,24 @@ OpenAI's structured output generation uses JSON Schema under the hood and has sp
 Replace `.nullish()` and `.optional()` with `.nullable()` in your Zod schemas when using structured output generation with OpenAI models.
 
 ```typescript
-import { generateObject } from 'ai';
+import { generateText, Output } from 'ai';
 import { openai } from '@ai-sdk/openai';
 import { z } from 'zod';
 
 // Correct approach - use .nullable()
-const result = await generateObject({
+const result = await generateText({
   model: openai('gpt-4o-2024-08-06'),
-  schema: z.object({
-    name: z.string().nullable(), // ✅ Use .nullable() instead of .nullish()
-    email: z.string().nullable(), // ✅ Use .nullable() instead of .optional()
-    age: z.number().nullable(),
+  output: Output.object({
+    schema: z.object({
+      name: z.string().nullable(), // ✅ Use .nullable() instead of .nullish()
+      email: z.string().nullable(), // ✅ Use .nullable() instead of .optional()
+      age: z.number().nullable(),
+    }),
   }),
   prompt: 'Generate a user profile',
 });
 
-console.log(result.object);
+console.log(result.output);
 // { name: "John Doe", email: "john@example.com", age: 30 }
 // or { name: null, email: null, age: 25 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "6.0.92",
+  "version": "6.0.94",
   "description": "AI SDK by Vercel - The AI Toolkit for TypeScript and JavaScript",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "@opentelemetry/api": "1.9.0",
-    "@ai-sdk/gateway": "3.0.51",
+    "@ai-sdk/gateway": "3.0.52",
     "@ai-sdk/provider": "3.0.8",
     "@ai-sdk/provider-utils": "4.0.15"
   },

package/src/generate-text/execute-tool-call.ts

@@ -4,12 +4,28 @@ import { assembleOperationName } from '../telemetry/assemble-operation-name';
 import { recordErrorOnSpan, recordSpan } from '../telemetry/record-span';
 import { selectTelemetryAttributes } from '../telemetry/select-telemetry-attributes';
 import { TelemetrySettings } from '../telemetry/telemetry-settings';
+import { now } from '../util/now';
+import {
+  GenerateTextOnToolCallFinishCallback,
+  GenerateTextOnToolCallStartCallback,
+} from './generate-text';
 import { TypedToolCall } from './tool-call';
 import { ToolOutput } from './tool-output';
 import { ToolSet } from './tool-set';
 import { TypedToolResult } from './tool-result';
 import { TypedToolError } from './tool-error';
 
+/**
+ * Executes a single tool call and manages its lifecycle callbacks.
+ *
+ * This function handles the complete tool execution flow:
+ * 1. Invokes `onToolCallStart` callback before execution
+ * 2. Executes the tool's `execute` function with proper context
+ * 3. Handles streaming outputs via `onPreliminaryToolResult`
+ * 4. Invokes `onToolCallFinish` callback with success or error result
+ *
+ * @returns The tool output (result or error), or undefined if the tool has no execute function.
+ */
 export async function executeToolCall<TOOLS extends ToolSet>({
   toolCall,
   tools,
@@ -18,7 +34,11 @@ export async function executeToolCall<TOOLS extends ToolSet>({
   messages,
   abortSignal,
   experimental_context,
+  stepNumber,
+  model,
   onPreliminaryToolResult,
+  onToolCallStart,
+  onToolCallFinish,
 }: {
   toolCall: TypedToolCall<TOOLS>;
   tools: TOOLS | undefined;
@@ -27,7 +47,11 @@ export async function executeToolCall<TOOLS extends ToolSet>({
   messages: ModelMessage[];
   abortSignal: AbortSignal | undefined;
   experimental_context: unknown;
+  stepNumber?: number;
+  model?: { provider: string; modelId: string };
   onPreliminaryToolResult?: (result: TypedToolResult<TOOLS>) => void;
+  onToolCallStart?: GenerateTextOnToolCallStartCallback<TOOLS>;
+  onToolCallFinish?: GenerateTextOnToolCallFinishCallback<TOOLS>;
 }): Promise<ToolOutput<TOOLS> | undefined> {
   const { toolName, toolCallId, input } = toolCall;
   const tool = tools?.[toolName];
@@ -56,6 +80,23 @@ export async function executeToolCall<TOOLS extends ToolSet>({
     fn: async span => {
       let output: unknown;
 
+      try {
+        await onToolCallStart?.({
+          stepNumber,
+          model,
+          toolCall,
+          messages,
+          abortSignal,
+          functionId: telemetry?.functionId,
+          metadata: telemetry?.metadata as Record<string, unknown> | undefined,
+          experimental_context,
+        });
+      } catch (_ignored) {
+        // Errors in callbacks should not break the generation flow.
+      }
+
+      const startTime = now();
+
       try {
         const stream = executeTool({
           execute: tool.execute!.bind(tool),
@@ -81,6 +122,28 @@ export async function executeToolCall<TOOLS extends ToolSet>({
           }
         }
       } catch (error) {
+        const durationMs = now() - startTime;
+
+        try {
+          await onToolCallFinish?.({
+            stepNumber,
+            model,
+            toolCall,
+            messages,
+            abortSignal,
+            success: false,
+            error,
+            durationMs,
+            functionId: telemetry?.functionId,
+            metadata: telemetry?.metadata as
+              | Record<string, unknown>
+              | undefined,
+            experimental_context,
+          });
+        } catch (_ignored) {
+          // Errors in callbacks should not break the generation flow.
+        }
+
         recordErrorOnSpan(span, error);
         return {
           type: 'tool-error',
@@ -95,6 +158,26 @@ export async function executeToolCall<TOOLS extends ToolSet>({
         } as TypedToolError<TOOLS>;
       }
 
+      const durationMs = now() - startTime;
+
+      try {
+        await onToolCallFinish?.({
+          stepNumber,
+          model,
+          toolCall,
+          messages,
+          abortSignal,
+          success: true,
+          output,
+          durationMs,
+          functionId: telemetry?.functionId,
+          metadata: telemetry?.metadata as Record<string, unknown> | undefined,
+          experimental_context,
+        });
+      } catch (_ignored) {
+        // Errors in callbacks should not break the generation flow.
+      }
+
       try {
         span.setAttributes(
           await selectTelemetryAttributes({