ai 6.0.92 → 6.0.94

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.92" : "0.0.0-test";
+var VERSION = true ? "6.0.94" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({

package/dist/internal/index.mjs

@@ -132,7 +132,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "6.0.92" : "0.0.0-test";
+var VERSION = true ? "6.0.94" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({

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

@@ -19,7 +19,7 @@ Text prompts are strings.
 They are ideal for simple generation use cases,
 e.g. repeatedly generating content for variants of the same prompt text.
 
-You can set text prompts using the `prompt` property made available by AI SDK functions like [`streamText`](/docs/reference/ai-sdk-core/stream-text) or [`generateObject`](/docs/reference/ai-sdk-core/generate-object).
+You can set text prompts using the `prompt` property made available by AI SDK functions like [`streamText`](/docs/reference/ai-sdk-core/stream-text) or [`generateText`](/docs/reference/ai-sdk-core/generate-text).
 You can structure the text in any way and inject variables, e.g. using a template literal.
 
 ```ts highlight="3"

package/docs/02-getting-started/01-navigating-the-library.mdx

@@ -19,7 +19,7 @@ When deciding which part of the AI SDK to use, your first consideration should b
 
 | Library                                   | Purpose                                                                                                                                                                                                  | Environment Compatibility                                          |
 | ----------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
-| [AI SDK Core](/docs/ai-sdk-core/overview) | Call any LLM with unified API (e.g. [generateText](/docs/reference/ai-sdk-core/generate-text) and [generateObject](/docs/reference/ai-sdk-core/generate-object))                                         | Any JS environment (e.g. Node.js, Deno, Browser)                   |
+| [AI SDK Core](/docs/ai-sdk-core/overview) | Call any LLM with unified API (e.g. [generateText](/docs/reference/ai-sdk-core/generate-text) and [streamText](/docs/reference/ai-sdk-core/stream-text))                                                 | Any JS environment (e.g. Node.js, Deno, Browser)                   |
 | [AI SDK UI](/docs/ai-sdk-ui/overview)     | Build streaming chat and generative UIs (e.g. [useChat](/docs/reference/ai-sdk-ui/use-chat))                                                                                                             | React & Next.js, Vue & Nuxt, Svelte & SvelteKit                    |
 | [AI SDK RSC](/docs/ai-sdk-rsc/overview)   | Stream generative UIs from Server to Client (e.g. [streamUI](/docs/reference/ai-sdk-rsc/stream-ui)). Development is currently experimental and we recommend using [AI SDK UI](/docs/ai-sdk-ui/overview). | Any framework that supports React Server Components (e.g. Next.js) |
 

package/docs/03-agents/02-building-agents.mdx

@@ -331,13 +331,14 @@ export async function POST(request: Request) {
 
 ### Track Step Progress
 
-Use `onStepFinish` to track each step's progress, including token usage:
+Use `onStepFinish` to track each step's progress, including token usage.
+The callback receives a `stepNumber` (zero-based) to identify which step just completed:
 
 ```ts
 const result = await myAgent.generate({
   prompt: 'Research and summarize the latest AI trends',
-  onStepFinish: async ({ usage, finishReason, toolCalls }) => {
-    console.log('Step completed:', {
+  onStepFinish: async ({ stepNumber, usage, finishReason, toolCalls }) => {
+    console.log(`Step ${stepNumber} completed:`, {
       inputTokens: usage.inputTokens,
       outputTokens: usage.outputTokens,
       finishReason,
@@ -352,18 +353,18 @@ You can also define `onStepFinish` in the constructor for agent-wide tracking. W
 ```ts
 const agent = new ToolLoopAgent({
   model: __MODEL__,
-  onStepFinish: async ({ usage }) => {
+  onStepFinish: async ({ stepNumber, usage }) => {
     // Agent-wide logging
-    console.log('Agent step:', usage.totalTokens);
+    console.log(`Agent step ${stepNumber}:`, usage.totalTokens);
   },
 });
 
 // Method-level callback runs after constructor callback
 const result = await agent.generate({
   prompt: 'Hello',
-  onStepFinish: async ({ usage }) => {
+  onStepFinish: async ({ stepNumber, usage }) => {
     // Per-call tracking (e.g., for billing)
-    await trackUsage(usage);
+    await trackUsage(stepNumber, usage);
   },
 });
 ```

package/docs/03-agents/03-workflows.mdx

@@ -40,7 +40,7 @@ These patterns, adapted from [Anthropic's guide on building effective agents](ht
 The simplest workflow pattern executes steps in a predefined order. Each step's output becomes input for the next step, creating a clear chain of operations. Use this pattern for tasks with well-defined sequences, like content generation pipelines or data transformation processes.
 
 ```ts
-import { generateText, generateObject } from 'ai';
+import { generateText, Output } from 'ai';
 __PROVIDER_IMPORT__;
 import { z } from 'zod';
 
@@ -54,12 +54,14 @@ async function generateMarketingCopy(input: string) {
   });
 
   // Perform quality check on copy
-  const { object: qualityMetrics } = await generateObject({
+  const { output: qualityMetrics } = await generateText({
     model,
-    schema: z.object({
-      hasCallToAction: z.boolean(),
-      emotionalAppeal: z.number().min(1).max(10),
-      clarity: z.number().min(1).max(10),
+    output: Output.object({
+      schema: z.object({
+        hasCallToAction: z.boolean(),
+        emotionalAppeal: z.number().min(1).max(10),
+        clarity: z.number().min(1).max(10),
+      }),
     }),
     prompt: `Evaluate this marketing copy for:
     1. Presence of call to action (true/false)
@@ -96,7 +98,7 @@ async function generateMarketingCopy(input: string) {
 This pattern lets the model decide which path to take through a workflow based on context and intermediate results. The model acts as an intelligent router, directing the flow of execution between different branches of your workflow. Use this when handling varied inputs that require different processing approaches. In the example below, the first LLM call's results determine the second call's model size and system prompt.
 
 ```ts
-import { generateObject, generateText } from 'ai';
+import { generateText, Output } from 'ai';
 __PROVIDER_IMPORT__;
 import { z } from 'zod';
 
@@ -104,12 +106,14 @@ async function handleCustomerQuery(query: string) {
   const model = __MODEL__;
 
   // First step: Classify the query type
-  const { object: classification } = await generateObject({
+  const { output: classification } = await generateText({
     model,
-    schema: z.object({
-      reasoning: z.string(),
-      type: z.enum(['general', 'refund', 'technical']),
-      complexity: z.enum(['simple', 'complex']),
+    output: Output.object({
+      schema: z.object({
+        reasoning: z.string(),
+        type: z.enum(['general', 'refund', 'technical']),
+        complexity: z.enum(['simple', 'complex']),
+      }),
     }),
     prompt: `Classify this customer query:
     ${query}
@@ -147,7 +151,7 @@ async function handleCustomerQuery(query: string) {
 Break down tasks into independent subtasks that execute simultaneously. This pattern uses parallel execution to improve efficiency while maintaining the benefits of structured workflows. For example, analyze multiple documents or process different aspects of a single input concurrently (like code review).
 
 ```ts
-import { generateText, generateObject } from 'ai';
+import { generateText, Output } from 'ai';
 __PROVIDER_IMPORT__;
 import { z } from 'zod';
 
@@ -158,40 +162,46 @@ async function parallelCodeReview(code: string) {
   // Run parallel reviews
   const [securityReview, performanceReview, maintainabilityReview] =
     await Promise.all([
-      generateObject({
+      generateText({
         model,
         system:
           'You are an expert in code security. Focus on identifying security vulnerabilities, injection risks, and authentication issues.',
-        schema: z.object({
-          vulnerabilities: z.array(z.string()),
-          riskLevel: z.enum(['low', 'medium', 'high']),
-          suggestions: z.array(z.string()),
+        output: Output.object({
+          schema: z.object({
+            vulnerabilities: z.array(z.string()),
+            riskLevel: z.enum(['low', 'medium', 'high']),
+            suggestions: z.array(z.string()),
+          }),
         }),
         prompt: `Review this code:
       ${code}`,
       }),
 
-      generateObject({
+      generateText({
         model,
         system:
           'You are an expert in code performance. Focus on identifying performance bottlenecks, memory leaks, and optimization opportunities.',
-        schema: z.object({
-          issues: z.array(z.string()),
-          impact: z.enum(['low', 'medium', 'high']),
-          optimizations: z.array(z.string()),
+        output: Output.object({
+          schema: z.object({
+            issues: z.array(z.string()),
+            impact: z.enum(['low', 'medium', 'high']),
+            optimizations: z.array(z.string()),
+          }),
         }),
         prompt: `Review this code:
       ${code}`,
       }),
 
-      generateObject({
+      generateText({
         model,
         system:
           'You are an expert in code quality. Focus on code structure, readability, and adherence to best practices.',
-        schema: z.object({
-          concerns: z.array(z.string()),
-          qualityScore: z.number().min(1).max(10),
-          recommendations: z.array(z.string()),
+        output: Output.object({
+          schema: z.object({
+            concerns: z.array(z.string()),
+            qualityScore: z.number().min(1).max(10),
+            recommendations: z.array(z.string()),
+          }),
         }),
         prompt: `Review this code:
       ${code}`,
@@ -199,9 +209,9 @@ async function parallelCodeReview(code: string) {
     ]);
 
   const reviews = [
-    { ...securityReview.object, type: 'security' },
-    { ...performanceReview.object, type: 'performance' },
-    { ...maintainabilityReview.object, type: 'maintainability' },
+    { ...securityReview.output, type: 'security' },
+    { ...performanceReview.output, type: 'performance' },
+    { ...maintainabilityReview.output, type: 'maintainability' },
   ];
 
   // Aggregate results using another model instance
@@ -221,23 +231,25 @@ async function parallelCodeReview(code: string) {
 A primary model (orchestrator) coordinates the execution of specialized workers. Each worker optimizes for a specific subtask, while the orchestrator maintains overall context and ensures coherent results. This pattern excels at complex tasks requiring different types of expertise or processing.
 
 ```ts
-import { generateObject } from 'ai';
+import { generateText, Output } from 'ai';
 __PROVIDER_IMPORT__;
 import { z } from 'zod';
 
 async function implementFeature(featureRequest: string) {
   // Orchestrator: Plan the implementation
-  const { object: implementationPlan } = await generateObject({
+  const { output: implementationPlan } = await generateText({
     model: __MODEL__,
-    schema: z.object({
-      files: z.array(
-        z.object({
-          purpose: z.string(),
-          filePath: z.string(),
-          changeType: z.enum(['create', 'modify', 'delete']),
-        }),
-      ),
-      estimatedComplexity: z.enum(['low', 'medium', 'high']),
+    output: Output.object({
+      schema: z.object({
+        files: z.array(
+          z.object({
+            purpose: z.string(),
+            filePath: z.string(),
+            changeType: z.enum(['create', 'modify', 'delete']),
+          }),
+        ),
+        estimatedComplexity: z.enum(['low', 'medium', 'high']),
+      }),
     }),
     system:
       'You are a senior software architect planning feature implementations.',
@@ -258,11 +270,13 @@ async function implementFeature(featureRequest: string) {
           'You are an expert at safely removing code while ensuring no breaking changes.',
       }[file.changeType];
 
-      const { object: change } = await generateObject({
+      const { output: change } = await generateText({
         model: __MODEL__,
-        schema: z.object({
-          explanation: z.string(),
-          code: z.string(),
+        output: Output.object({
+          schema: z.object({
+            explanation: z.string(),
+            code: z.string(),
+          }),
         }),
         system: workerSystemPrompt,
         prompt: `Implement the changes for ${file.filePath} to support:
@@ -291,7 +305,7 @@ async function implementFeature(featureRequest: string) {
 Add quality control to workflows with dedicated evaluation steps that assess intermediate results. Based on the evaluation, the workflow proceeds, retries with adjusted parameters, or takes corrective action. This creates robust workflows capable of self-improvement and error recovery.
 
 ```ts
-import { generateText, generateObject } from 'ai';
+import { generateText, Output } from 'ai';
 __PROVIDER_IMPORT__;
 import { z } from 'zod';
 
@@ -313,15 +327,17 @@ async function translateWithFeedback(text: string, targetLanguage: string) {
   // Evaluation-optimization loop
   while (iterations < MAX_ITERATIONS) {
     // Evaluate current translation
-    const { object: evaluation } = await generateObject({
+    const { output: evaluation } = await generateText({
       model: __MODEL__,
-      schema: z.object({
-        qualityScore: z.number().min(1).max(10),
-        preservesTone: z.boolean(),
-        preservesNuance: z.boolean(),
-        culturallyAccurate: z.boolean(),
-        specificIssues: z.array(z.string()),
-        improvementSuggestions: z.array(z.string()),
+      output: Output.object({
+        schema: z.object({
+          qualityScore: z.number().min(1).max(10),
+          preservesTone: z.boolean(),
+          preservesNuance: z.boolean(),
+          culturallyAccurate: z.boolean(),
+          specificIssues: z.array(z.string()),
+          improvementSuggestions: z.array(z.string()),
+        }),
       }),
       system: 'You are an expert in evaluating literary translations.',
       prompt: `Evaluate this translation:

package/docs/03-ai-sdk-core/01-overview.mdx

@@ -23,10 +23,8 @@ These functions take a standardized approach to setting up [prompts](./prompts)
   This function is ideal for non-interactive use cases such as automation tasks where you need to write text (e.g. drafting email or summarizing web pages) and for agents that use tools.
 - [`streamText`](/docs/ai-sdk-core/generating-text): Stream text and tool calls.
   You can use the `streamText` function for interactive use cases such as [chat bots](/docs/ai-sdk-ui/chatbot) and [content streaming](/docs/ai-sdk-ui/completion).
-- [`generateObject`](/docs/ai-sdk-core/generating-structured-data): Generates a typed, structured object that matches a [Zod](https://zod.dev/) schema.
-  You can use this function to force the language model to return structured data, e.g. for information extraction, synthetic data generation, or classification tasks.
-- [`streamObject`](/docs/ai-sdk-core/generating-structured-data): Stream a structured object that matches a Zod schema.
-  You can use this function to [stream generated UIs](/docs/ai-sdk-ui/object-generation).
+
+Both `generateText` and `streamText` support [structured output](/docs/ai-sdk-core/generating-structured-data) via the `output` property (e.g. `Output.object()`, `Output.array()`), allowing you to generate typed, schema-validated data for information extraction, synthetic data generation, classification tasks, and [streaming generated UIs](/docs/ai-sdk-ui/object-generation).
 
 ## API Reference
 

package/docs/03-ai-sdk-core/05-generating-text.mdx

@@ -105,6 +105,60 @@ const result = await generateText({
 });
 ```
 
+### Lifecycle callbacks (experimental)
+
+<Note type="warning">
+  Experimental callbacks are subject to breaking changes in incremental package
+  releases.
+</Note>
+
+`generateText` provides several experimental lifecycle callbacks that let you hook into different phases of the generation process.
+These are useful for logging, observability, debugging, and custom telemetry.
+Errors thrown inside these callbacks are silently caught and do not break the generation flow.
+
+```tsx
+import { generateText } from 'ai';
+__PROVIDER_IMPORT__;
+
+const result = await generateText({
+  model: __MODEL__,
+  prompt: 'What is the weather in San Francisco?',
+  tools: {
+    // ... your tools
+  },
+
+  experimental_onStart({ model, settings, functionId }) {
+    console.log('Generation started', { model, functionId });
+  },
+
+  experimental_onStepStart({ stepNumber, model, promptMessages }) {
+    console.log(`Step ${stepNumber} starting`, { model: model.modelId });
+  },
+
+  experimental_onToolCallStart({ toolName, toolCallId, input }) {
+    console.log(`Tool call starting: ${toolName}`, { toolCallId });
+  },
+
+  experimental_onToolCallFinish({ toolName, durationMs, error }) {
+    console.log(`Tool call finished: ${toolName} (${durationMs}ms)`, {
+      success: !error,
+    });
+  },
+
+  onStepFinish({ stepNumber, finishReason, usage }) {
+    console.log(`Step ${stepNumber} finished`, { finishReason, usage });
+  },
+});
+```
+
+The available lifecycle callbacks are:
+
+- **`experimental_onStart`**: Called once when the `generateText` operation begins, before any LLM calls. Receives model info, prompt, settings, and telemetry metadata.
+- **`experimental_onStepStart`**: Called before each step (LLM call). Receives the step number, model, prompt messages being sent, tools, and prior steps.
+- **`experimental_onToolCallStart`**: Called right before a tool's `execute` function runs. Receives the tool name, call ID, and input.
+- **`experimental_onToolCallFinish`**: Called right after a tool's `execute` function completes or errors. Receives the tool name, call ID, input, output (or undefined on error), error (or undefined on success), and `durationMs`.
+- **`onStepFinish`**: Called after each step finishes. Now also includes `stepNumber` (zero-based index of the completed step).
+
 ## `streamText`
 
 Depending on your model and prompt, it can take a large language model (LLM) up to a minute to finish generating its response. This delay can be unacceptable for interactive use cases such as chatbots or real-time applications, where users expect immediate responses.

package/docs/03-ai-sdk-core/10-generating-structured-data.mdx

@@ -451,190 +451,26 @@ try {
 }
 ```
 
-## generateObject and streamObject (Legacy)
-
-<Note type="warning">
-  `generateObject` and `streamObject` are deprecated. Use `generateText` and
-  `streamText` with the `output` property instead. The legacy functions will be
-  removed in a future major version.
-</Note>
-
-The `generateObject` and `streamObject` functions are the legacy way to generate structured data. They work similarly to `generateText` and `streamText` with `Output.object()`, but as standalone functions.
-
-### generateObject
-
-```ts
-import { generateObject } from 'ai';
-__PROVIDER_IMPORT__;
-import { z } from 'zod';
-
-const { object } = await generateObject({
-  model: __MODEL__,
-  schema: z.object({
-    recipe: z.object({
-      name: z.string(),
-      ingredients: z.array(z.object({ name: z.string(), amount: z.string() })),
-      steps: z.array(z.string()),
-    }),
-  }),
-  prompt: 'Generate a lasagna recipe.',
-});
-```
-
-### streamObject
-
-```ts
-import { streamObject } from 'ai';
-__PROVIDER_IMPORT__;
-import { z } from 'zod';
-
-const { partialObjectStream } = streamObject({
-  model: __MODEL__,
-  schema: z.object({
-    recipe: z.object({
-      name: z.string(),
-      ingredients: z.array(z.object({ name: z.string(), amount: z.string() })),
-      steps: z.array(z.string()),
-    }),
-  }),
-  prompt: 'Generate a lasagna recipe.',
-});
-
-for await (const partialObject of partialObjectStream) {
-  console.log(partialObject);
-}
-```
-
-### Schema Name and Description (Legacy)
-
-You can optionally specify a name and description for the schema. These are used by some providers for additional LLM guidance, e.g. via tool or schema name.
-
-```ts highlight="4-5"
-import { generateObject } from 'ai';
-__PROVIDER_IMPORT__;
-import { z } from 'zod';
-
-const { object } = await generateObject({
-  model: __MODEL__,
-  schemaName: 'Recipe',
-  schemaDescription: 'A recipe for a dish.',
-  schema: z.object({
-    name: z.string(),
-    ingredients: z.array(z.object({ name: z.string(), amount: z.string() })),
-    steps: z.array(z.string()),
-  }),
-  prompt: 'Generate a lasagna recipe.',
-});
-```
-
-### Output Strategy (Legacy)
-
-The legacy functions support different output strategies via the `output` parameter:
-
-#### Array
-
-Generate an array of objects. The schema specifies the shape of an array element.
-
-```ts highlight="7"
-import { streamObject } from 'ai';
-__PROVIDER_IMPORT__;
-import { z } from 'zod';
-
-const { elementStream } = streamObject({
-  model: __MODEL__,
-  output: 'array',
-  schema: z.object({
-    name: z.string(),
-    class: z
-      .string()
-      .describe('Character class, e.g. warrior, mage, or thief.'),
-    description: z.string(),
-  }),
-  prompt: 'Generate 3 hero descriptions for a fantasy role playing game.',
-});
-
-for await (const hero of elementStream) {
-  console.log(hero);
-}
-```
-
-#### Enum
-
-Generate a specific enum value for classification tasks.
-
-```ts highlight="5-6"
-import { generateObject } from 'ai';
-__PROVIDER_IMPORT__;
-
-const { object } = await generateObject({
-  model: __MODEL__,
-  output: 'enum',
-  enum: ['action', 'comedy', 'drama', 'horror', 'sci-fi'],
-  prompt:
-    'Classify the genre of this movie plot: ' +
-    '"A group of astronauts travel through a wormhole in search of a ' +
-    'new habitable planet for humanity."',
-});
-```
-
-#### No Schema
-
-Generate unstructured JSON without a schema.
-
-```ts highlight="6"
-import { generateObject } from 'ai';
-__PROVIDER_IMPORT__;
-
-const { object } = await generateObject({
-  model: __MODEL__,
-  output: 'no-schema',
-  prompt: 'Generate a lasagna recipe.',
-});
-```
-
-### Repairing Invalid JSON (Legacy)
-
-<Note type="warning">
-  The `repairText` function is experimental and may change in the future.
-</Note>
-
-Sometimes the model will generate invalid or malformed JSON.
-You can use the `repairText` function to attempt to repair the JSON.
-
-```ts highlight="7-10"
-import { generateObject } from 'ai';
-
-const { object } = await generateObject({
-  model,
-  schema,
-  prompt,
-  experimental_repairText: async ({ text, error }) => {
-    // example: add a closing brace to the text
-    return text + '}';
-  },
-});
-```
-
 ## More Examples
 
-You can see `generateObject` and `streamObject` in action using various frameworks in the following examples:
+You can see structured output generation in action using various frameworks in the following examples:
 
-### `generateObject`
+### `generateText` with Output
 
 <ExampleLinks
   examples={[
     {
-      title: 'Learn to generate objects in Node.js',
+      title: 'Learn to generate structured data in Node.js',
       link: '/examples/node/generating-structured-data/generate-object',
     },
     {
       title:
-        'Learn to generate objects in Next.js with Route Handlers (AI SDK UI)',
+        'Learn to generate structured data in Next.js with Route Handlers (AI SDK UI)',
       link: '/examples/next-pages/basics/generating-object',
     },
     {
       title:
-        'Learn to generate objects in Next.js with Server Actions (AI SDK RSC)',
+        'Learn to generate structured data in Next.js with Server Actions (AI SDK RSC)',
       link: '/examples/next-app/basics/generating-object',
     },
   ]}
@@ -645,17 +481,17 @@ You can see `generateObject` and `streamObject` in action using various framewor
 <ExampleLinks
   examples={[
     {
-      title: 'Learn to stream objects in Node.js',
+      title: 'Learn to stream structured data in Node.js',
       link: '/examples/node/streaming-structured-data/stream-object',
     },
     {
       title:
-        'Learn to stream objects in Next.js with Route Handlers (AI SDK UI)',
+        'Learn to stream structured data in Next.js with Route Handlers (AI SDK UI)',
       link: '/examples/next-pages/basics/streaming-object-generation',
     },
     {
       title:
-        'Learn to stream objects in Next.js with Server Actions (AI SDK RSC)',
+        'Learn to stream structured data in Next.js with Server Actions (AI SDK RSC)',
       link: '/examples/next-app/basics/streaming-object-generation',
     },
   ]}