ai 7.0.127 → 7.0.128

package/src/registry/provider-registry.ts

@@ -1,5 +1,5 @@
 import {
-  type Experimental_EvaluationModelV4 as EvaluationModelV4,
+  type Experimental_DecisionModelV4 as DecisionModelV4,
   type EmbeddingModelV4,
   type Experimental_VideoModelV3,
   type Experimental_VideoModelV4,
@@ -14,8 +14,12 @@ import {
   type SpeechModelV4,
   type TranscriptionModelV4,
 } from '@ai-sdk/provider';
-import type { EvaluationProvider } from '../evaluate/evaluation-provider';
-import { resolveEvaluationModel } from '../model/resolve-model';
+import type { DecisionModel } from '../decide/decision-result';
+import type { DecisionProvider } from '../decide/decision-provider';
+import {
+  resolveDecisionModel,
+  asEvaluationModel,
+} from '../model/resolve-model';
 import { wrapImageModel } from '../middleware/wrap-image-model';
 import { wrapLanguageModel } from '../middleware/wrap-language-model';
 import { asProviderV4 } from '../model/as-provider-v4';
@@ -38,7 +42,7 @@ type RegistryModelType =
   | 'speechModel'
   | 'rerankingModel'
   | 'videoModel'
-  | 'evaluationModel';
+  | 'decisionModel';
 
 type ProviderVideoModelIdentifier<PROVIDER> = PROVIDER extends {
   videoModel: (...args: infer ARGS) => unknown;
@@ -46,28 +50,40 @@ type ProviderVideoModelIdentifier<PROVIDER> = PROVIDER extends {
   ? ExtractLiteralUnion<ARGS[0]>
   : never;
 
-type ProviderEvaluationModelIdentifier<PROVIDER> = PROVIDER extends {
-  evaluationModel: (...args: infer ARGS) => unknown;
+type ProviderDecisionModelIdentifier<PROVIDER> = PROVIDER extends {
+  decisionModel: (...args: infer ARGS) => unknown;
 }
   ? ExtractLiteralUnion<ARGS[0]>
-  : never;
+  : PROVIDER extends { evaluationModel: (...args: infer ARGS) => unknown }
+    ? ExtractLiteralUnion<ARGS[0]>
+    : never;
 
-/** Registry with experimental evaluation access, separate from the stable interface. */
-export type EvaluationProviderRegistry<
+/** Registry with experimental decision access, separate from the stable interface. */
+export type DecisionProviderRegistry<
   PROVIDERS extends Record<string, ProviderV4 | ProviderV3> = Record<
     string,
     ProviderV4 | ProviderV3
   >,
   SEPARATOR extends string = ':',
 > = ProviderRegistryProvider<PROVIDERS, SEPARATOR> & {
+  decisionModel<KEY extends keyof PROVIDERS>(
+    id: KEY extends string
+      ? `${KEY & string}${SEPARATOR}${ProviderDecisionModelIdentifier<PROVIDERS[KEY]>}`
+      : never,
+  ): DecisionModelV4;
+  decisionModel<KEY extends keyof PROVIDERS>(
+    id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never,
+  ): DecisionModelV4;
+  /** @deprecated Use `decisionModel` instead. */
   evaluationModel<KEY extends keyof PROVIDERS>(
     id: KEY extends string
-      ? `${KEY & string}${SEPARATOR}${ProviderEvaluationModelIdentifier<PROVIDERS[KEY]>}`
+      ? `${KEY & string}${SEPARATOR}${ProviderDecisionModelIdentifier<PROVIDERS[KEY]>}`
       : never,
-  ): EvaluationModelV4;
+  ): DecisionModelV4 & { doEvaluate: DecisionModelV4['doDecide'] };
+  /** @deprecated Use `decisionModel` instead. */
   evaluationModel<KEY extends keyof PROVIDERS>(
     id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never,
-  ): EvaluationModelV4;
+  ): DecisionModelV4 & { doEvaluate: DecisionModelV4['doDecide'] };
 };
 
 export interface ProviderRegistryProvider<
@@ -178,7 +194,7 @@ export function createProviderRegistry<
       | LanguageModelMiddleware[];
     imageModelMiddleware?: ImageModelMiddleware | ImageModelMiddleware[];
   } = {},
-): EvaluationProviderRegistry<PROVIDERS, SEPARATOR> {
+): DecisionProviderRegistry<PROVIDERS, SEPARATOR> {
   const registry = new DefaultProviderRegistry<PROVIDERS, SEPARATOR>({
     separator,
     languageModelMiddleware,
@@ -206,12 +222,12 @@ class DefaultProviderRegistry<
 >
   implements
     ProviderRegistryProvider<PROVIDERS, SEPARATOR>,
-    EvaluationProviderRegistry<PROVIDERS, SEPARATOR>
+    DecisionProviderRegistry<PROVIDERS, SEPARATOR>
 {
   private providers: Partial<
     Record<
       keyof PROVIDERS,
-      ProviderV4 & ProviderWithOptionalVideoModel & EvaluationProvider
+      ProviderV4 & ProviderWithOptionalVideoModel & DecisionProvider
     >
   > = Object.create(null);
   private separator: SEPARATOR;
@@ -248,9 +264,10 @@ class DefaultProviderRegistry<
       provider as ProviderWithOptionalVideoModel
     ).videoModel?.bind(provider);
 
-    const evaluationModel = (
-      provider as EvaluationProvider
-    ).evaluationModel?.bind(provider);
+    const decisionProvider = provider as DecisionProvider;
+    const decisionModel = (
+      decisionProvider.decisionModel ?? decisionProvider.evaluationModel
+    )?.bind(provider);
 
     const registeredProvider =
       videoModel == null
@@ -261,9 +278,9 @@ class DefaultProviderRegistry<
               asVideoModelV4(videoModel(modelId)),
           });
 
-    // Keep v4 instances intact. Adapted providers need the original evaluation receiver.
-    if (registeredProvider !== provider && evaluationModel != null) {
-      Object.assign(registeredProvider, { evaluationModel });
+    // Keep v4 instances intact. Adapted providers need the original decision receiver.
+    if (registeredProvider !== provider && decisionModel != null) {
+      Object.assign(registeredProvider, { decisionModel });
     }
     this.providers[id] = registeredProvider;
   }
@@ -271,7 +288,7 @@ class DefaultProviderRegistry<
   private getProvider(
     id: string,
     modelType: RegistryModelType,
-  ): ProviderV4 & ProviderWithOptionalVideoModel & EvaluationProvider {
+  ): ProviderV4 & ProviderWithOptionalVideoModel & DecisionProvider {
     const provider = this.providers[id as keyof PROVIDERS];
 
     if (provider == null) {
@@ -427,18 +444,28 @@ class DefaultProviderRegistry<
     return asVideoModelV4(model);
   }
 
-  evaluationModel<KEY extends keyof PROVIDERS>(
+  decisionModel<KEY extends keyof PROVIDERS>(
     id: `${KEY & string}${SEPARATOR}${string}`,
-  ): EvaluationModelV4 {
-    const [providerId, modelId] = this.splitId(id, 'evaluationModel');
-    const provider = this.getProvider(providerId, 'evaluationModel');
-    const model = provider.evaluationModel?.(modelId);
+  ): DecisionModelV4 {
+    const [providerId, modelId] = this.splitId(id, 'decisionModel');
+    const provider = this.getProvider(providerId, 'decisionModel');
+    const factory:
+      | ((modelId: string) => Exclude<DecisionModel, string>)
+      | undefined = provider.decisionModel ?? provider.evaluationModel;
+    const model = factory?.call(provider, modelId);
 
     if (model == null) {
-      throw new NoSuchModelError({ modelId: id, modelType: 'evaluationModel' });
+      throw new NoSuchModelError({ modelId: id, modelType: 'decisionModel' });
     }
 
-    return resolveEvaluationModel(model);
+    return resolveDecisionModel(model);
+  }
+
+  /** @deprecated Use `decisionModel` instead. */
+  evaluationModel<KEY extends keyof PROVIDERS>(
+    id: `${KEY & string}${SEPARATOR}${string}`,
+  ) {
+    return asEvaluationModel(this.decisionModel(id));
   }
 
   files<KEY extends keyof PROVIDERS>(id: KEY & string): FilesV4 {

package/src/telemetry/create-telemetry-dispatcher.ts

@@ -142,10 +142,18 @@ export function createTelemetryDispatcher({
 
   const mergeTelemetryCallback = <KEY extends TelemetryCallbackKey>(
     key: KEY,
+    deprecatedKey?: keyof Telemetry,
   ): Callback<TelemetryEvent<KEY>> | undefined => {
     const integrationCallbacks = (
       integrations
-        .map(integration => integration[key]?.bind(integration))
+        .map(integration => {
+          const callback =
+            integration[key] ??
+            (deprecatedKey == null ? undefined : integration[deprecatedKey]);
+          return typeof callback === 'function'
+            ? callback.bind(integration)
+            : undefined;
+        })
         .filter(Boolean) as Array<
         Callback<InferTelemetryEvent<TelemetryEvent<KEY>>>
       >
@@ -222,16 +230,20 @@ export function createTelemetryDispatcher({
     onEmbedEnd: mergeTelemetryCallback('onEmbedEnd'),
     onRerankStart: mergeTelemetryCallback('onRerankStart'),
     onRerankEnd: mergeTelemetryCallback('onRerankEnd'),
-    experimental_onEvaluateStart: mergeTelemetryCallback(
+    experimental_onDecideStart: mergeTelemetryCallback(
+      'experimental_onDecideStart',
       'experimental_onEvaluateStart',
     ),
-    experimental_onEvaluationModelCallStart: mergeTelemetryCallback(
+    experimental_onDecisionModelCallStart: mergeTelemetryCallback(
+      'experimental_onDecisionModelCallStart',
       'experimental_onEvaluationModelCallStart',
     ),
-    experimental_onEvaluationModelCallEnd: mergeTelemetryCallback(
+    experimental_onDecisionModelCallEnd: mergeTelemetryCallback(
+      'experimental_onDecisionModelCallEnd',
       'experimental_onEvaluationModelCallEnd',
     ),
-    experimental_onEvaluateEnd: mergeTelemetryCallback(
+    experimental_onDecideEnd: mergeTelemetryCallback(
+      'experimental_onDecideEnd',
       'experimental_onEvaluateEnd',
     ),
     experimental_onStreamTranscriptionStart: mergeTelemetryCallback(

package/src/telemetry/telemetry.ts

@@ -6,11 +6,11 @@ import type {
   EmbeddingModelCallStartEvent,
 } from '../embed/embed-events';
 import type {
-  EvaluateEndEvent,
-  EvaluateStartEvent,
-  EvaluationModelCallEndEvent,
-  EvaluationModelCallStartEvent,
-} from '../evaluate/evaluate-events';
+  DecideEndEvent,
+  DecideStartEvent,
+  DecisionModelCallEndEvent,
+  DecisionModelCallStartEvent,
+} from '../decide/decide-events';
 import type {
   GenerateObjectEndEvent,
   GenerateObjectStartEvent,
@@ -116,10 +116,10 @@ export interface TelemetryDispatcher {
   onEmbedEnd?: Callback<EmbeddingModelCallEndEvent>;
   onRerankStart?: Callback<RerankingModelCallStartEvent>;
   onRerankEnd?: Callback<RerankingModelCallEndEvent>;
-  experimental_onEvaluateStart?: Callback<EvaluateStartEvent>;
-  experimental_onEvaluationModelCallStart?: Callback<EvaluationModelCallStartEvent>;
-  experimental_onEvaluationModelCallEnd?: Callback<EvaluationModelCallEndEvent>;
-  experimental_onEvaluateEnd?: Callback<EvaluateEndEvent>;
+  experimental_onDecideStart?: Callback<DecideStartEvent>;
+  experimental_onDecisionModelCallStart?: Callback<DecisionModelCallStartEvent>;
+  experimental_onDecisionModelCallEnd?: Callback<DecisionModelCallEndEvent>;
+  experimental_onDecideEnd?: Callback<DecideEndEvent>;
   experimental_onStreamTranscriptionStart?: Callback<StreamTranscriptionStartEvent>;
   experimental_onStreamTranscriptionEnd?: Callback<StreamTranscriptionEndEvent>;
   onEnd?: Callback<OperationEndEvent>;
@@ -245,29 +245,45 @@ export interface Telemetry {
    */
   onRerankEnd?: Callback<InferTelemetryEvent<RerankingModelCallEndEvent>>;
 
-  /** Called when an experimental evaluation operation begins. */
+  /** @deprecated Use `experimental_onDecideStart` instead. */
   experimental_onEvaluateStart?: Callback<
-    InferTelemetryEvent<EvaluateStartEvent>
+    InferTelemetryEvent<DecideStartEvent>
   >;
 
+  /** @deprecated Use `experimental_onDecisionModelCallStart` instead. */
+  experimental_onEvaluationModelCallStart?: Callback<
+    InferTelemetryEvent<DecisionModelCallStartEvent>
+  >;
+
+  /** @deprecated Use `experimental_onDecisionModelCallEnd` instead. */
+  experimental_onEvaluationModelCallEnd?: Callback<
+    InferTelemetryEvent<DecisionModelCallEndEvent>
+  >;
+
+  /** @deprecated Use `experimental_onDecideEnd` instead. */
+  experimental_onEvaluateEnd?: Callback<InferTelemetryEvent<DecideEndEvent>>;
+
+  /** Called when an experimental decision operation begins. */
+  experimental_onDecideStart?: Callback<InferTelemetryEvent<DecideStartEvent>>;
+
   /**
-   * Called immediately before an experimental evaluation model call begins.
+   * Called immediately before an experimental decision model call begins.
    * The logical model call includes any provider retries.
    */
-  experimental_onEvaluationModelCallStart?: Callback<
-    InferTelemetryEvent<EvaluationModelCallStartEvent>
+  experimental_onDecisionModelCallStart?: Callback<
+    InferTelemetryEvent<DecisionModelCallStartEvent>
   >;
 
   /**
-   * Called after an experimental evaluation model response has been validated.
+   * Called after an experimental decision model response has been validated.
    * The logical model call includes any provider retries.
    */
-  experimental_onEvaluationModelCallEnd?: Callback<
-    InferTelemetryEvent<EvaluationModelCallEndEvent>
+  experimental_onDecisionModelCallEnd?: Callback<
+    InferTelemetryEvent<DecisionModelCallEndEvent>
   >;
 
-  /** Called when an experimental evaluation operation completes. */
-  experimental_onEvaluateEnd?: Callback<InferTelemetryEvent<EvaluateEndEvent>>;
+  /** Called when an experimental decision operation completes. */
+  experimental_onDecideEnd?: Callback<InferTelemetryEvent<DecideEndEvent>>;
 
   /** Called when an experimental streaming transcription operation begins. */
   experimental_onStreamTranscriptionStart?: Callback<

package/src/telemetry/tracing-channel.ts

@@ -12,7 +12,7 @@ export type TelemetryTracingEventType =
   | 'generateSpeech'
   | 'transcribe'
   | 'streamTranscribe'
-  | 'experimental_evaluate';
+  | 'experimental_decide';
 
 export type TelemetryTracingChannelMessage<EVENT = unknown> = {
   readonly type: TelemetryTracingEventType;

package/src/test/decision-mock-model-v4.ts

@@ -0,0 +1,35 @@
+import type { Experimental_DecisionModelV4 as DecisionModelV4 } from '@ai-sdk/provider';
+import { notImplemented } from './not-implemented';
+
+export class DecisionMockModelV4 implements DecisionModelV4 {
+  readonly specificationVersion = 'v4';
+  readonly provider: string;
+  readonly modelId: string;
+  readonly supportedQuestionTypes: DecisionModelV4['supportedQuestionTypes'];
+  doDecide: DecisionModelV4['doDecide'];
+
+  /** @deprecated Use `doDecide` instead. */
+  doEvaluate(options: Parameters<DecisionModelV4['doDecide']>[0]) {
+    return this.doDecide(options);
+  }
+
+  constructor({
+    provider = 'mock-provider',
+    modelId = 'mock-model-id',
+    supportedQuestionTypes = ['choice', 'score', 'boolean'],
+    doDecide,
+    doEvaluate,
+  }: {
+    provider?: string;
+    modelId?: string;
+    supportedQuestionTypes?: DecisionModelV4['supportedQuestionTypes'];
+    doDecide?: DecisionModelV4['doDecide'];
+    /** @deprecated Use `doDecide` instead. */
+    doEvaluate?: DecisionModelV4['doDecide'];
+  } = {}) {
+    this.provider = provider;
+    this.modelId = modelId;
+    this.supportedQuestionTypes = supportedQuestionTypes;
+    this.doDecide = doDecide ?? doEvaluate ?? notImplemented;
+  }
+}

package/src/transcribe/transcribe.ts

@@ -256,7 +256,7 @@ export async function transcribe({
           model: resolvedModel.modelId,
         });
 
-        if (!result.text) {
+        if (result.text == null) {
           throw new NoTranscriptGeneratedError({
             responses: [result.response],
           });

package/src/ui/chat.ts

@@ -849,11 +849,18 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
       responseMessageIndex === -1
         ? lastMessage
         : this.state.messages[responseMessageIndex];
+    // the continued stream can start with either
+    // 1) input deltas
+    // 2) or the result of an answered tool approval request
+    // Keep the tool part so in case 2, those chunks can find their tool call
     const resumableResponseMessage =
       trigger === 'resume-stream' &&
       responseMessage?.role === 'assistant' &&
       responseMessage.parts.some(
-        part => isToolUIPart(part) && part.state === 'input-streaming',
+        part =>
+          isToolUIPart(part) &&
+          (part.state === 'input-streaming' ||
+            part.state === 'approval-responded'),
       )
         ? this.state.snapshot(responseMessage)
         : undefined;
@@ -952,6 +959,7 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
       await consumeStream({
         stream: processUIMessageStream({
           stream,
+          resetStateOnMessageIdChange: trigger === 'resume-stream',
           onToolCall: this.onToolCall,
           onData: this.onData,
           messageMetadataSchema: this.messageMetadataSchema,

package/src/ui/process-ui-message-stream.ts

@@ -120,6 +120,7 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
   onError,
   onToolCall,
   onData,
+  resetStateOnMessageIdChange = false,
 }: {
   // input stream is not fully typed yet:
   stream: ReadableStream<UIMessageChunk>;
@@ -136,6 +137,8 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
     }) => Promise<void>,
   ) => Promise<void>;
   onError: ErrorHandler;
+  // During resume, a different message ID identifies a separate response.
+  resetStateOnMessageIdChange?: boolean;
 }): ReadableStream<InferUIMessageChunk<UI_MESSAGE>> {
   return stream.pipeThrough(
     new TransformStream<UIMessageChunk, InferUIMessageChunk<UI_MESSAGE>>({
@@ -953,6 +956,24 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
             }
 
             case 'start': {
+              if (
+                resetStateOnMessageIdChange &&
+                chunk.messageId != null &&
+                chunk.messageId !== state.message.id
+              ) {
+                // Start the separate response with empty parts and metadata.
+                // Reset the active-part maps too, so earlier chunks stay with
+                // the previous response. Keep the state object for its callers.
+                Object.assign(
+                  state,
+                  createStreamingUIMessageState({
+                    lastMessage: undefined,
+                    messageId: chunk.messageId,
+                  }),
+                  { finishReason: undefined },
+                );
+              }
+
               if (chunk.messageId != null) {
                 state.message.id = chunk.messageId;
               }

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

@@ -1,74 +0,0 @@
----
-title: experimental_evaluate
-description: Evaluate typed questions against shared state with an evaluation model.
----
-
-# `experimental_evaluate()`
-
-```ts
-import { experimental_evaluate } from 'ai';
-```
-
-Evaluates a nonempty map of `choice`, `score`, and `boolean` questions against one
-state. See [Evaluation](/docs/ai-sdk-core/evaluation) for examples and semantics.
-
-## Parameters
-
-| Parameter         | Type                                               | Description                                                                                                                                 |
-| ----------------- | -------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
-| `model`           | `Experimental_EvaluationModel`                     | Required experimental v4 model instance or a string ID resolved by Gateway or an explicitly configured evaluation-capable default provider. |
-| `state`           | `string \| object \| array`                        | Required JSON-compatible shared state.                                                                                                      |
-| `questions`       | `Record<string, Experimental_EvaluationQuestion>`  | Required nonempty question map.                                                                                                             |
-| `maxRetries`      | `number`                                           | Nonnegative integer; defaults to 2.                                                                                                         |
-| `abortSignal`     | `AbortSignal`                                      | Cancels evaluation.                                                                                                                         |
-| `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_EvaluateStartEvent) => void` | Called when the evaluation operation begins.                                                                                                |
-| `onEnd`           | `(event: Experimental_EvaluateEndEvent) => void`   | Called when the evaluation operation completes successfully.                                                                                |
-
-See [Lifecycle Callbacks](/docs/ai-sdk-core/lifecycle-callbacks#experimental_evaluate)
-for the complete `onStart` and `onEnd` event fields.
-
-## Result
-
-Returns `Promise<Experimental_EvaluationResult<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_EvaluationModelV4` is exported from `@ai-sdk/provider` and declares
-`specificationVersion: 'v4'`, `provider`, `modelId`, `supportedQuestionTypes`, and
-`doEvaluate(options)`. Evaluation is isolated from stable `ProviderV4`.
-
-The public core types are `Experimental_EvaluationModel`,
-`Experimental_EvaluationQuestion`, `Experimental_EvaluationAnswer`, and
-`Experimental_EvaluationResult`. All evaluation-specific classes use the
-`Evaluation` prefix, with `Experimental_` aliases at package boundaries.
-
-## Errors
-
-Unsupported types throw `Experimental_EvaluationUnsupportedQuestionTypeError`
-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.evaluationModel('provider:model')` or
-`customProvider({ evaluationModels: { alias: model } }).evaluationModel('alias')`
-to resolve models. Strings passed directly to `experimental_evaluate` use
-`globalThis.AI_SDK_DEFAULT_PROVIDER.evaluationModel(id)`, when available. Evaluation
-never implicitly falls back to Gateway.
-
-Resolution errors use the existing `NoSuchModelError` and `NoSuchProviderError`
-classes with `modelType: 'evaluationModel'`. Model instances and resolved models
-must implement v4; other versions throw `UnsupportedModelVersionError`.
-See [model resolution examples](/docs/ai-sdk-core/evaluation#model-aliases-and-registries).

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

@@ -1,31 +0,0 @@
----
-title: AI_EvaluationUnsupportedQuestionTypeError
-description: Identify an evaluation question type that a model does not support.
----
-
-# AI_EvaluationUnsupportedQuestionTypeError
-
-This experimental error identifies a question whose type is unsupported by an
-evaluation model. It is exported from `ai` and `@ai-sdk/provider` as
-`Experimental_EvaluationUnsupportedQuestionTypeError`.
-
-## Properties
-
-- `questionId`: The ID of the unsupported question.
-- `questionType`: The requested question type.
-- `provider`: The provider of the evaluation model.
-- `modelId`: The evaluation 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_EvaluationUnsupportedQuestionTypeError as EvaluationUnsupportedQuestionTypeError } from 'ai';
-
-if (EvaluationUnsupportedQuestionTypeError.isInstance(error)) {
-  console.log(error.questionId, error.questionType, error.modelId);
-}
-```