ai 7.0.127 → 7.0.129

package/docs/07-reference/01-ai-sdk-core/66-extract-reasoning-middleware.mdx

@@ -1,11 +1,11 @@
 ---
 title: extractReasoningMiddleware
-description: Middleware that extracts XML-tagged reasoning sections from generated text
+description: Middleware that extracts reasoning sections from generated text using configurable delimiters
 ---
 
 # `extractReasoningMiddleware()`
 
-`extractReasoningMiddleware` is a middleware function that extracts XML-tagged reasoning sections from generated text and exposes them separately from the main text content. This is particularly useful when you want to separate an AI model's reasoning process from its final output.
+`extractReasoningMiddleware` is a middleware function that extracts delimited reasoning sections from generated text and exposes them separately from the main text content. This is particularly useful when you want to separate an AI model's reasoning process from its final output.
 
 ```ts
 import { extractReasoningMiddleware } from 'ai';
@@ -16,6 +16,22 @@ const middleware = extractReasoningMiddleware({
 });
 ```
 
+For models that emit non-XML delimiters, pass literal `opening` and `closing`
+strings. For example, Gemma 4's raw thought-channel output uses a newline in its
+opening delimiter:
+
+```ts
+const middleware = extractReasoningMiddleware({
+  tagName: { opening: '<|channel>thought\n', closing: '<channel|>' },
+});
+```
+
+Custom delimiters must be non-empty. They are matched literally, including
+characters such as `|`, and can span multiple streaming chunks. Empty reasoning
+blocks are removed from the answer text as well. Use this middleware when the
+server returns these markers in text; providers that already return reasoning
+separately do not need it.
+
 ## Import
 
 <Snippet
