ai 6.0.93 → 6.0.95

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # ai
 
+## 6.0.95
+
+### Patch Changes
+
+- Updated dependencies [73b7e09]
+  - @ai-sdk/gateway@3.0.53
+
+## 6.0.94
+
+### Patch Changes
+
+- Updated dependencies [363fa44]
+  - @ai-sdk/gateway@3.0.52
+
 ## 6.0.93
 
 ### Patch Changes

package/dist/index.js

@@ -1211,7 +1211,7 @@ var import_provider_utils3 = require("@ai-sdk/provider-utils");
 var import_provider_utils4 = require("@ai-sdk/provider-utils");
 
 // src/version.ts
-var VERSION = true ? "6.0.93" : "0.0.0-test";
+var VERSION = true ? "6.0.95" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({

package/dist/index.mjs

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

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.93" : "0.0.0-test";
+var VERSION = true ? "6.0.95" : "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.93" : "0.0.0-test";
+var VERSION = true ? "6.0.95" : "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/02-getting-started/09-coding-agents.mdx

@@ -176,4 +176,4 @@ The `onStepFinish` callback fires after each LLM step and prints any tool result
 - Learn about [Agent Skills](https://agentskills.io/specification) to understand the full skill format.
 - Read the [DevTools reference](/docs/ai-sdk-core/devtools) for a complete list of captured data and configuration options.
 - Explore [Tools and Tool Calling](/docs/ai-sdk-core/tools-and-tool-calling) to build agents that can take real-world actions.
-- Check out the [Add Skills to Your Agent](/docs/guides/agent-skills) cookbook guide for a step-by-step integration walkthrough.
+- Check out the [Add Skills to Your Agent](/cookbook/guides/agent-skills) cookbook guide for a step-by-step integration walkthrough.

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/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',
     },
   ]}

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

@@ -901,7 +901,7 @@ You can use different strategies to repair the tool call:
 
 ```ts
 import { openai } from '@ai-sdk/openai';
-import { generateObject, generateText, NoSuchToolError, tool } from 'ai';
+import { generateText, NoSuchToolError, Output, tool } from 'ai';
 
 const result = await generateText({
   model,
@@ -920,9 +920,9 @@ const result = await generateText({
 
     const tool = tools[toolCall.toolName as keyof typeof tools];
 
-    const { object: repairedArgs } = await generateObject({
+    const { output: repairedArgs } = await generateText({
       model: __MODEL__,
-      schema: tool.inputSchema,
+      output: Output.object({ schema: tool.inputSchema }),
       prompt: [
         `The model tried to call the tool "${toolCall.toolName}"` +
           ` with the following inputs:`,
@@ -942,7 +942,7 @@ const result = await generateText({
 
 ```ts
 import { openai } from '@ai-sdk/openai';
-import { generateObject, generateText, NoSuchToolError, tool } from 'ai';
+import { generateText, NoSuchToolError, tool } from 'ai';
 
 const result = await generateText({
   model,

package/docs/03-ai-sdk-core/20-prompt-engineering.mdx

@@ -33,19 +33,21 @@ Zod expects JavaScript Date objects, but models return dates as strings.
 You can specify and validate the date format using `z.string().datetime()` or `z.string().date()`,
 and then use a Zod transformer to convert the string to a Date object.
 
-```ts highlight="7-10"
-const result = await generateObject({
+```ts highlight="8-11"
+const result = await generateText({
   model: __MODEL__,
-  schema: z.object({
-    events: z.array(
-      z.object({
-        event: z.string(),
-        date: z
-          .string()
-          .date()
-          .transform(value => new Date(value)),
-      }),
-    ),
+  output: Output.object({
+    schema: z.object({
+      events: z.array(
+        z.object({
+          event: z.string(),
+          date: z
+            .string()
+            .date()
+            .transform(value => new Date(value)),
+        }),
+      ),
+    }),
   }),
   prompt: 'List 5 important events from the year 2000.',
 });