ai 7.0.127 → 7.0.128

package/docs/07-reference/01-ai-sdk-core/23-create-mcp-client.mdx

@@ -368,11 +368,24 @@ Returns a Promise that resolves to an `MCPClient` with the following properties
                 'Tool definitions, typically returned by `listTools`.',
             },
             {
-              name: 'schemas',
-              type: 'TOOL_SCHEMAS',
+              name: 'options',
+              type: '{ schemas?: TOOL_SCHEMAS }',
               isOptional: true,
-              description:
-                'Optional schema definitions for compile-time type checking and typed outputs.',
+              description: 'Options for converting the tool definitions.',
+              properties: [
+                {
+                  type: 'options',
+                  parameters: [
+                    {
+                      name: 'schemas',
+                      type: 'TOOL_SCHEMAS',
+                      isOptional: true,
+                      description:
+                        'Optional schema definitions for compile-time type checking and typed outputs.',
+                    },
+                  ],
+                },
+              ],
             },
           ],
         },
@@ -641,6 +654,47 @@ The client throws `MCPClientError` for:
 - Missing server capabilities
 - Connection failures
 
+Import `MCPClientError` from `@ai-sdk/mcp` and use its `isInstance` method to
+safely narrow unknown errors:
+
+```typescript
+import { createMCPClient, MCPClientError } from '@ai-sdk/mcp';
+
+try {
+  await createMCPClient({
+    transport: {
+      type: 'http',
+      url: 'https://your-server.com/mcp',
+    },
+  });
+} catch (error) {
+  if (MCPClientError.isInstance(error)) {
+    if (error.statusCode === 401 || error.statusCode === 403) {
+      // Authentication or authorization must be fixed before retrying.
+      throw error;
+    }
+
+    // Inspect error.code and error.statusCode according to your application's policy.
+  }
+
+  throw error;
+}
+```
+
+The error exposes the optional `code`, `statusCode`, `url`, and `responseBody`
+properties. `code` is the JSON-RPC application error code. `statusCode`, `url`,
+and `responseBody` contain HTTP transport context when it is available. They
+are `undefined` for failures without an HTTP response, such as network errors,
+timeouts, aborted requests, and stdio transport failures.
+
+`MCPClientError` also represents configuration and protocol errors, so its
+type or a missing `statusCode` alone does not indicate a retryable failure.
+OAuth failures can instead throw the separately exported `UnauthorizedError`
+or `MCPClientOAuthError`.
+
+Avoid logging `url` or `responseBody` without redacting sensitive endpoint,
+query parameter, or server response data.
+
 For tool execution, errors are propagated as `CallToolError` errors.
 
 For unknown errors, the client exposes an `onUncaughtError` callback that can be used to manually log or handle errors that are not covered by known error types.

package/docs/07-reference/01-ai-sdk-core/40-provider-registry.mdx

@@ -299,20 +299,20 @@ The `createProviderRegistry` function returns a `Provider` instance. It has the
   ]}
 />
 
-## Experimental evaluation models
+## Experimental decision models
 
-The inferred return type also exposes `evaluationModel('providerId:modelId')`,
-returning `Experimental_EvaluationModelV4`. The provider must expose an
-`evaluationModel` factory. Custom separators and model ID
+The inferred return type also exposes `decisionModel('providerId:modelId')`,
+returning `Experimental_DecisionModelV4`. The provider must expose an
+`decisionModel` factory. Custom separators and model ID
 inference work as they do for video models. Language and image middleware do not
-wrap evaluation models. `ProviderRegistryProvider` remains a stable interface;
-use the inferred return type or `Experimental_EvaluationProviderRegistry` to
-retain experimental evaluation access.
+wrap decision models. `ProviderRegistryProvider` remains a stable interface;
+use the inferred return type or `Experimental_DecisionProviderRegistry` to
+retain experimental decision access.
 
-Unavailable evaluation capabilities or models throw `NoSuchModelError` with
-`modelType: 'evaluationModel'`; unknown registry providers throw
+Unavailable decision capabilities or models throw `NoSuchModelError` with
+`modelType: 'decisionModel'`; unknown registry providers throw
 `NoSuchProviderError`. These capabilities are structural extensions and are not
-added to the stable `ProviderV4` contract. Direct evaluation string IDs default
+added to the stable `ProviderV4` contract. Direct decision string IDs default
 to Gateway when no default provider is configured.
-See [Evaluation](/docs/ai-sdk-core/evaluation#model-aliases-and-registries)
+See [Decisions](/docs/ai-sdk-core/decisions#model-aliases-and-registries)
 for runnable usage patterns.

package/docs/07-reference/01-ai-sdk-core/42-custom-provider.mdx

@@ -202,20 +202,20 @@ The `customProvider` function returns a `Provider` instance. It has the followin
   ]}
 />
 
-## Experimental evaluation models
+## Experimental decision models
 
-Pass `evaluationModels: Record<string, Experimental_EvaluationModel>` to define
-aliases for evaluation model instances or string IDs. The returned provider adds
-`evaluationModel(alias): Experimental_EvaluationModelV4`. String aliases resolve
+Pass `decisionModels: Record<string, Experimental_DecisionModel>` to define
+aliases for decision model instances or string IDs. The returned provider adds
+`decisionModel(alias): Experimental_DecisionModelV4`. String aliases resolve
 through Gateway by default, or an explicitly configured default provider with
-an `evaluationModel` method. Unknown aliases use the fallback provider's evaluation
+a `decisionModel` method. Unknown aliases use the fallback provider's decision
 factory when available; model failures and unsupported questions do not trigger
 substitution.
 
-Unavailable evaluation capabilities or models throw `NoSuchModelError` with
-`modelType: 'evaluationModel'`; unknown registry providers throw
+Unavailable decision capabilities or models throw `NoSuchModelError` with
+`modelType: 'decisionModel'`; unknown registry providers throw
 `NoSuchProviderError`. These capabilities are structural extensions and are not
-added to the stable `ProviderV4` contract. Direct evaluation string IDs default
+added to the stable `ProviderV4` contract. Direct decision string IDs default
 to Gateway when no default provider is configured.
-See [Evaluation](/docs/ai-sdk-core/evaluation#model-aliases-and-registries)
+See [Decisions](/docs/ai-sdk-core/decisions#model-aliases-and-registries)
 for runnable usage patterns.

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.128",
   "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,20 +42,20 @@
     }
   },
   "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.104",
+    "@ai-sdk/provider": "4.0.22",
+    "@ai-sdk/provider-utils": "5.0.54"
   },
   "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/amazon-bedrock": "5.0.106",
+    "@ai-sdk/deepseek": "3.0.59",
+    "@ai-sdk/google": "4.0.88",
+    "@ai-sdk/groq": "4.0.55",
+    "@ai-sdk/huggingface": "2.0.63",
+    "@ai-sdk/moonshotai": "3.0.63",
+    "@ai-sdk/openai": "4.0.84",
     "@ai-sdk/test-server": "2.0.3",
-    "@ai-sdk/xai": "5.0.14",
+    "@ai-sdk/xai": "5.0.15",
     "@edge-runtime/vm": "^5.0.0",
     "@smithy/eventstream-codec": "^4.3.3",
     "@smithy/util-utf8": "^4.3.3",

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'];
+};