@@ -31,10 +47,10 @@ const middleware = extractReasoningMiddleware({
   content={[
     {
       name: 'tagName',
-      type: 'string',
+      type: 'string | { opening: string; closing: string }',
       isOptional: false,
       description:
-        'The name of the XML tag to extract reasoning from (without angle brackets)',
+        'An XML tag name without angle brackets (e.g. "think" for <think> / </think>), or an object containing non-empty literal opening and closing delimiters.',
     },
     {
       name: 'separator',
@@ -48,7 +64,7 @@ const middleware = extractReasoningMiddleware({
       type: 'boolean',
       isOptional: true,
       description:
-        'Starts with reasoning tokens. Set to true when the response always starts with reasoning and the initial tag is omitted. Defaults to false.',
+        'Starts with reasoning tokens. Set to true when the response always starts with reasoning and the opening delimiter is omitted. Defaults to false.',
     },
   ]}
 />
@@ -58,9 +74,9 @@ const middleware = extractReasoningMiddleware({
 Returns a middleware object that:
 
 - Processes both streaming and non-streaming responses
-- Extracts content between specified XML tags as reasoning
-- Removes the XML tags and reasoning from the main text
-- Adds a `reasoning` property to the result containing the extracted content
+- Extracts content between the specified delimiters as reasoning
+- Removes the delimiters and reasoning from the main text
+- Emits reasoning content parts separately from text content parts
 - Maintains proper separation between text sections using the specified separator
 
 ### Type Parameters

package/docs/07-reference/02-ai-sdk-ui/32-prune-messages.mdx

@@ -60,7 +60,7 @@ export async function POST(req: Request) {
     },
     {
       name: 'toolCalls',
-      type: `'all' | 'before-last-message' | 'before-last-\${number}-messages' | 'none' | Array<{ type: 'all' | 'before-last-message' | 'before-last-\${number}-messages'; tools?: string[] }>`,
+      type: `'all' | 'before-last-message' | \`before-last-\${number}-messages\` | 'none' | Array<{ type: 'all' | 'before-last-message' | \`before-last-\${number}-messages\`; tools?: string[] }>`,
       description:
         'How to prune tool call/results/approval content. Can specify a strategy string or an array for per-tool fine control. Default: [] (empty array, equivalent to "none").',
     },

package/docs/07-reference/03-ai-sdk-rsc/01-stream-ui.mdx

@@ -517,6 +517,7 @@ To see `streamUI` in action, check out [these examples](#examples).
             {
               name: 'response',
               type: 'Response',
+              isOptional: true,
               description: 'Optional response data.',
               properties: [
                 {

package/docs/07-reference/04-ai-sdk-workflow/01-workflow-agent.mdx

@@ -99,7 +99,7 @@ To see `WorkflowAgent` in action, check out [these examples](#examples).
       type: 'StopCondition | StopCondition[]',
       isOptional: true,
       description:
-        'Default stop condition for the agent loop. When omitted, WorkflowAgent has no maximum step count and continues until natural completion. Use `isStepCount()` to bound execution. Per-stream values override this default.',
+        'Default stop condition for the agent loop. When omitted, generate defaults to 20 steps, while stream has no maximum step count. Use `isStepCount()` to bound execution. Per-call values override this default.',
     },
     {
       name: 'activeTools',
@@ -478,6 +478,43 @@ To see `WorkflowAgent` in action, check out [these examples](#examples).
 
 ## Methods
 
+### `generate()`
+
+Runs the durable agent loop using the model's non-streaming `doGenerate()` method. Model calls and tool execution use the same orchestration as `stream()`.
+
+```ts
+const result = await agent.generate({ prompt: 'Summarize the findings.' });
+console.log(result.text);
+console.log(result.usage);
+```
+
+Accepts `WorkflowAgentGenerateOptions`, sharing prompt/messages, instructions, generation settings, tools and runtime context, preparation, stopping, output, and lifecycle options with `stream()`. It does not accept `writable`, `includeRawChunks`, `experimental_transform`, `sendFinish`, or `preventClose`. Without a configured stop condition, generation stops after at most 20 steps. `stream()` retains its existing unbounded default.
+
+The `include` option accepts `requestBody`, `responseBody`, and `requestMessages` booleans, all defaulting to `false`. Enable them only when the additional request/response data is needed. Response IDs, timestamps, model IDs, headers, and provider metadata are retained when supplied by the model.
+
+#### Returns
+
+Returns `Promise<WorkflowAgentGenerateResult>` with the core [`GenerateTextResult`](/docs/reference/ai-sdk-core/generate-text#returns) semantics:
+
+- `text`, `finishReason`, `rawFinishReason`, and `finalStep` describe the final step.
+- `content`, `files`, `sources`, `warnings`, tool calls, and tool results cover all steps.
+- `usage` and `totalUsage` sum all steps while retaining token details and unknown counts.
+- `responseMessages` includes generated messages, even when `prepareStep` replaces the input history.
+- `output` defaults to text, or follows the constructor/per-call output specification. Reading it throws `NoOutputGeneratedError` when output is unavailable, such as a final `tool-calls` response.
+
+Inside a workflow, `timeout` bounds model calls, including retries and dispatch after suspension. It does not cancel a hook that a tool is waiting on. Use the Workflow runtime’s `run.cancel()` to stop a suspended run. See [deadlines, cancellation, and replay](/docs/agents/workflow-agent#deadlines-cancellation-and-replay).
+
+Generation failures reject. The end callback runs before complete-output parsing; a parsing failure can therefore reject after `onEnd` has run. Existing Workflow callback shapes and preparation precedence apply; they are not all identical to core's callback APIs.
+
+<Note>
+  Use the result API inside workflow code and return selected serializable
+  fields (for example, `text` and `usage`) through `run.returnValue`. Returning
+  the whole result class is not supported. Performance data currently measures
+  the model response; complete tool/step timing is not yet reported.
+</Note>
+
+Approval requests appear in `content` and `responseMessages` without requiring a writable. To continue, append `responseMessages` to the original history and add a tool message containing the user's `tool-approval-response`. Preserve the request signature and tool-call input; use the same `experimental_toolApprovalSecret` environment-variable reference on continuation. Local approvals are validated before execution, and provider-executed approval responses are forwarded to the provider. See [approval round trips](/docs/agents/workflow-agent#approval-round-trips-without-streaming).
+
 ### `stream()`
 
 Runs the agent loop, streaming responses and executing tool calls as needed. Returns a promise resolving to a `WorkflowAgentStreamResult`.
@@ -549,7 +586,7 @@ const result = await agent.stream({
       name: 'timeout',
       type: 'number',
       isOptional: true,
-      description: 'Timeout in milliseconds. Creates an AbortSignal that aborts the operation after the given time.',
+      description: 'Model-call deadline in milliseconds. Inside a workflow, the absolute deadline is checked at dispatch and retry and remains in effect across suspension. It does not cancel a tool waiting on a Workflow hook; use run.cancel() to stop the suspended run.',
     },
     {
       name: 'sendFinish',

package/docs/07-reference/05-ai-sdk-errors/ai-decision-unsupported-question-type-error.mdx

@@ -0,0 +1,31 @@
+---
+title: AI_DecisionUnsupportedQuestionTypeError
+description: Identify a decision question type that a model does not support.
+---
+
+# AI_DecisionUnsupportedQuestionTypeError
+
+This experimental error identifies a question whose type is unsupported by a
+decision model. It is exported from `ai` and `@ai-sdk/provider` as
+`Experimental_DecisionUnsupportedQuestionTypeError`.
+
+## Properties
+
+- `questionId`: The ID of the unsupported question.
+- `questionType`: The requested question type.
+- `provider`: The provider of the decision model.
+- `modelId`: The decision model ID.
+- `message`: A description of the unsupported question and model. Providers can
+  supply a custom message.
+
+## Checking for this Error
+
+Use the marker-based `isInstance` check, which works across package copies:
+
+```typescript
+import { Experimental_DecisionUnsupportedQuestionTypeError as DecisionUnsupportedQuestionTypeError } from 'ai';
+
+if (DecisionUnsupportedQuestionTypeError.isInstance(error)) {
+  console.log(error.questionId, error.questionType, error.modelId);
+}
+```

package/docs/07-reference/05-ai-sdk-errors/ai-no-such-model-error.mdx

@@ -25,6 +25,6 @@ if (NoSuchModelError.isInstance(error)) {
 }
 ```
 
-Experimental evaluation resolution uses `modelType: 'evaluationModel'`. This
-includes unavailable evaluation capabilities and unknown evaluation model or
-provider IDs. See [Evaluation](/docs/ai-sdk-core/evaluation#default-provider-strings).
+Experimental decision resolution uses `modelType: 'decisionModel'`. This
+includes unavailable decision capabilities and unknown decision model or
+provider IDs. See [Decisions](/docs/ai-sdk-core/decisions#default-provider-strings).

package/docs/07-reference/05-ai-sdk-errors/ai-no-such-provider-error.mdx

@@ -27,6 +27,6 @@ if (NoSuchProviderError.isInstance(error)) {
 }
 ```
 
-Experimental evaluation resolution uses `modelType: 'evaluationModel'`. This
-includes unavailable evaluation capabilities and unknown evaluation model or
-provider IDs. See [Evaluation](/docs/ai-sdk-core/evaluation#default-provider-strings).
+Experimental decision resolution uses `modelType: 'decisionModel'`. This
+includes unavailable decision capabilities and unknown decision model or
+provider IDs. See [Decisions](/docs/ai-sdk-core/decisions#default-provider-strings).

package/docs/08-migration-guides/23-migration-guide-7-0.mdx

@@ -1385,7 +1385,7 @@ if (isToolUIPart(part)) {
 
 The deprecated tool result content part of `{ type: 'media' }` has been removed in AI SDK 7.
 
-Use `{ type: 'file-data' }` for all inline file content, including images.
+Use `{ type: 'file', mediaType, data: { type: 'data', data } }` for inline tool-result file content, including images, as described below. The legacy `file-data` variant still works through runtime auto-migration, but is deprecated.
 
 #### Tool Result Content: Migrate Away From `image-*` and `file-*` variants to `file`
 

package/docs/08-migration-guides/29-migration-guide-4-0.mdx

@@ -944,7 +944,7 @@ import { useAssistant } from '@ai-sdk/react';
   code manually.
 </Note>
 
-The `threadId` and `messageId` parameters have been removed from the `AssistantResponse` function.
+The `threadId` and `messageId` properties have been removed from the argument passed to the `AssistantResponse` callback. The initial response options passed to `AssistantResponse` still require both IDs.
 Please use the `threadId` and `messageId` variables from the outer scope instead.
 
 ```ts filename="AI SDK 3.4"

package/docs/09-troubleshooting/05-tool-invocation-missing-result.mdx

@@ -57,14 +57,14 @@ const { messages, sendMessage, addToolOutput } = useChat({
       try {
         const result = await getLocationData();
 
-        // Important: Don't await inside onToolCall to avoid deadlocks
+        // Important: Don't await addToolOutput inside onToolCall to avoid deadlocks
         addToolOutput({
           tool: 'getLocation',
           toolCallId: toolCall.toolCallId,
           output: result,
         });
       } catch (err) {
-        // Important: Don't await inside onToolCall to avoid deadlocks
+        // Important: Don't await addToolOutput inside onToolCall to avoid deadlocks
         addToolOutput({
           tool: 'getLocation',
           toolCallId: toolCall.toolCallId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.127",
+  "version": "7.0.129",
   "type": "module",
   "description": "AI SDK by Vercel - build apps like ChatGPT, Claude, Gemini, and more with a single interface for any model using the Vercel AI Gateway or go direct to OpenAI, Anthropic, Google, or any other model provider.",
   "license": "Apache-2.0",
@@ -42,30 +42,30 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/gateway": "4.0.103",
-    "@ai-sdk/provider": "4.0.21",
-    "@ai-sdk/provider-utils": "5.0.53"
+    "@ai-sdk/gateway": "4.0.105",
+    "@ai-sdk/provider": "4.0.23",
+    "@ai-sdk/provider-utils": "5.0.55"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "5.0.105",
-    "@ai-sdk/deepseek": "3.0.58",
-    "@ai-sdk/google": "4.0.87",
-    "@ai-sdk/groq": "4.0.54",
-    "@ai-sdk/huggingface": "2.0.62",
-    "@ai-sdk/moonshotai": "3.0.62",
-    "@ai-sdk/openai": "4.0.83",
-    "@ai-sdk/test-server": "2.0.3",
-    "@ai-sdk/xai": "5.0.14",
+    "@ai-sdk/amazon-bedrock": "5.0.107",
+    "@ai-sdk/deepseek": "3.0.60",
+    "@ai-sdk/google": "4.0.89",
+    "@ai-sdk/groq": "4.0.56",
+    "@ai-sdk/huggingface": "2.0.64",
+    "@ai-sdk/moonshotai": "3.0.64",
+    "@ai-sdk/openai": "4.0.85",
+    "@ai-sdk/test-server": "2.0.4",
+    "@ai-sdk/xai": "5.0.16",
     "@edge-runtime/vm": "^5.0.0",
     "@smithy/eventstream-codec": "^4.3.3",
     "@smithy/util-utf8": "^4.3.3",
     "@types/json-schema": "7.0.15",
     "@types/node": "22.19.19",
     "@vercel/ai-tsconfig": "0.0.0",
-    "esbuild": "^0.28.1",
+    "esbuild": "^0.28.2",
     "tsdown": "^0.23.0",
     "tsx": "4.23.12",
-    "typescript": "5.8.3",
+    "typescript": "6.0.3",
     "zod": "3.25.76"
   },
   "peerDependencies": {

package/src/decide/decide-events.ts

@@ -0,0 +1,129 @@
+import type {
+  Experimental_DecisionModelV4CallOptions as DecisionModelV4CallOptions,
+  Experimental_DecisionModelV4Result as DecisionModelV4Result,
+} from '@ai-sdk/provider';
+import type { Context, ProviderOptions } from '@ai-sdk/provider-utils';
+import type { DecisionQuestion, DecisionResult } from './decision-result';
+
+/**
+ * Event passed to the `onStart` callback for decision operations.
+ *
+ * Called when the operation begins, before the decision model is called.
+ */
+export type DecideStartEvent<RUNTIME_CONTEXT extends Context = Context> = {
+  /** User-defined runtime context. */
+  readonly runtimeContext: RUNTIME_CONTEXT;
+
+  /** Unique identifier for this decision call, used to correlate events. */
+  readonly callId: string;
+
+  /** Identifies the operation type (`ai.decide`). */
+  readonly operationId: 'ai.decide';
+
+  /** The provider identifier. */
+  readonly provider: string;
+
+  /** The decision model identifier. */
+  readonly modelId: string;
+
+  /** The shared state used to make decisions. */
+  readonly state: DecisionModelV4CallOptions['state'];
+
+  /** The questions to decide against the shared state. */
+  readonly questions: Readonly<Record<string, DecisionQuestion>>;
+
+  /** Maximum number of retries for the decision model call. */
+  readonly maxRetries: number;
+
+  /** Additional HTTP headers sent with the request. */
+  readonly headers: Record<string, string> | undefined;
+
+  /** Additional provider-specific options. */
+  readonly providerOptions: ProviderOptions;
+};
+
+/**
+ * Event passed to the `onEnd` callback for decision operations.
+ *
+ * Called when the operation completes successfully.
+ */
+export type DecideEndEvent<RUNTIME_CONTEXT extends Context = Context> =
+  DecideStartEvent<RUNTIME_CONTEXT> & {
+    /** Exactly one typed answer per question ID. */
+    readonly answers: DecisionResult<
+      Record<string, DecisionQuestion>
+    >['answers'];
+
+    /** Token usage for the decision operation. */
+    readonly usage: DecisionResult<Record<string, DecisionQuestion>>['usage'];
+
+    /** Warnings from the decision model. */
+    readonly warnings: DecisionResult<
+      Record<string, DecisionQuestion>
+    >['warnings'];
+
+    /** Provider-declared decimal precision for probabilities and scores. */
+    readonly rounding: DecisionResult<
+      Record<string, DecisionQuestion>
+    >['rounding'];
+
+    /** Optional provider-specific metadata. */
+    readonly providerMetadata: DecisionResult<
+      Record<string, DecisionQuestion>
+    >['providerMetadata'];
+
+    /** Response metadata, including the resolved model ID and timestamp. */
+    readonly response: DecisionResult<
+      Record<string, DecisionQuestion>
+    >['response'];
+  };
+
+/**
+ * Event fired when the decision model call begins.
+ *
+ * The logical model call includes any provider retries.
+ */
+export type DecisionModelCallStartEvent = {
+  /** Unique identifier for the outer decision call. */
+  readonly callId: string;
+
+  /** Identifies the inner operation (`ai.decide.doDecide`). */
+  readonly operationId: 'ai.decide.doDecide';
+
+  /** The provider identifier. */
+  readonly provider: string;
+
+  /** The decision model identifier. */
+  readonly modelId: string;
+
+  /** The shared state used to make decisions. */
+  readonly state: DecisionModelV4CallOptions['state'];
+
+  /** The questions to decide against the shared state. */
+  readonly questions: Readonly<Record<string, DecisionQuestion>>;
+};
+
+/**
+ * Event fired after the decision model response has been validated.
+ *
+ * Contains the result of the logical model call, including any retries.
+ */
+export type DecisionModelCallEndEvent = DecisionModelCallStartEvent & {
+  /** Exactly one answer per question ID. */
+  readonly answers: DecisionModelV4Result['answers'];
+
+  /** Token usage reported by the decision model. */
+  readonly usage?: DecisionModelV4Result['usage'];
+
+  /** Warnings from the decision model. */
+  readonly warnings: DecisionModelV4Result['warnings'];
+
+  /** Provider-declared decimal precision for probabilities and scores. */
+  readonly rounding?: DecisionModelV4Result['rounding'];
+
+  /** Optional provider-specific metadata. */
+  readonly providerMetadata?: DecisionModelV4Result['providerMetadata'];
+
+  /** Optional raw response metadata from the provider. */
+  readonly response?: DecisionModelV4Result['response'];
+};

package/src/{evaluate/evaluate.ts → decide/decide.ts}

@@ -1,6 +1,6 @@
 import {
-  Experimental_EvaluationUnsupportedQuestionTypeError as EvaluationUnsupportedQuestionTypeError,
-  type Experimental_EvaluationModelV4CallOptions as EvaluationModelV4CallOptions,
+  Experimental_DecisionUnsupportedQuestionTypeError as DecisionUnsupportedQuestionTypeError,
+  type Experimental_DecisionModelV4CallOptions as DecisionModelV4CallOptions,
 } from '@ai-sdk/provider';
 import {
   createIdGenerator,
@@ -8,33 +8,33 @@ import {
   type Context,
   type ProviderOptions,
 } from '@ai-sdk/provider-utils';
-import { resolveEvaluationModel } from '../model/resolve-model';
+import { resolveDecisionModel } from '../model/resolve-model';
 import { logWarnings } from '../logger/log-warnings';
 import type { TelemetryOptions } from '../telemetry/telemetry-options';
 import type { Callback } from '../util/callback';
 import { notify } from '../util/notify';
 import { prepareRetries } from '../util/prepare-retries';
 import { VERSION } from '../version';
-import type { EvaluateEndEvent, EvaluateStartEvent } from './evaluate-events';
+import type { DecideEndEvent, DecideStartEvent } from './decide-events';
 import type {
-  EvaluationModel,
-  EvaluationQuestion,
-  EvaluationResult,
-} from './evaluation-result';
+  DecisionModel,
+  DecisionQuestion,
+  DecisionResult,
+} from './decision-result';
 import { createRestrictedTelemetryDispatcher } from './restricted-telemetry-dispatcher';
 import {
-  validateEvaluationInput,
-  validateEvaluationAnswers,
-} from './validate-evaluation';
+  validateDecisionInput,
+  validateDecisionAnswers,
+} from './validate-decision';
 
 const originalGenerateCallId = createIdGenerator({
   prefix: 'call',
   size: 24,
 });
 
-/** Evaluate typed questions against one shared state. Experimental. */
-export async function evaluate<
-  const QUESTIONS extends Record<string, EvaluationQuestion>,
+/** Decide answers to typed questions against one shared state. Experimental. */
+export async function decide<
+  const QUESTIONS extends Record<string, DecisionQuestion>,
   RUNTIME_CONTEXT extends Context = Context,
 >({
   model: modelArg,
@@ -50,9 +50,9 @@ export async function evaluate<
   onEnd,
   _internal: { generateCallId = originalGenerateCallId } = {},
 }: {
-  /** An evaluation model instance or an ID resolved by the configured default provider. */
-  model: EvaluationModel;
-  state: EvaluationModelV4CallOptions['state'];
+  /** A decision model instance or an ID resolved by the configured default provider. */
+  model: DecisionModel;
+  state: DecisionModelV4CallOptions['state'];
   questions: QUESTIONS;
   /** Maximum retries for transient provider failures. Defaults to 2. */
   maxRetries?: number;
@@ -63,22 +63,22 @@ export async function evaluate<
   telemetry?: TelemetryOptions<RUNTIME_CONTEXT>;
   /** User-defined runtime context. Treat runtime context as immutable. */
   runtimeContext?: RUNTIME_CONTEXT;
-  /** Called when the evaluate operation begins. */
-  onStart?: Callback<EvaluateStartEvent<RUNTIME_CONTEXT>>;
-  /** Called when the evaluate operation completes. */
-  onEnd?: Callback<EvaluateEndEvent<RUNTIME_CONTEXT>>;
+  /** Called when the decide operation begins. */
+  onStart?: Callback<DecideStartEvent<RUNTIME_CONTEXT>>;
+  /** Called when the decide operation completes. */
+  onEnd?: Callback<DecideEndEvent<RUNTIME_CONTEXT>>;
   /** Internal. For test use only. May change without notice. */
   _internal?: {
     generateCallId?: () => string;
   };
-}): Promise<EvaluationResult<QUESTIONS>> {
-  const model = resolveEvaluationModel(modelArg);
+}): Promise<DecisionResult<QUESTIONS>> {
+  const model = resolveDecisionModel(modelArg);
 
-  validateEvaluationInput({ state, questions });
+  validateDecisionInput({ state, questions });
 
   for (const [questionId, question] of Object.entries(questions)) {
     if (!model.supportedQuestionTypes.includes(question.type)) {
-      throw new EvaluationUnsupportedQuestionTypeError({
+      throw new DecisionUnsupportedQuestionTypeError({
         questionId,
         questionType: question.type,
         provider: model.provider,
@@ -101,7 +101,7 @@ export async function evaluate<
       await execute());
   const startEvent = {
     callId,
-    operationId: 'ai.evaluate' as const,
+    operationId: 'ai.decide' as const,
     runtimeContext,
     provider: model.provider,
     modelId: model.modelId,
@@ -112,7 +112,7 @@ export async function evaluate<
     providerOptions,
   };
   return await runInTracingChannelSpan({
-    type: 'experimental_evaluate',
+    type: 'experimental_decide',
     event: startEvent,
     execute: async () => {
       await notify({
@@ -123,7 +123,7 @@ export async function evaluate<
       try {
         const modelCallEvent = {
           callId,
-          operationId: 'ai.evaluate.doEvaluate' as const,
+          operationId: 'ai.decide.doDecide' as const,
           provider: model.provider,
           modelId: model.modelId,
           state,
@@ -132,12 +132,12 @@ export async function evaluate<
         await notify({
           event: modelCallEvent,
           callbacks: [
-            telemetryDispatcher.experimental_onEvaluationModelCallStart,
+            telemetryDispatcher.experimental_onDecisionModelCallStart,
           ],
         });
         const result = await retry(async () => {
           abortSignal?.throwIfAborted();
-          return await model.doEvaluate({
+          return await model.doDecide({
             state,
             questions,
             abortSignal,
@@ -147,16 +147,14 @@ export async function evaluate<
         });
 
         abortSignal?.throwIfAborted();
-        validateEvaluationAnswers({
+        validateDecisionAnswers({
           questions,
           answers: result.answers,
           rounding: result.rounding,
         });
         await notify({
           event: { ...modelCallEvent, ...result },
-          callbacks: [
-            telemetryDispatcher.experimental_onEvaluationModelCallEnd,
-          ],
+          callbacks: [telemetryDispatcher.experimental_onDecisionModelCallEnd],
         });
 
         logWarnings({
@@ -167,8 +165,8 @@ export async function evaluate<
 
         const inputTokens = result.usage?.inputTokens;
         const outputTokens = result.usage?.outputTokens;
-        const evaluationResult: EvaluationResult<QUESTIONS> = {
-          answers: result.answers as EvaluationResult<QUESTIONS>['answers'],
+        const decisionResult: DecisionResult<QUESTIONS> = {
+          answers: result.answers as DecisionResult<QUESTIONS>['answers'],
           usage: {
             inputTokens,
             outputTokens,
@@ -188,11 +186,11 @@ export async function evaluate<
         };
 
         await notify({
-          event: { ...startEvent, ...evaluationResult },
+          event: { ...startEvent, ...decisionResult },
           callbacks: [onEnd, telemetryDispatcher.onEnd],
         });
 
-        return evaluationResult;
+        return decisionResult;
       } catch (error) {
         await telemetryDispatcher.onError?.({ callId, error });
         throw error;

package/src/decide/decision-provider.ts

@@ -0,0 +1,11 @@
+import type {
+  Experimental_DecisionModelV4 as DecisionModelV4,
+  Experimental_EvaluationModelV4 as EvaluationModelV4,
+} from '@ai-sdk/provider';
+
+/** Structural extension; decision is not part of the stable provider contract. */
+export type DecisionProvider = {
+  decisionModel?: (modelId: string) => DecisionModelV4;
+  /** @deprecated Use `decisionModel` instead. */
+  evaluationModel?: (modelId: string) => EvaluationModelV4;
+};