ai 7.0.127 → 7.0.128

package/docs/03-ai-sdk-core/{32-evaluation.mdx → 32-decisions.mdx}

@@ -1,24 +1,24 @@
 ---
-title: Evaluation
-description: Evaluate Choice, Score, and Boolean questions against shared state.
+title: Decisions
+description: Decide answers to Choice, Score, and Boolean questions against shared state.
 ---
 
-# Evaluation
+# Decisions
 
-`experimental_evaluate` evaluates named questions against one shared state using
-an evaluation model. State can be a string, JSON object, or JSON array. An array
+`experimental_decide` decides answers to named questions against one shared state using
+a decision model. State can be a string, JSON object, or JSON array. An array
 is one state, not a batch of unrelated inputs.
 
-This API and the evaluation model specification are experimental and may change
-in patch releases. Pass an evaluation model instance, resolve a model through a
+This API and the decision model specification are experimental and may change
+in patch releases. Pass a decision model instance, resolve a model through a
 provider registry, or use a string ID. Strings resolve through Vercel AI Gateway
-unless you configure an evaluation-capable default provider.
+unless you configure a decision-capable default provider.
 
 ```ts
-import { experimental_evaluate, type Experimental_EvaluationModel } from 'ai';
+import { experimental_decide, type Experimental_DecisionModel } from 'ai';
 
-async function triage(model: Experimental_EvaluationModel, message: string) {
-  return experimental_evaluate({
+async function triage(model: Experimental_DecisionModel, message: string) {
+  return experimental_decide({
     model,
     state: { message },
     questions: {
@@ -46,16 +46,16 @@ async function triage(model: Experimental_EvaluationModel, message: string) {
 
 ## Provider models
 
-Use a provider's `evaluationModel` factory:
+Use a provider's `decisionModel` factory:
 
-| Provider    | Example model                                            |
-| ----------- | -------------------------------------------------------- |
-| TypeSafe AI | `typeSafeAi.evaluationModel('jev-latest')`               |
-| OpenAI      | `openai.evaluationModel('gpt-5.6-luna')`                 |
-| Anthropic   | `anthropic.evaluationModel('claude-haiku-4-5-20251001')` |
-| Google      | `google.evaluationModel('gemini-3.5-flash-lite')`        |
+| Provider    | Example model                                          |
+| ----------- | ------------------------------------------------------ |
+| TypeSafe AI | `typeSafeAi.decisionModel('jev-latest')`               |
+| OpenAI      | `openai.decisionModel('gpt-5.6-luna')`                 |
+| Anthropic   | `anthropic.decisionModel('claude-haiku-4-5-20251001')` |
+| Google      | `google.decisionModel('gemini-3.5-flash-lite')`        |
 
-TypeSafe AI's [Jev](https://vercel.com/i/what-is-jev) supplies native Choice, Score, and Boolean evaluations. OpenAI,
+TypeSafe AI's [Jev](https://vercel.com/i/what-is-jev) supplies native Choice, Score, and Boolean decisions. OpenAI,
 Anthropic, and Google adapt structured language-model output for all three types.
 Boolean answers contain prompted estimates of P(true), validated to be finite
 and in `[0, 1]`. These estimates are not guaranteed to be calibrated. Choice and
@@ -63,14 +63,14 @@ Score answers do not include probability distributions. Select a model that
 supports the provider's structured-output API; judge quality against your own
 labeled examples before choosing a model for a task.
 
-The language-model adapters evaluate all questions in one prompt. They do not
+The language-model adapters decide all answers in one prompt. They do not
 provide TypeSafe's native independent-question execution semantics. The example
 model IDs demonstrate API compatibility; they are not benchmark-selected defaults.
 
 Language-model adapters request `reasoning: 'none'` by default. Each provider
 maps this setting to its model's reasoning controls; it does not guarantee that
 every model runs without thinking. To enable reasoning for more demanding
-evaluations, pass the model's supported reasoning settings through
+decisions, pass the model's supported reasoning settings through
 `providerOptions`, which take precedence over this default. For example, use
 `providerOptions: { openai: { reasoningEffort: 'high' } }` with an OpenAI model
 that supports that effort.
@@ -86,22 +86,22 @@ import { openai } from '@ai-sdk/openai';
 import {
   customProvider,
   createProviderRegistry,
-  experimental_evaluate,
+  experimental_decide,
 } from 'ai';
 
 const registry = createProviderRegistry({
   triage: customProvider({
-    evaluationModels: {
-      native: typeSafeAi.evaluationModel('jev-latest'),
-      compact: openai.evaluationModel('gpt-6-luna'),
+    decisionModels: {
+      native: typeSafeAi.decisionModel('jev-latest'),
+      compact: openai.decisionModel('gpt-6-luna'),
     },
     fallbackProvider: typeSafeAi,
   }),
   openai,
 });
 
-const result = await experimental_evaluate({
-  model: registry.evaluationModel('triage:native'),
+const result = await experimental_decide({
+  model: registry.decisionModel('triage:native'),
   state: 'I was charged twice.',
   questions: {
     department: {
@@ -118,10 +118,10 @@ result.answers.department.choice; // 'billing' | 'support'
 Registry IDs use `providerId:modelId`; the `separator` option changes the
 separator. Only the first separator is used, so model IDs can contain it.
 Custom aliases take precedence over a fallback provider. A fallback only resolves
-unknown model IDs; it does not retry failed evaluations or substitute a model
+unknown model IDs; it does not retry failed decisions or substitute a model
 when a question type is unsupported. Registered providers keep their own
 credentials and settings. Registry language/image middleware does not wrap
-evaluation models.
+decision models.
 
 ### Default-provider strings
 
@@ -129,9 +129,9 @@ String IDs use Vercel AI Gateway by default. Configure Gateway authentication
 with `AI_GATEWAY_API_KEY` or Vercel OIDC, then pass a Gateway model ID:
 
 ```ts
