ai 7.0.126 → 7.0.128

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.126",
+  "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.102",
-    "@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.104",
-    "@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'];
+};

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

package/src/decide/decision-result.ts

@@ -0,0 +1,39 @@
+import type {
+  Experimental_DecisionModelV4 as DecisionModelV4,
+  Experimental_EvaluationModelV4 as EvaluationModelV4,
+  Experimental_DecisionModelV4Question as DecisionModelV4Question,
+  Experimental_DecisionModelV4Result as DecisionModelV4Result,
+} from '@ai-sdk/provider';
+
+export type DecisionModel = string | DecisionModelV4 | EvaluationModelV4;
+export type DecisionQuestion = DecisionModelV4Question;
+
+export type DecisionAnswer<QUESTION extends DecisionQuestion> =
+  QUESTION extends { type: 'choice'; criteria: infer CRITERIA }
+    ? {
+        type: 'choice';
+        choice: Extract<keyof CRITERIA, string>;
+        probabilities?: Record<Extract<keyof CRITERIA, string>, number>;
+      }
+    : QUESTION extends { type: 'score' }
+      ? { type: 'score'; score: number; probabilities?: Record<string, number> }
+      : { type: 'boolean'; probability: number };
+
+export type DecisionResult<QUESTIONS extends Record<string, DecisionQuestion>> =
+  {
+    readonly answers: {
+      [ID in keyof QUESTIONS]: DecisionAnswer<QUESTIONS[ID]>;
+    };
+    readonly usage: {
+      inputTokens: number | undefined;
+      outputTokens: number | undefined;
+      totalTokens: number | undefined;
+    };
+    readonly warnings: DecisionModelV4Result['warnings'];
+    readonly rounding: DecisionModelV4Result['rounding'];
+    readonly providerMetadata: DecisionModelV4Result['providerMetadata'];
+    readonly response: NonNullable<DecisionModelV4Result['response']> & {
+      timestamp: Date;
+      modelId: string;
+    };
+  };

package/src/decide/index.ts

@@ -0,0 +1,64 @@
+import type { Context } from '@ai-sdk/provider-utils';
+import { decide } from './decide';
+import type {
+  DecideStartEvent,
+  DecideEndEvent,
+  DecisionModelCallStartEvent,
+  DecisionModelCallEndEvent,
+} from './decide-events';
+import type {
+  DecisionModel,
+  DecisionQuestion,
+  DecisionAnswer,
+  DecisionResult,
+} from './decision-result';
+
+export { decide as experimental_decide } from './decide';
+export type {
+  DecideStartEvent as Experimental_DecideStartEvent,
+  DecideEndEvent as Experimental_DecideEndEvent,
+  DecisionModelCallStartEvent as Experimental_DecisionModelCallStartEvent,
+  DecisionModelCallEndEvent as Experimental_DecisionModelCallEndEvent,
+} from './decide-events';
+export type {
+  DecisionModel as Experimental_DecisionModel,
+  DecisionQuestion as Experimental_DecisionQuestion,
+  DecisionAnswer as Experimental_DecisionAnswer,
+  DecisionResult as Experimental_DecisionResult,
+} from './decision-result';
+
+/** @deprecated Use `experimental_decide` instead. */
+export const experimental_evaluate: typeof decide = decide;
+
+/** @deprecated Use `Experimental_DecideStartEvent` instead. */
+export type Experimental_EvaluateStartEvent<
+  RUNTIME_CONTEXT extends Context = Context,
+> = DecideStartEvent<RUNTIME_CONTEXT>;
+
+/** @deprecated Use `Experimental_DecideEndEvent` instead. */
+export type Experimental_EvaluateEndEvent<
+  RUNTIME_CONTEXT extends Context = Context,
+> = DecideEndEvent<RUNTIME_CONTEXT>;
+
+/** @deprecated Use `Experimental_DecisionModelCallStartEvent` instead. */
+export type Experimental_EvaluationModelCallStartEvent =
+  DecisionModelCallStartEvent;
+
+/** @deprecated Use `Experimental_DecisionModelCallEndEvent` instead. */
+export type Experimental_EvaluationModelCallEndEvent =
+  DecisionModelCallEndEvent;
+
+/** @deprecated Use `Experimental_DecisionModel` instead. */
+export type Experimental_EvaluationModel = DecisionModel;
+
+/** @deprecated Use `Experimental_DecisionQuestion` instead. */
+export type Experimental_EvaluationQuestion = DecisionQuestion;
+
+/** @deprecated Use `Experimental_DecisionAnswer` instead. */
+export type Experimental_EvaluationAnswer<QUESTION extends DecisionQuestion> =
+  DecisionAnswer<QUESTION>;
+
+/** @deprecated Use `Experimental_DecisionResult` instead. */
+export type Experimental_EvaluationResult<
+  QUESTIONS extends Record<string, DecisionQuestion>,
+> = DecisionResult<QUESTIONS>;

