@fondation-io/ai 7.0.0-beta.45

package/docs/02-foundations/04-tools.mdx

@@ -0,0 +1,251 @@
+---
+title: Tools
+description: Learn about tools with the AI SDK.
+---
+
+# Tools
+
+While [large language models (LLMs)](/docs/foundations/overview#large-language-models) have incredible generation capabilities,
+they struggle with discrete tasks (e.g. mathematics) and interacting with the outside world (e.g. getting the weather).
+
+Tools are actions that an LLM can invoke.
+The results of these actions can be reported back to the LLM to be considered in the next response.
+
+For example, when you ask an LLM for the "weather in London", and there is a weather tool available, it could call a tool
+with London as the argument. The tool would then fetch the weather data and return it to the LLM. The LLM can then use this
+information in its response.
+
+## What is a tool?
+
+A tool is an object that can be called by the model to perform a specific task.
+You can use tools with [`generateText`](/docs/reference/ai-sdk-core/generate-text)
+and [`streamText`](/docs/reference/ai-sdk-core/stream-text) by passing one or more tools to the `tools` parameter.
+
+A tool consists of three properties:
+
+- **`description`**: An optional description of the tool that can influence when the tool is picked.
+- **`inputSchema`**: A [Zod schema](/docs/reference/ai-sdk-core/zod-schema) or a [JSON schema](/docs/reference/ai-sdk-core/json-schema) that defines the input required for the tool to run. The schema is consumed by the LLM, and also used to validate the LLM tool calls.
+- **`execute`**: An optional async function that is called with the arguments from the tool call.
+
+<Note>
+  `streamUI` uses UI generator tools with a `generate` function that can return
+  React components.
+</Note>
+
+If the LLM decides to use a tool, it will generate a tool call.
+Tools with an `execute` function are run automatically when these calls are generated.
+The output of the tool calls are returned using tool result objects.
+
+You can automatically pass tool results back to the LLM
+using [multi-step calls](/docs/ai-sdk-core/tools-and-tool-calling#multi-step-calls) with `streamText` and `generateText`.
+
+## Types of Tools
+
+The AI SDK supports three types of tools, each with different trade-offs:
+
+### Custom Tools
+
+Custom tools are tools you define entirely yourself, including the description, input schema, and execute function. They are provider-agnostic and give you full control.
+
+```ts
+import { tool } from 'ai';
+import { z } from 'zod';
+
+const weatherTool = tool({
+  description: 'Get the weather in a location',
+  inputSchema: z.object({
+    location: z.string().describe('The location to get the weather for'),
+  }),
+  execute: async ({ location }) => {
+    // Your implementation
+    return { temperature: 72, conditions: 'sunny' };
+  },
+});
+```
+
+**When to use**: When you need full control, want provider portability, or are implementing application-specific functionality.
+
+### Provider-Defined Tools
+
+Provider-defined tools are tools where the provider specifies the tool's `inputSchema` and `description`, but you provide the `execute` function. These are sometimes called "client tools" because execution happens on your side.
+
+Examples include Anthropic's `bash` and `text_editor` tools. The model has been specifically trained to use these tools effectively, which can result in better performance for supported tasks.
+
+```ts
+import { anthropic } from '@ai-sdk/anthropic';
+import { generateText } from 'ai';
+
+const result = await generateText({
+  model: anthropic('claude-opus-4-5'),
+  tools: {
+    bash: anthropic.tools.bash_20250124({
+      execute: async ({ command }) => {
+        // Your implementation to run the command
+        return runCommand(command);
+      },
+    }),
+  },
+  prompt: 'List files in the current directory',
+});
+```
+
+**When to use**: When the provider offers a tool the model is trained to use well, and you want better performance for that specific task.
+
+### Provider-Executed Tools
+
+Provider-executed tools are tools that run entirely on the provider's servers. You configure them, but the provider handles execution. These are sometimes called "server-side tools".
+
+Examples include OpenAI's web search and Anthropic's code execution. These provide out-of-the-box functionality without requiring you to set up infrastructure.
+
+```ts
+import { openai } from '@ai-sdk/openai';
+import { generateText } from 'ai';
+
+const result = await generateText({
+  model: openai('gpt-5.2'),
+  tools: {
+    web_search: openai.tools.webSearch(),
+  },
+  prompt: 'What happened in the news today?',
+});
+```
+
+**When to use**: When you want powerful functionality (like web search or sandboxed code execution) without managing the infrastructure yourself.
+
+### Comparison
+
+| Aspect             | Custom Tools             | Provider-Defined Tools | Provider-Executed Tools |
+| ------------------ | ------------------------ | ---------------------- | ----------------------- |
+| **Execution**      | Your code                | Your code              | Provider's servers      |
+| **Schema**         | You define               | Provider defines       | Provider defines        |
+| **Portability**    | Works with any provider  | Provider-specific      | Provider-specific       |
+| **Model Training** | General tool use         | Optimized for the tool | Optimized for the tool  |
+| **Setup**          | You implement everything | You implement execute  | Configuration only      |
+
+<Note>
+  Provider-defined and provider-executed tools are documented in each provider's
+  page. See [Anthropic Provider](/providers/ai-sdk-providers/anthropic) and
+  [OpenAI Provider](/providers/ai-sdk-providers/openai) for examples.
+</Note>
+
+## Schemas
+
+Schemas are used to define and validate the [tool input](/docs/ai-sdk-core/tools-and-tool-calling), tools outputs, and structured output generation.
+
+The AI SDK supports the following schemas:
+
+- [Zod](https://zod.dev/) v3 and v4 directly or via [`zodSchema()`](/docs/reference/ai-sdk-core/zod-schema)
+- [Valibot](https://valibot.dev/) via [`valibotSchema()`](/docs/reference/ai-sdk-core/valibot-schema) from `@ai-sdk/valibot`
+- [Standard JSON Schema](https://standardschema.dev/json-schema) compatible schemas
+- Raw JSON schemas via [`jsonSchema()`](/docs/reference/ai-sdk-core/json-schema)
+
+<Note>
+  You can also use schemas for structured output generation with
+  [`generateText`](/docs/reference/ai-sdk-core/generate-text) and
+  [`streamText`](/docs/reference/ai-sdk-core/stream-text) using the `output`
+  setting.
+</Note>
+
+## Tool Packages
+
+Given tools are JavaScript objects, they can be packaged and distributed through npm like any other library. This makes it easy to share reusable tools across projects and with the community.
+
+### Using Ready-Made Tool Packages
+
+Install a tool package and import the tools you need:
+
+```bash
+pnpm add some-tool-package
+```
+
+Then pass them directly to `generateText`, `streamText`, or your agent definition:
+
+```ts highlight="2, 8"
+import { generateText, stepCountIs } from 'ai';
+import { searchTool } from 'some-tool-package';
+
+const { text } = await generateText({
+  model: 'anthropic/claude-haiku-4.5',
+  prompt: 'When was Vercel Ship AI?',
+  tools: {
+    webSearch: searchTool,
+  },
+  stopWhen: stepCountIs(10),
+});
+```
+
+### Publishing Your Own Tools
+
+You can publish your own tool packages to npm for others to use. Simply export your tool objects from your package:
+
+```ts filename="my-tools/index.ts"
+import { tool } from 'ai';
+import { z } from 'zod';
+
+export const myTool = tool({
+  description: 'A helpful tool',
+  inputSchema: z.object({
+    query: z.string(),
+  }),
+  execute: async ({ query }) => {
+    // your tool logic
+    return result;
+  },
+});
+```
+
+Anyone can then install and use your tools by importing them.
+
+To get started, you can use the [AI SDK Tool Package Template](https://github.com/vercel-labs/ai-sdk-tool-as-package-template) which provides a ready-to-use starting point for publishing your own tools.
+
+## Toolsets
+
+When you work with tools, you typically need a mix of application-specific tools and general-purpose tools. The community has created various toolsets and resources to help you build and use tools.
+
+### Ready-to-Use Tool Packages
+
+These packages provide pre-built tools you can install and use immediately:
+
+- **[@exalabs/ai-sdk](https://www.npmjs.com/package/@exalabs/ai-sdk)** - Web search tool that lets AI search the web and get real-time information.
+- **[@parallel-web/ai-sdk-tools](https://www.npmjs.com/package/@parallel-web/ai-sdk-tools)** - Web search and extract tools powered by Parallel Web API for real-time information and content extraction.
+- **[@perplexity-ai/ai-sdk](https://www.npmjs.com/package/@perplexity-ai/ai-sdk)** - Search the web with real-time results and advanced filtering powered by Perplexity's Search API.
+- **[@tavily/ai-sdk](https://www.npmjs.com/package/@tavily/ai-sdk)** - Search, extract, crawl, and map tools for enterprise-grade agents to explore the web in real-time.
+- **[Stripe agent tools](https://docs.stripe.com/agents?framework=vercel)** - Tools for interacting with Stripe.
+- **[StackOne ToolSet](https://docs.stackone.com/agents/typescript/frameworks/vercel-ai-sdk)** - Agentic integrations for hundreds of [enterprise SaaS](https://www.stackone.com/integrations) platforms.
+- **[agentic](https://docs.agentic.so/marketplace/ts-sdks/ai-sdk)** - A collection of 20+ tools that connect to external APIs such as [Exa](https://exa.ai/) or [E2B](https://e2b.dev/).
+- **[Amazon Bedrock AgentCore](https://github.com/aws/bedrock-agentcore-sdk-typescript)** - Fully managed AI agent services including [**Browser**](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/built-in-tools.html) (a fast and secure cloud-based browser runtime to enable agents to interact with web applications, fill forms, navigate websites, and extract information) and [**Code Interpreter**](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/built-in-tools.html) (an isolated sandbox environment for agents to execute code in Python, JavaScript, and TypeScript, enhancing accuracy and expanding ability to solve complex end-to-end tasks).
+- **[@airweave/vercel-ai-sdk](https://www.npmjs.com/package/@airweave/vercel-ai-sdk)** - Unified semantic search across 35+ data sources (Notion, Slack, Google Drive, databases, and more) for AI agents.
+- **[Composio](https://docs.composio.dev/providers/vercel)** - 250+ tools like GitHub, Gmail, Salesforce and [more](https://composio.dev/tools).
+- **[JigsawStack](http://www.jigsawstack.com/docs/integration/vercel)** - Over 30+ small custom fine-tuned models available for specific uses.
+- **[AI Tools Registry](https://ai-tools-registry.vercel.app)** - A Shadcn-compatible tool definitions and components registry for the AI SDK.
+- **[Toolhouse](https://docs.toolhouse.ai/toolhouse/toolhouse-sdk/using-vercel-ai)** - AI function-calling in 3 lines of code for over 25 different actions.
+- **[bash-tool](https://www.npmjs.com/package/bash-tool)** - Provides `bash`, `readFile`, and `writeFile` tools for AI agents. Supports [@vercel/sandbox](https://vercel.com/docs/vercel-sandbox) for full VM isolation.
+
+### MCP Tools
+
+These are pre-built tools available as MCP servers:
+
+- **[Smithery](https://smithery.ai/docs/integrations/vercel_ai_sdk)** - An open marketplace of 6,000+ MCPs, including [Browserbase](https://browserbase.com/) and [Exa](https://exa.ai/).
+- **[Pipedream](https://pipedream.com/docs/connect/mcp/ai-frameworks/vercel-ai-sdk)** - Developer toolkit that lets you easily add 3,000+ integrations to your app or AI agent.
+- **[Apify](https://docs.apify.com/platform/integrations/vercel-ai-sdk)** - Apify provides a [marketplace](https://apify.com/store) of thousands of tools for web scraping, data extraction, and browser automation.
+
+### Tool Building Tutorials
+
+These tutorials and guides help you build your own tools that integrate with specific services:
+
+- **[browserbase](https://docs.browserbase.com/integrations/vercel/introduction#vercel-ai-integration)** - Tutorial for building browser tools that run a headless browser.
+- **[browserless](https://docs.browserless.io/ai-integrations/vercel-ai-sdk)** - Guide for integrating browser automation (self-hosted or cloud-based).
+- **[AI Tool Maker](https://github.com/nihaocami/ai-tool-maker)** - A CLI utility to generate AI SDK tools from OpenAPI specs.
+- **[Interlify](https://www.interlify.com/docs/integrate-with-vercel-ai)** - Guide for converting APIs into tools.
+- **[DeepAgent](https://deepagent.amardeep.space/docs/vercel-ai-sdk)** - A suite of 50+ AI tools and integrations, seamlessly connecting with APIs like Tavily, E2B, Airtable and [more](https://deepagent.amardeep.space/docs).
+
+<Note>
+  Do you have open source tools or tool libraries that are compatible with the
+  AI SDK? Please [file a pull request](https://github.com/vercel/ai/pulls) to
+  add them to this list.
+</Note>
+
+## Learn more
+
+The AI SDK Core [Tool Calling](/docs/ai-sdk-core/tools-and-tool-calling)
+and [Agents](/docs/agents) documentation has more information about tools and tool calling.

package/docs/02-foundations/05-streaming.mdx

@@ -0,0 +1,62 @@
+---
+title: Streaming
+description: Why use streaming for AI applications?
+---
+
+# Streaming
+
+Streaming conversational text UIs (like ChatGPT) have gained massive popularity over the past few months. This section explores the benefits and drawbacks of streaming and blocking interfaces.
+
+[Large language models (LLMs)](/docs/foundations/overview#large-language-models) are extremely powerful. However, when generating long outputs, they can be very slow compared to the latency you're likely used to. If you try to build a traditional blocking UI, your users might easily find themselves staring at loading spinners for 5, 10, even up to 40s waiting for the entire LLM response to be generated. This can lead to a poor user experience, especially in conversational applications like chatbots. Streaming UIs can help mitigate this issue by **displaying parts of the response as they become available**.
+
+<div className="grid lg:grid-cols-2 grid-cols-1 gap-4 mt-8">
+  <Card
+    title="Blocking UI"
+    description="Blocking responses wait until the full response is available before displaying it."
+  >
+    <BrowserIllustration highlight blocking />
+  </Card>
+  <Card
+    title="Streaming UI"
+    description="Streaming responses can transmit parts of the response as they become available."
+  >
+    <BrowserIllustration highlight />
+  </Card>
+</div>
+
+## Real-world Examples
+
+Here are 2 examples that illustrate how streaming UIs can improve user experiences in a real-world setting – the first uses a blocking UI, while the second uses a streaming UI.
+
+### Blocking UI
+
+<InlinePrompt
+  initialInput="Come up with the first 200 characters of the first book in the Harry Potter series."
+  blocking
+/>
+
+### Streaming UI
+
+<InlinePrompt initialInput="Come up with the first 200 characters of the first book in the Harry Potter series." />
+
+As you can see, the streaming UI is able to start displaying the response much faster than the blocking UI. This is because the blocking UI has to wait for the entire response to be generated before it can display anything, while the streaming UI can display parts of the response as they become available.
+
+While streaming interfaces can greatly enhance user experiences, especially with larger language models, they aren't always necessary or beneficial. If you can achieve your desired functionality using a smaller, faster model without resorting to streaming, this route can often lead to simpler and more manageable development processes.
+
+However, regardless of the speed of your model, the AI SDK is designed to make implementing streaming UIs as simple as possible. In the example below, we stream text generation in under 10 lines of code using the SDK's [`streamText`](/docs/reference/ai-sdk-core/stream-text) function:
+
+```ts
+import { streamText } from 'ai';
+__PROVIDER_IMPORT__;
+
+const { textStream } = streamText({
+  model: __MODEL__,
+  prompt: 'Write a poem about embedding models.',
+});
+
+for await (const textPart of textStream) {
+  console.log(textPart);
+}
+```
+
+For an introduction to streaming UIs and the AI SDK, check out our [Getting Started guides](/docs/getting-started).

package/docs/02-foundations/06-provider-options.mdx

@@ -0,0 +1,345 @@
+---
+title: Provider Options
+description: Learn how to use provider-specific options to control reasoning, caching, and other advanced features.
+---
+
+# Provider Options
+
+Provider options let you pass provider-specific configuration that goes beyond the [standard settings](/docs/ai-sdk-core/settings) shared by all providers. They are set via the `providerOptions` property on functions like `generateText` and `streamText`.
+
+```ts
+const result = await generateText({
+  model: openai('gpt-5.2'),
+  prompt: 'Explain quantum entanglement.',
+  providerOptions: {
+    openai: {
+      reasoningEffort: 'low',
+    },
+  },
+});
+```
+
+Provider options are namespaced by the provider name (e.g. `openai`, `anthropic`) so you can even include options for multiple providers in the same call — only the options matching the active provider are used. See [Prompts: Provider Options](/docs/foundations/prompts#provider-options) for details on applying options at the message and message-part level.
+
+<Note>
+  For controlling reasoning effort, consider using the top-level [`reasoning`
+  parameter](/docs/ai-sdk-core/reasoning) instead of provider-specific options.
+  It provides a portable setting that works across all providers that support
+  reasoning. Use provider-specific options only when you need features like
+  exact token budgets.
+</Note>
+
+## Common Provider Options
+
+The sections below cover the most frequently used provider options, focusing on reasoning and output control for OpenAI and Anthropic. For a complete reference, see the individual provider pages:
+
+- [OpenAI provider options](/providers/ai-sdk-providers/openai)
+- [Anthropic provider options](/providers/ai-sdk-providers/anthropic)
+
+---
+
+## OpenAI
+
+### Reasoning Effort
+
+For reasoning models (e.g. `o3`, `o4-mini`, `gpt-5.2`), `reasoningEffort` controls how much internal reasoning the model performs before responding. Lower values are faster and cheaper; higher values produce more thorough answers.
+
+```ts
+import {
+  openai,
+  type OpenAILanguageModelResponsesOptions,
+} from '@ai-sdk/openai';
+import { generateText } from 'ai';
+
+const { text, usage, providerMetadata } = await generateText({
+  model: openai('gpt-5.2'),
+  prompt: 'Invent a new holiday and describe its traditions.',
+  providerOptions: {
+    openai: {
+      reasoningEffort: 'low', // 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh'
+    } satisfies OpenAILanguageModelResponsesOptions,
+  },
+});
+
+console.log('Reasoning tokens:', providerMetadata?.openai?.reasoningTokens);
+```
+
+| Value       | Behavior                                   |
+| ----------- | ------------------------------------------ |
+| `'none'`    | No reasoning (GPT-5.1 models only)         |
+| `'minimal'` | Bare-minimum reasoning                     |
+| `'low'`     | Fast, concise reasoning                    |
+| `'medium'`  | Balanced (default)                         |
+| `'high'`    | Thorough reasoning                         |
+| `'xhigh'`   | Maximum reasoning (GPT-5.1-Codex-Max only) |
+
+<Note>
+  `'none'` and `'xhigh'` are only supported on specific models. Using them with
+  unsupported models will result in an error.
+</Note>
+
+### Reasoning Summary
+
+When working with reasoning models, you may want to see _how_ the model arrived at its answer. The `reasoningSummary` option surfaces the model's thought process.
+
+#### Streaming
+
+```ts
+import {
+  openai,
+  type OpenAILanguageModelResponsesOptions,
+} from '@ai-sdk/openai';
+import { streamText } from 'ai';
+
+const result = streamText({
+  model: openai('gpt-5.2'),
+  prompt: 'Tell me about the Mission burrito debate in San Francisco.',
+  providerOptions: {
+    openai: {
+      reasoningSummary: 'detailed', // 'auto' | 'detailed'
+    } satisfies OpenAILanguageModelResponsesOptions,
+  },
+});
+
+for await (const part of result.fullStream) {
+  if (part.type === 'reasoning') {
+    console.log(`Reasoning: ${part.textDelta}`);
+  } else if (part.type === 'text-delta') {
+    process.stdout.write(part.textDelta);
+  }
+}
+```
+
+#### Non-streaming
+
+```ts
+import {
+  openai,
+  type OpenAILanguageModelResponsesOptions,
+} from '@ai-sdk/openai';
+import { generateText } from 'ai';
+
+const result = await generateText({
+  model: openai('gpt-5.2'),
+  prompt: 'Tell me about the Mission burrito debate in San Francisco.',
+  providerOptions: {
+    openai: {
+      reasoningSummary: 'auto',
+    } satisfies OpenAILanguageModelResponsesOptions,
+  },
+});
+
+console.log('Reasoning:', result.reasoning);
+```
+
+| Value        | Behavior                       |
+| ------------ | ------------------------------ |
+| `'auto'`     | Condensed summary of reasoning |
+| `'detailed'` | Comprehensive reasoning output |
+
+### Text Verbosity
+
+Control the length and detail of the model's text response independently of reasoning:
+
+```ts
+import {
+  openai,
+  type OpenAILanguageModelResponsesOptions,
+} from '@ai-sdk/openai';
+import { generateText } from 'ai';
+
+const result = await generateText({
+  model: openai('gpt-5-mini'),
+  prompt: 'Write a poem about a boy and his first pet dog.',
+  providerOptions: {
+    openai: {
+      textVerbosity: 'low', // 'low' | 'medium' | 'high'
+    } satisfies OpenAILanguageModelResponsesOptions,
+  },
+});
+```
+
+| Value      | Behavior                         |
+| ---------- | -------------------------------- |
+| `'low'`    | Terse, minimal responses         |
+| `'medium'` | Balanced detail (default)        |
+| `'high'`   | Verbose, comprehensive responses |
+
+---
+
+## Anthropic
+
+### Thinking (Extended Reasoning)
+
+Anthropic's thinking feature gives Claude models a dedicated "thinking" phase before they respond. You enable it by providing a `thinking` object with a token budget.
+
+```ts
+import { anthropic, AnthropicLanguageModelOptions } from '@ai-sdk/anthropic';
+import { generateText } from 'ai';
+
+const { text, reasoning, reasoningText } = await generateText({
+  model: anthropic('claude-opus-4-20250514'),
+  prompt: 'How many people will live in the world in 2040?',
+  providerOptions: {
+    anthropic: {
+      thinking: { type: 'enabled', budgetTokens: 12000 },
+    } satisfies AnthropicLanguageModelOptions,
+  },
+});
+
+console.log('Reasoning:', reasoningText);
+console.log('Answer:', text);
+```
+
+The `budgetTokens` value sets the upper limit on how many tokens the model can use for its internal reasoning. Higher budgets allow deeper reasoning but increase latency and cost.
+
+<Note>
+  Thinking is supported on `claude-opus-4-20250514`, `claude-sonnet-4-20250514`,
+  and `claude-sonnet-4-5-20250929` models.
+</Note>
+
+### Effort
+
+The `effort` option provides a simpler way to control reasoning depth without specifying a token budget. It affects thinking, text responses, and function calls.
+
+```ts
+import { anthropic, AnthropicLanguageModelOptions } from '@ai-sdk/anthropic';
+import { generateText } from 'ai';
+
+const { text, usage } = await generateText({
+  model: anthropic('claude-opus-4-20250514'),
+  prompt: 'How many people will live in the world in 2040?',
+  providerOptions: {
+    anthropic: {
+      effort: 'low', // 'low' | 'medium' | 'high'
+    } satisfies AnthropicLanguageModelOptions,
+  },
+});
+```
+
+| Value      | Behavior                             |
+| ---------- | ------------------------------------ |
+| `'low'`    | Minimal reasoning, fastest responses |
+| `'medium'` | Balanced reasoning                   |
+| `'high'`   | Thorough reasoning (default)         |
+
+### Fast Mode
+
+For `claude-opus-4-6`, the `speed` option enables approximately 2.5x faster output token speeds:
+
+```ts
+import { anthropic, AnthropicLanguageModelOptions } from '@ai-sdk/anthropic';
+import { generateText } from 'ai';
+
+const { text } = await generateText({
+  model: anthropic('claude-opus-4-6'),
+  prompt: 'Write a short poem about the sea.',
+  providerOptions: {
+    anthropic: {
+      speed: 'fast', // 'fast' | 'standard'
+    } satisfies AnthropicLanguageModelOptions,
+  },
+});
+```
+
+---
+
+## Combining Options
+
+You can combine multiple provider options in a single call. For example, using both reasoning effort and reasoning summaries with OpenAI:
+
+```ts
+import {
+  openai,
+  type OpenAILanguageModelResponsesOptions,
+} from '@ai-sdk/openai';
+import { generateText } from 'ai';
+
+const result = await generateText({
+  model: openai('gpt-5.2'),
+  prompt: 'What are the implications of quantum computing for cryptography?',
+  providerOptions: {
+    openai: {
+      reasoningEffort: 'high',
+      reasoningSummary: 'detailed',
+    } satisfies OpenAILanguageModelResponsesOptions,
+  },
+});
+```
+
+Or enabling thinking with a low effort level for Anthropic:
+
+```ts
+import { anthropic, AnthropicLanguageModelOptions } from '@ai-sdk/anthropic';
+import { generateText } from 'ai';
+
+const result = await generateText({
+  model: anthropic('claude-opus-4-20250514'),
+  prompt: 'Explain the Riemann hypothesis in simple terms.',
+  providerOptions: {
+    anthropic: {
+      thinking: { type: 'enabled', budgetTokens: 8000 },
+      effort: 'medium',
+    } satisfies AnthropicLanguageModelOptions,
+  },
+});
+```
+
+## Using Provider Options with the AI Gateway
+
+Provider options work the same way when using the [Vercel AI Gateway](/providers/ai-sdk-providers/ai-gateway). Use the underlying provider name (e.g. `openai`, `anthropic`) as the key — not `gateway`. The AI Gateway forwards these options to the target provider automatically.
+
+```ts
+import type { OpenAILanguageModelResponsesOptions } from '@ai-sdk/openai';
+import { generateText } from 'ai';
+
+const result = await generateText({
+  model: 'openai/gpt-5.2', // AI Gateway model string
+  prompt: 'What are the implications of quantum computing for cryptography?',
+  providerOptions: {
+    openai: {
+      reasoningEffort: 'high',
+      reasoningSummary: 'detailed',
+    } satisfies OpenAILanguageModelResponsesOptions,
+  },
+});
+```
+
+You can also combine gateway-specific options (like routing and fallbacks) with provider-specific options in the same call:
+
+```ts
+import type { AnthropicLanguageModelOptions } from '@ai-sdk/anthropic';
+import type { GatewayProviderOptions } from '@ai-sdk/gateway';
+import { generateText } from 'ai';
+
+const result = await generateText({
+  model: 'anthropic/claude-sonnet-4',
+  prompt: 'Explain quantum computing',
+  providerOptions: {
+    // Gateway-specific: control routing
+    gateway: {
+      order: ['vertex', 'anthropic'],
+    } satisfies GatewayProviderOptions,
+    // Provider-specific: enable reasoning
+    anthropic: {
+      thinking: { type: 'enabled', budgetTokens: 12000 },
+    } satisfies AnthropicLanguageModelOptions,
+  },
+});
+```
+
+For more on gateway routing, fallbacks, and other gateway-specific options, see the [AI Gateway provider documentation](/providers/ai-sdk-providers/ai-gateway#provider-options).
+
+## Type Safety
+
+Each provider exports a type for its options, which you can use with `satisfies` to get autocomplete and catch typos at build time:
+
+```ts
+import { type OpenAILanguageModelResponsesOptions } from '@ai-sdk/openai';
+import { type AnthropicLanguageModelOptions } from '@ai-sdk/anthropic';
+```
+
+For a full list of available options, see the provider-specific documentation:
+
+- [OpenAI Provider](/providers/ai-sdk-providers/openai)
+- [Anthropic Provider](/providers/ai-sdk-providers/anthropic)