-import { experimental_evaluate } from 'ai';
+import { experimental_decide } from 'ai';
 
-const result = await experimental_evaluate({
+const result = await experimental_decide({
   model: 'typesafe-ai/jev',
   state: 'I was charged twice. Please refund the extra charge.',
   questions: {
@@ -149,10 +149,10 @@ provider once at application startup:
 ```ts
 // Using the registry above, expose an alias through a custom provider:
 globalThis.AI_SDK_DEFAULT_PROVIDER = customProvider({
-  evaluationModels: { native: registry.evaluationModel('triage:native') },
+  decisionModels: { native: registry.decisionModel('triage:native') },
 });
 
-const result = await experimental_evaluate({
+const result = await experimental_decide({
   model: 'native',
   state: 'I was charged twice.',
   questions: {
@@ -165,20 +165,20 @@ const result = await experimental_evaluate({
 ```
 
 A direct provider such as `typeSafeAi` can also be the default; then use its
-unprefixed model ID, such as `'jev-latest'`. String values in `evaluationModels`
+unprefixed model ID, such as `'jev-latest'`. String values in `decisionModels`
 also resolve through this global default. Prefer model instances in aliases to
 avoid resolution cycles. Global configuration affects other AI SDK functions
 too; avoid changing it per request in a shared process.
 
-An explicitly configured default provider must expose an `evaluationModel`
+An explicitly configured default provider must expose a `decisionModel`
 method; Gateway is used only when no default provider is configured. Missing
-registry providers throw `NoSuchProviderError`; missing models or evaluation
+registry providers throw `NoSuchProviderError`; missing models or decision
 capabilities throw
-`NoSuchModelError` with `modelType: 'evaluationModel'`. Unsupported model versions
+`NoSuchModelError` with `modelType: 'decisionModel'`. Unsupported model versions
 throw `UnsupportedModelVersionError`, including models returned by registries.
 The stable `ProviderV4` and `ProviderRegistryProvider` interfaces are unchanged;
-keep the inferred registry type, or use `Experimental_EvaluationProviderRegistry`,
-to retain its experimental `evaluationModel` method.
+keep the inferred registry type, or use `Experimental_DecisionProviderRegistry`,
+to retain its experimental `decisionModel` method.
 
 ## Question types
 
@@ -214,7 +214,7 @@ are preserved, never silently normalized.
 Choice and Score distributions are optional. Boolean probability is required:
 `0.98` means a strong yes and `0.02` means a strong no. It is not confidence in
 either outcome. The SDK does not promise calibration across providers. Structured
-language-model adapters prompt the model to estimate P(true); native evaluation providers return
+language-model adapters prompt the model to estimate P(true); native decision providers return
 their API probabilities. Provider-specific confidence statistics belong
 in `providerMetadata`. TypeSafe exposes its separate Choice/Score confidence
 statistic at `result.providerMetadata?.typesafe?.confidence`, keyed by question
@@ -245,34 +245,34 @@ if (result.answers.requestsRefund.probability >= 0.8) {
 
 The model's `supportedQuestionTypes` are checked before calling the provider.
 Any unsupported question fails the entire call with
-`Experimental_EvaluationUnsupportedQuestionTypeError`. Successful calls return
+`Experimental_DecisionUnsupportedQuestionTypeError`. Successful calls return
 an answer for every question; there is no partial success, and Core does not
 substitute models automatically.
 
 Invalid inputs throw `InvalidArgumentError`. Missing answers, mismatched answer
 types, invalid options, scores, or probabilities throw `InvalidResponseDataError`.
 Transient provider failures use the normal retry policy (`maxRetries: 2` by
-default). Use `abortSignal` to cancel evaluation, `headers` for request headers,
+default). Use `abortSignal` to cancel the decisions request, `headers` for request headers,
 and `providerOptions` for provider-specific settings.
 
 The result includes `usage`, `warnings`, `providerMetadata`, and `response`.
 Unknown token counts stay `undefined`; `totalTokens` is available only when both
 input and output counts are known.
 
-For tests, use `Experimental_EvaluationMockModelV4` from `ai/test`.
+For tests, use `Experimental_DecisionMockModelV4` from `ai/test`.
 
 ## Scope and examples
 
-Evaluation currently returns one complete result for one shared state. It does
+`experimental_decide` currently returns one complete result for one shared state. It does
 not stream answers, perform multilabel classification, or batch unrelated
 states. Run separate calls for separate states. Provider support and judgment
 quality depend on the chosen model. Core does not choose another model, but a
 provider can implement routing through its provider options. For example, AI
-Gateway supports conditional evaluation fallbacks under
+Gateway supports conditional decision fallbacks under
 `providerOptions.gateway.models`.
 
 Runnable examples are in
-[`examples/ai-functions/src/evaluate`](https://github.com/vercel/ai/tree/main/examples/ai-functions/src/evaluate),
+[`examples/ai-functions/src/decide`](https://github.com/vercel/ai/tree/main/examples/ai-functions/src/decide),
 including basic examples for TypeSafe, OpenAI, Anthropic, and Google, model
 registries, custom aliases, default-provider strings, and probability-based routing.
 
@@ -281,7 +281,7 @@ registries, custom aliases, default-provider strings, and probability-based rout
 Explore use cases, implementation guides, and a deployable template for using
 Jev from TypeSafe AI with the AI SDK:
 
-- [Jev use cases](https://vercel.com/i/jev-use-cases): Explore ideas for applying evaluation in your application.
-- [Classify, route, and score with Jev and AI SDK](https://vercel.com/kb/guide/typesafe-jev-and-ai-sdk): Learn how to ask typed questions, route answers using probabilities, and test routing logic with a mock evaluation model.
+- [Jev use cases](https://vercel.com/i/jev-use-cases): Explore ideas for applying decisions in your application.
+- [Classify, route, and score with Jev and AI SDK](https://vercel.com/kb/guide/typesafe-jev-and-ai-sdk): Learn how to ask typed questions, route answers using probabilities, and test routing logic with a mock decision model.
 - [Jev and AI SDK form router guide](https://vercel.com/kb/guide/jev-ai-sdk-form-router): Explore form routing with Jev and the AI SDK.
-- [Jev and AI SDK form router template](https://vercel.com/templates/next.js/jev-and-ai-sdk): Deploy a Next.js application that routes form submissions with Jev and uses a language model fallback for uncertain or failed evaluations.
+- [Jev and AI SDK form router template](https://vercel.com/templates/next.js/jev-and-ai-sdk): Deploy a Next.js application that routes form submissions with Jev and uses a language model fallback for uncertain or failed decisions.

package/docs/03-ai-sdk-core/35-image-generation.mdx

@@ -308,7 +308,7 @@ __PROVIDER_IMPORT__;
 const model = wrapImageModel({
   model: __IMAGE_MODEL__,
   middleware: {
-    specificationVersion: 'v3',
+    specificationVersion: 'v4',
     transformParams: async ({ params }) => ({
       ...params,
       size: params.size ?? '1024x1024',

package/docs/03-ai-sdk-core/45-provider-management.mdx

@@ -469,12 +469,12 @@ const result = await streamText({
 
 This simplifies provider usage and makes it easier to switch between providers without changing your model references throughout your codebase.
 
-## Experimental evaluation models
-
-Custom providers accept `evaluationModels` aliases, and registries expose
-`evaluationModel('provider:model')`. These methods return model instances for
-`experimental_evaluate`. Direct string IDs use Gateway by default, or an
-explicitly configured default provider with an `evaluationModel` method. Registry
-middleware for language and image models does not apply to evaluation.
-See [Evaluation](/docs/ai-sdk-core/evaluation#model-aliases-and-registries)
+## Experimental decision models
+
+Custom providers accept `decisionModels` aliases, and registries expose
+`decisionModel('provider:model')`. These methods return model instances for
+`experimental_decide`. Direct string IDs use Gateway by default, or an
+explicitly configured default provider with a `decisionModel` method. Registry
+middleware for language and image models does not apply to decision.
+See [Decisions](/docs/ai-sdk-core/decisions#model-aliases-and-registries)
 for aliases, default-provider configuration, and capability differences.

package/docs/03-ai-sdk-core/60-telemetry.mdx

@@ -114,7 +114,7 @@ const result = await generateText({
 });
 ```
 
-To disable telemetry globally, do not register any telemetry integrations via the `registerTelemetry()` function.
+Not registering integrations with `registerTelemetry()` prevents delivery to globally registered integrations, but does not disable per-call integrations or Node.js tracing-channel subscribers. To disable telemetry events for a call, including tracing-channel events, pass `telemetry: { isEnabled: false }`. Apply this setting to every call if you want to opt out throughout your application.
 
 ## Telemetry Metadata
 
@@ -157,7 +157,7 @@ const result = await generateText({
 });
 ```
 
-In this example, telemetry integrations receive `runtimeContext` as `{ requestId: 'req_abc' }`. Properties set to `false` or omitted are excluded. If `telemetry.includeRuntimeContext` is omitted, no runtime context properties are included. `telemetry.includeRuntimeContext` is supported by `generateText`, `streamText`, `ToolLoopAgent`, `embed`, `embedMany`, `rerank`, and `experimental_evaluate`.
+In this example, telemetry integrations receive `runtimeContext` as `{ requestId: 'req_abc' }`. Properties set to `false` or omitted are excluded. If `telemetry.includeRuntimeContext` is omitted, no runtime context properties are included. `telemetry.includeRuntimeContext` is supported by `generateText`, `streamText`, `ToolLoopAgent`, `embed`, `embedMany`, `rerank`, and `experimental_decide`.
 
 <Note>
   `telemetry.includeRuntimeContext` only filters telemetry integrations,
@@ -354,6 +354,10 @@ class MyIntegration implements Telemetry {
   async onAbort(event) {
     console.log('Stream aborted after', event.steps.length, 'finished steps');
   }
+
+  async onError(event) {
+    console.error('Generation failed:', event.callId, event.error);
+  }
 }
 
 export function myIntegration(): Telemetry {
@@ -415,27 +419,26 @@ export function myIntegration(): Telemetry {
       description: 'Called when an individual reranking model call completes.',
     },
     {
-      name: 'experimental_onEvaluateStart',
-      type: '(event: Experimental_EvaluateStartEvent) => void | PromiseLike<void>',
-      description: 'Called when an experimental evaluation operation begins.',
+      name: 'experimental_onDecideStart',
+      type: '(event: Experimental_DecideStartEvent) => void | PromiseLike<void>',
+      description: 'Called when an experimental decision operation begins.',
     },
     {
-      name: 'experimental_onEvaluationModelCallStart',
-      type: '(event: Experimental_EvaluationModelCallStartEvent) => void | PromiseLike<void>',
+      name: 'experimental_onDecisionModelCallStart',
+      type: '(event: Experimental_DecisionModelCallStartEvent) => void | PromiseLike<void>',
       description:
-        'Called when the logical evaluation model call begins. The call includes any provider retries.',
+        'Called when the logical decision model call begins. The call includes any provider retries.',
     },
     {
-      name: 'experimental_onEvaluationModelCallEnd',
-      type: '(event: Experimental_EvaluationModelCallEndEvent) => void | PromiseLike<void>',
+      name: 'experimental_onDecisionModelCallEnd',
+      type: '(event: Experimental_DecisionModelCallEndEvent) => void | PromiseLike<void>',
       description:
-        'Called when the logical evaluation model call, including any retries, completes.',
+        'Called when the logical decision model call, including any retries, completes.',
     },
     {
-      name: 'experimental_onEvaluateEnd',
-      type: '(event: Experimental_EvaluateEndEvent) => void | PromiseLike<void>',
-      description:
-        'Called when an experimental evaluation operation completes.',
+      name: 'experimental_onDecideEnd',
+      type: '(event: Experimental_DecideEndEvent) => void | PromiseLike<void>',
+      description: 'Called when an experimental decision operation completes.',
     },
     {
       name: 'onEnd',
@@ -449,10 +452,16 @@ export function myIntegration(): Telemetry {
       description:
         'Called when a streaming text generation operation is aborted before it completes.',
     },
+    {
+      name: 'onError',
+      type: '(event: { callId: string; error: unknown }) => void | PromiseLike<void>',
+      description:
+        'Called when an unrecoverable error occurs. The event identifies the operation and contains the thrown value.',
+    },
   ]}
 />
 
-Experimental evaluation events use the four `experimental_*` callbacks above.
+Experimental decision events use the four `experimental_*` callbacks above.
 They are not included in the stable `onStart` and `onEnd` event unions.
 
 The event types for each method are the same as the corresponding [lifecycle callbacks](/docs/ai-sdk-core/lifecycle-callbacks). See the lifecycle callbacks documentation for the full property reference of each event.
@@ -598,30 +607,30 @@ corresponding input/output recording controls. Raw audio is not captured, so
 transcription input and speech output do not populate message attributes with
 audio content or placeholder audio parts.
 
-#### experimental_evaluate
+#### experimental_decide
 
-For `experimental_evaluate`, the integration records two spans with `CLIENT`
-kind: an **`evaluate {modelId}`** root span for the whole operation and one
-**`evaluate {modelId}`** child span for evaluation model work, including
+For `experimental_decide`, the integration records two spans with `CLIENT`
+kind: a **`decide {modelId}`** root span for the whole operation and one
+**`decide {modelId}`** child span for decision model work, including
 retries. Both include the provider and requested model with
-`gen_ai.operation.name: "evaluate"`. Token
-usage is recorded on the child span. When evaluation attributes are enabled,
+`gen_ai.operation.name: "decide"`. Token
+usage is recorded on the child span. When decision attributes are enabled,
 answers are recorded on both spans so the operation span contains its output.
 
-`evaluate` is an AI SDK-defined custom operation name, not a well-known
+`decide` is an AI SDK-defined custom operation name, not a well-known
 OpenTelemetry GenAI operation. OpenTelemetry permits custom operation names
 when no well-known value describes the operation.
 
 OpenTelemetry's `gen_ai.evaluation.result` event describes the result of
 evaluating a GenAI output for quality or other characteristics. In contrast,
-`experimental_evaluate` can evaluate arbitrary JSON state for classification,
+`experimental_decide` can use arbitrary JSON state for classification,
 routing, scoring, and similar tasks. The integration therefore does not emit a
 `gen_ai.evaluation.result` event.
 
-Evaluation state, questions, and answers also do not have applicable GenAI
-semantic-convention attributes. Enable the `experimental_evaluation`
+Decision state, questions, and answers also do not have applicable GenAI
+semantic-convention attributes. Enable the `experimental_decision`
 supplemental option to record them under AI SDK-specific
-`ai.evaluation.*` attributes.
+`ai.decision.*` attributes.
 
 #### GenAI span details
 
@@ -678,10 +687,10 @@ registerTelemetry(
 
 The callback runs when each span is created and receives:
 
-- `spanType`: the type of span being created (`operation`, `step`, `languageModel`, `tool`, `embedding`, `reranking`, or `experimental_evaluation`).
+- `spanType`: the type of span being created (`operation`, `step`, `languageModel`, `tool`, `embedding`, `reranking`, or `experimental_decision`).
 - `operationId`: the AI SDK operation ID for the current call, such as `ai.generateText` or `ai.streamText`.
 - `callId`: the unique ID for the current AI SDK call.
-- `runtimeContext`: the telemetry-filtered runtime context for text generation, embedding, reranking, and evaluation spans. Text generation spans also reflect updates from `prepareStep`.
+- `runtimeContext`: the telemetry-filtered runtime context for text generation, embedding, reranking, and decision spans. Text generation spans also reflect updates from `prepareStep`.
 
 Custom attributes are merged with AI SDK attributes on the span. AI SDK-owned
 attributes take precedence when a custom attribute uses the same key.
@@ -741,7 +750,7 @@ registerTelemetry(
     providerMetadata: true,
     embedding: true,
     reranking: true,
-    experimental_evaluation: true,
+    experimental_decision: true,
     runtimeContext: true,
     headers: true,
     toolChoice: true,
@@ -756,7 +765,7 @@ The available options are:
 - `providerMetadata`: `ai.response.providerMetadata` on operation, step, and model-call spans.
 - `embedding`: embedding inputs and outputs.
 - `reranking`: rerank input documents and ranking output.
-- `experimental_evaluation`: experimental evaluation state, questions, and answers.
+- `experimental_decision`: experimental decision state, questions, and answers.
 - `runtimeContext`: `ai.settings.context.*`.
 - `headers`: `ai.request.headers.*`.
 - `toolChoice`: `ai.prompt.toolChoice`.

package/docs/03-ai-sdk-core/65-lifecycle-callbacks.mdx

@@ -1,12 +1,12 @@
 ---
 title: Lifecycle Callbacks
-description: Observe AI SDK lifecycle events in generateText, streamText, embed, embedMany, rerank, and experimental_evaluate calls
+description: Observe AI SDK lifecycle events in generateText, streamText, embed, embedMany, rerank, and experimental_decide calls
 ---
 
 # Lifecycle Callbacks
 
 Event callbacks let you run your own code at important points in an AI SDK call.
-You can attach them directly to `generateText`, `streamText`, `embed`, `embedMany`, `rerank`, and `experimental_evaluate` calls to observe what happened, record usage, debug multi-step generations, and monitor tool execution.
+You can attach them directly to `generateText`, `streamText`, `embed`, `embedMany`, `rerank`, and `experimental_decide` calls to observe what happened, record usage, debug multi-step generations, and monitor tool execution.
 
 They are especially useful when you want application-specific logic close to the call site:
 
@@ -452,21 +452,20 @@ const result = await generateText({
   ]}
 />
 
-### `experimental_evaluate`
+### `experimental_decide`
 
 <PropertiesTable
   content={[
     {
       name: 'onStart',
-      type: '(event: Experimental_EvaluateStartEvent) => void | Promise<void>',
+      type: '(event: Experimental_DecideStartEvent) => void | Promise<void>',
       description:
-        'Called when the evaluation operation begins, before the evaluation model is called.',
+        'Called when the decision operation begins, before the decision model is called.',
     },
     {
       name: 'onEnd',
-      type: '(event: Experimental_EvaluateEndEvent) => void | Promise<void>',
-      description:
-        'Called when the evaluation operation completes successfully.',
+      type: '(event: Experimental_DecideEndEvent) => void | Promise<void>',
+      description: 'Called when the decision operation completes successfully.',
     },
   ]}
 />
@@ -1174,10 +1173,10 @@ For `embed`, `value` is a single string. For `embedMany`, `value` is an array of
   ]}
 />
 
-### Evaluation Events
+### Decision Events
 
-Evaluation callbacks are experimental. Their exported types are
-`Experimental_EvaluateStartEvent` and `Experimental_EvaluateEndEvent`.
+Decision callbacks are experimental. Their exported types are
+`Experimental_DecideStartEvent` and `Experimental_DecideEndEvent`.
 
 #### onStart
 
@@ -1186,12 +1185,12 @@ Evaluation callbacks are experimental. Their exported types are
     {
       name: 'callId',
       type: 'string',
-      description: 'Unique identifier for this evaluation call.',
+      description: 'Unique identifier for this decision call.',
     },
     {
       name: 'operationId',
-      type: "'ai.evaluate'",
-      description: 'Evaluation operation identifier.',
+      type: "'ai.decide'",
+      description: 'Decision operation identifier.',
     },
     {
       name: 'runtimeContext',
@@ -1201,22 +1200,22 @@ Evaluation callbacks are experimental. Their exported types are
     {
       name: 'provider',
       type: 'string',
-      description: 'Provider identifier for the evaluation model.',
+      description: 'Provider identifier for the decision model.',
     },
     {
       name: 'modelId',
       type: 'string',
-      description: 'Evaluation model identifier.',
+      description: 'Decision model identifier.',
     },
     {
       name: 'state',
       type: 'string | object | array',
-      description: 'Shared state being evaluated.',
+      description: 'Shared state used to make decisions.',
     },
     {
       name: 'questions',
-      type: 'Readonly<Record<string, Experimental_EvaluationQuestion>>',
-      description: 'Questions being evaluated against the shared state.',
+      type: 'Readonly<Record<string, Experimental_DecisionQuestion>>',
+      description: 'Questions to decide against the shared state.',
     },
     {
       name: 'maxRetries',
@@ -1244,18 +1243,18 @@ Includes every `onStart` field plus:
   content={[
     {
       name: 'answers',
-      type: 'Record<string, Experimental_EvaluationAnswer>',
+      type: 'Record<string, Experimental_DecisionAnswer>',
       description: 'Exactly one typed answer per question ID.',
     },
     {
       name: 'usage',
       type: '{ inputTokens: number | undefined; outputTokens: number | undefined; totalTokens: number | undefined }',
-      description: 'Token usage for the evaluation operation.',
+      description: 'Token usage for the decision operation.',
     },
     {
       name: 'warnings',
       type: 'Array<Warning>',
-      description: 'Warnings from the evaluation model.',
+      description: 'Warnings from the decision model.',
     },
     {
       name: 'rounding',

package/docs/03-ai-sdk-harnesses/08-terminal-ui.mdx

@@ -6,8 +6,8 @@ description: Use @ai-sdk/tui with HarnessAgent.
 # Harnesses with Terminal UI
 
 `@ai-sdk/tui` can render harness streams, tool calls, reasoning sections, and
-approval prompts in a terminal. Because `HarnessAgent` requires a session on
-every call, wrap it with a small `AgentTUIAgent` adapter that injects one
+approval prompts in a terminal. Because `HarnessAgent` requires a session for
+`generate` and `stream` calls, wrap it with a small `AgentTUIAgent` adapter that injects one
 session for the lifetime of the terminal UI.
 
 ## Installation

package/docs/06-advanced/09-multistep-interfaces.mdx

@@ -84,7 +84,7 @@ Tool: bookFlight("BA123", "12th December", ["John Doe", "Jane Doe"])
 Model: Your flight has been booked!
 ```
 
-Before the last tool call, the passenger details needed by the `bookFlight` tool are not available in the application context. As a result, the model asks the user to provide the passenger details before proceeding with the booking.
+After `lookupFlight` returns, the passenger details needed by the `bookFlight` tool are not yet available in the application context. The model asks the user for those details; once the user supplies the names, the model can call `bookFlight`.
 
 Looking up passenger information could've been another tool that the model could've called before calling the `bookFlight` tool assuming that the user is logged into the application. This way, the model does not have to ask the user for the passenger details and can proceed with the booking.
 

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

@@ -0,0 +1,74 @@
+---
+title: experimental_decide
+description: Decide answers to typed questions against shared state with a decision model.
+---
+
+# `experimental_decide()`
+
+```ts
+import { experimental_decide } from 'ai';
+```
+
+Decides answers to a nonempty map of `choice`, `score`, and `boolean` questions against one
+state. See [Decisions](/docs/ai-sdk-core/decisions) for examples and semantics.
+
+## Parameters
+
+| Parameter         | Type                                             | Description                                                                                                                               |
+| ----------------- | ------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------- |
+| `model`           | `Experimental_DecisionModel`                     | Required experimental v4 model instance or a string ID resolved by Gateway or an explicitly configured decision-capable default provider. |
+| `state`           | `string \| object \| array`                      | Required JSON-compatible shared state.                                                                                                    |
+| `questions`       | `Record<string, Experimental_DecisionQuestion>`  | Required nonempty question map.                                                                                                           |
+| `maxRetries`      | `number`                                         | Nonnegative integer; defaults to 2.                                                                                                       |
+| `abortSignal`     | `AbortSignal`                                    | Cancels the decisions request.                                                                                                            |
+| `headers`         | `Record<string, string>`                         | Additional HTTP headers.                                                                                                                  |
+| `providerOptions` | `ProviderOptions`                                | Provider-specific options.                                                                                                                |
+| `telemetry`       | `TelemetryOptions`                               | Telemetry configuration, including per-call integrations, input/output recording, and a function ID.                                      |
+| `runtimeContext`  | `Record<string, unknown>`                        | Context available to lifecycle callbacks and selectively included in telemetry with `telemetry.includeRuntimeContext`.                    |
+| `onStart`         | `(event: Experimental_DecideStartEvent) => void` | Called when the decision operation begins.                                                                                                |
+| `onEnd`           | `(event: Experimental_DecideEndEvent) => void`   | Called when the decision operation completes successfully.                                                                                |
+
+See [Lifecycle Callbacks](/docs/ai-sdk-core/lifecycle-callbacks#experimental_decide)
+for the complete `onStart` and `onEnd` event fields.
+
+## Result
+
+Returns `Promise<Experimental_DecisionResult<QUESTIONS>>`:
+
+- `answers`: One typed answer per question ID, with literal Choice option inference.
+- `usage`: `inputTokens`, `outputTokens`, and `totalTokens`, each possibly undefined.
+- `warnings`: Provider warnings, also passed to the SDK warning logger.
+- `rounding`: Optional provider-declared decimal precision for probabilities and scores.
+- `providerMetadata`: Optional provider-specific metadata.
+- `response`: Timestamp, model ID, and optional response ID, headers, and body.
+
+## Provider specification
+
+`Experimental_DecisionModelV4` is exported from `@ai-sdk/provider` and declares
+`specificationVersion: 'v4'`, `provider`, `modelId`, `supportedQuestionTypes`, and
+`doDecide(options)`. Decision models are isolated from stable `ProviderV4`.
+
+The public core types are `Experimental_DecisionModel`,
+`Experimental_DecisionQuestion`, `Experimental_DecisionAnswer`, and
+`Experimental_DecisionResult`. All decision-specific classes use the
+`Decision` prefix, with `Experimental_` aliases at package boundaries.
+
+## Errors
+
+Unsupported types throw `Experimental_DecisionUnsupportedQuestionTypeError`
+before provider I/O. Invalid inputs throw `InvalidArgumentError`; malformed
+answers throw `InvalidResponseDataError`. Invalid answers are not retried.
+Neither partial results nor missing probability synthesis are supported.
+
+## Model resolution
+
+Use `registry.decisionModel('provider:model')` or
+`customProvider({ decisionModels: { alias: model } }).decisionModel('alias')`
+to resolve models. Strings passed directly to `experimental_decide` use
+`globalThis.AI_SDK_DEFAULT_PROVIDER.decisionModel(id)` when a default provider is
+configured, or Gateway when no default provider is configured.
+
+Resolution errors use the existing `NoSuchModelError` and `NoSuchProviderError`
+classes with `modelType: 'decisionModel'`. Model instances and resolved models
+must implement v4; other versions throw `UnsupportedModelVersionError`.
+See [model resolution examples](/docs/ai-sdk-core/decisions#model-aliases-and-registries).