package/src/{evaluate → decide}/restricted-telemetry-dispatcher.ts

@@ -4,7 +4,7 @@ import { filterIncludedContext } from '../telemetry/filter-included-context';
 import type { TelemetryDispatcher } from '../telemetry/telemetry';
 import type { TelemetryOptions } from '../telemetry/telemetry-options';
 import type { Callback } from '../util/callback';
-import type { EvaluateEndEvent, EvaluateStartEvent } from './evaluate-events';
+import type { DecideEndEvent, DecideStartEvent } from './decide-events';
 
 export function createRestrictedTelemetryDispatcher<
   RUNTIME_CONTEXT extends Context,
@@ -16,18 +16,18 @@ export function createRestrictedTelemetryDispatcher<
   TelemetryDispatcher,
   | 'onStart'
   | 'onEnd'
-  | 'experimental_onEvaluateStart'
-  | 'experimental_onEvaluateEnd'
+  | 'experimental_onDecideStart'
+  | 'experimental_onDecideEnd'
 > & {
-  onStart: Callback<EvaluateStartEvent<RUNTIME_CONTEXT>>;
-  onEnd: Callback<EvaluateEndEvent<RUNTIME_CONTEXT>>;
+  onStart: Callback<DecideStartEvent<RUNTIME_CONTEXT>>;
+  onEnd: Callback<DecideEndEvent<RUNTIME_CONTEXT>>;
 } {
   const dispatcher = createTelemetryDispatcher({ telemetry });
 
   return {
     ...dispatcher,
     onStart: event =>
-      dispatcher.experimental_onEvaluateStart?.({
+      dispatcher.experimental_onDecideStart?.({
         ...event,
         runtimeContext: filterIncludedContext({
           context: event.runtimeContext,
@@ -35,7 +35,7 @@ export function createRestrictedTelemetryDispatcher<
         }),
       }),
     onEnd: event =>
-      dispatcher.experimental_onEvaluateEnd?.({
+      dispatcher.experimental_onDecideEnd?.({
         ...event,
         runtimeContext: filterIncludedContext({
           context: event.runtimeContext,

package/src/{evaluate/validate-evaluation.ts → decide/validate-decision.ts}

@@ -1,7 +1,7 @@
 import {
   InvalidResponseDataError,
-  type Experimental_EvaluationModelV4CallOptions as EvaluationModelV4CallOptions,
-  type Experimental_EvaluationModelV4Result as EvaluationModelV4Result,
+  type Experimental_DecisionModelV4CallOptions as DecisionModelV4CallOptions,
+  type Experimental_DecisionModelV4Result as DecisionModelV4Result,
 } from '@ai-sdk/provider';
 import { InvalidArgumentError } from '../error/invalid-argument-error';
 
@@ -47,10 +47,10 @@ function invalidInput(
   throw new InvalidArgumentError({ parameter, value, message });
 }
 
-export function validateEvaluationInput({
+export function validateDecisionInput({
   state,
   questions,
-}: EvaluationModelV4CallOptions) {
+}: DecisionModelV4CallOptions) {
   if (!isInput(state)) {
     invalidInput(
       'state',
@@ -173,21 +173,21 @@ function validateDistribution(
   }
 }
 
-export function validateEvaluationAnswers({
+export function validateDecisionAnswers({
   questions,
   answers,
   rounding,
 }: {
-  questions: EvaluationModelV4CallOptions['questions'];
+  questions: DecisionModelV4CallOptions['questions'];
   answers: unknown;
-  rounding?: EvaluationModelV4Result['rounding'];
+  rounding?: DecisionModelV4Result['rounding'];
 }) {
   function roundingError(decimals: number | undefined): number {
     if (decimals === undefined) return 0;
     if (!Number.isInteger(decimals) || decimals < 0 || decimals > 15) {
       invalidAnswer(
         answers,
-        'Evaluation rounding decimals must be integers between 0 and 15.',
+        'Decision rounding decimals must be integers between 0 and 15.',
       );
     }
     return 0.5 * 10 ** -decimals;
@@ -197,7 +197,7 @@ export function validateEvaluationAnswers({
   if (!isRecord(answers) || !hasExactKeys(answers, Object.keys(questions))) {
     invalidAnswer(
       answers,
-      'Evaluation must return exactly one answer for every question.',
+      'Decision must return exactly one answer for every question.',
     );
   }