ai 7.0.103 → 7.0.104

package/docs/03-ai-sdk-core/18-code-mode.mdx

@@ -173,6 +173,17 @@ const user = await tools['lookup-user']({ userId: 'user_123' });
 return { id: user.id, plan: user.plan };
 ```
 
+### Searching Deferred Tools
+
+Use `toolSearch()` with `deferLoading: true` to expose tools only when the model
+needs them. With `toolDiscovery: 'conversation'`, discovered definitions arrive
+in user messages, preserving the tool-definition cache by keeping the
+provider-visible code mode tool unchanged. Actual prompt-cache reuse depends on
+the provider.
+
+See [Tool Search](/docs/ai-sdk-core/tool-search) for direct-calling and code mode
+examples.
+
 ## Writing Code Mode Programs
 
 Generated programs support:

package/docs/03-ai-sdk-core/19-tool-search.mdx

@@ -0,0 +1,80 @@
+---
+title: Tool Search
+description: Let models discover tools on demand, with direct calling or cache-preserving code mode.
+---
+
+# Tool Search
+
+`toolSearch()` lets a model find the tools it needs without loading every tool's
+definition into its initial context. Register tools with `deferLoading: true`;
+search matches their names and descriptions and makes them available on the
+**next model step**.
+
+Use it with `generateText`, `streamText`, or `ToolLoopAgent`. The factory takes no
+arguments; the model supplies a search query.
+
+## Direct Tool Calling
+
+The model initially sees only `search`. After searching, matching definitions are
+added to the provider's tool list and the model calls those tools directly. This
+changes the tool definitions and can invalidate the cached prompt prefix.
+
+```ts
+import { generateText, isStepCount, tool, toolSearch } from 'ai';
+import { z } from 'zod/v4';
+
+const weather = tool({
+  deferLoading: true,
+  description: 'Get the weather forecast for a city.',
+  inputSchema: z.object({ city: z.string() }),
+  execute: async ({ city }) => ({ city, forecast: 'Rain tomorrow.' }),
+});
+
+const result = await generateText({
+  model: __MODEL__,
+  tools: { search: toolSearch(), weather },
+  stopWhen: isStepCount(5),
+  prompt: 'Will it rain in Bangalore tomorrow?',
+});
+```
+
+## Code Mode
+
+With [code mode](/docs/ai-sdk-core/code-mode), the model searches and calls tools
+through generated code. Set `toolDiscovery: 'conversation'` to announce discovered
+definitions in user messages while keeping the provider-visible code tool
+unchanged. **This preserves the tool-definition cache as tools are discovered.**
+Actual prompt-cache reuse depends on the provider.
+
+Using the `weather` tool defined above:
+
+```ts
+import { experimental_codeModeTool as codeModeTool } from '@ai-sdk/code-mode';
+
+const result = await generateText({
+  model: __MODEL__,
+  tools: {
+    code: codeModeTool({ toolDiscovery: 'conversation' }),
+    search: toolSearch(),
+    weather,
+  },
+  experimental_toolCallers: {
+    search: ['code'],
+    weather: ['code'],
+  },
+  stopWhen: isStepCount(5),
+  prompt: 'Will it rain in Bangalore tomorrow?',
+});
+```
+
+The model first runs `tools.search({ query: 'weather forecast' })`. On the next
+step, it receives the updated capability catalog and can call
+`tools.weather({ city: 'Bangalore' })`.
+
+In both modes, search loads up to five matches, respects `activeTools` and caller
+routing, and keeps discovered tools available for the rest of the generation.
+MCP client tools work too: add `deferLoading: true` to the tools returned by
+`client.tools()`.
+
+See the [`toolSearch()` reference](/docs/reference/ai-sdk-core/tool-search) for
+input, output, and matching details.

package/docs/03-ai-sdk-core/32-evaluation.mdx

@@ -10,9 +10,9 @@ an evaluation model. State can be a string, JSON object, or JSON array. An array
 is one state, not a batch of unrelated inputs.
 
 This API and the evaluation model specification are experimental and may change
-in patch releases. Pass a model instance implementing
-`Experimental_EvaluationModelV4`; string model IDs and registry integration are
-not supported yet.
+in patch releases. Pass an evaluation model instance, resolve a model through a
+provider registry, or use a string ID with an evaluation-capable default provider.
+Evaluation does not fall back to Vercel AI Gateway.
 
 ```ts
 import { experimental_evaluate, type Experimental_EvaluationModel } from 'ai';
@@ -44,6 +44,123 @@ async function triage(model: Experimental_EvaluationModel, message: string) {
 }
 ```
 
+## Provider models
+
+Use a provider's `evaluationModel` factory:
+
+| Provider    | Example model                                            |
+| ----------- | -------------------------------------------------------- |
+| TypeSafe AI | `typeSafeAi.evaluationModel('jev-latest')`               |
+| OpenAI      | `openai.evaluationModel('gpt-5.6-luna')`                 |
+| Anthropic   | `anthropic.evaluationModel('claude-haiku-4-5-20251001')` |
+| Google      | `google.evaluationModel('gemini-3.5-flash-lite')`        |
+
+TypeSafe AI supplies native Choice, Score, and Boolean evaluations. OpenAI,
+Anthropic, and Google adapt structured language-model output for all three types.
+Boolean answers contain prompted estimates of P(true), validated to be finite
+and in `[0, 1]`. These estimates are not guaranteed to be calibrated. Choice and
+Score answers do not include probability distributions. Select a model that
+supports the provider's structured-output API; judge quality against your own
+labeled examples before choosing a model for a task.
+
+The language-model adapters evaluate all questions in one prompt. They do not
+provide TypeSafe's native independent-question execution semantics. The example
+model IDs demonstrate API compatibility; they are not benchmark-selected defaults.
+
+Language-model adapters request `reasoning: 'none'` by default. Each provider
+maps this setting to its model's reasoning controls; it does not guarantee that
+every model runs without thinking. To enable reasoning for more demanding
+evaluations, pass the model's supported reasoning settings through
+`providerOptions`, which take precedence over this default. For example, use
+`providerOptions: { openai: { reasoningEffort: 'high' } }` with an OpenAI model
+that supports that effort.
+
+## Model aliases and registries
+
+Use `customProvider` to give models application-specific names, then register
+providers with `createProviderRegistry`:
+
+```ts
+import { typeSafeAi } from '@ai-sdk/typesafe-ai';
+import { openai } from '@ai-sdk/openai';
+import {
+  customProvider,
+  createProviderRegistry,
+  experimental_evaluate,
+} from 'ai';
+
+const registry = createProviderRegistry({
+  triage: customProvider({
+    evaluationModels: {
+      native: typeSafeAi.evaluationModel('jev-latest'),
+      compact: openai.evaluationModel('gpt-5.6-luna'),
+    },
+    fallbackProvider: typeSafeAi,
+  }),
+  openai,
+});
+
+const result = await experimental_evaluate({
+  model: registry.evaluationModel('triage:native'),
+  state: 'I was charged twice.',
+  questions: {
+    department: {
+      type: 'choice',
+      instructions: 'Which team should handle this?',
+      criteria: { billing: 'Charges and refunds', support: 'Other requests' },
+    },
+  },
+});
+
+result.answers.department.choice; // 'billing' | 'support'
+```
+
+Registry IDs use `providerId:modelId`; the `separator` option changes the
+separator. Only the first separator is used, so model IDs can contain it.
+Custom aliases take precedence over a fallback provider. A fallback only resolves
+unknown model IDs; it does not retry failed evaluations or substitute a model
+when a question type is unsupported. Registered providers keep their own
+credentials and settings. Registry language/image middleware does not wrap
+evaluation models.
+
+### Default-provider strings
+
+To use strings directly, configure the default provider once at application
+startup:
+
+```ts
+// Using the registry above, expose an alias through a custom provider:
+globalThis.AI_SDK_DEFAULT_PROVIDER = customProvider({
+  evaluationModels: { native: registry.evaluationModel('triage:native') },
+});
+
+const result = await experimental_evaluate({
+  model: 'native',
+  state: 'I was charged twice.',
+  questions: {
+    refund: {
+      type: 'boolean',
+      instructions: 'Is the customer asking for a refund?',
+    },
+  },
+});
+```
+
+A direct provider such as `typeSafeAi` can also be the default; then use its
+unprefixed model ID, such as `'jev-latest'`. String values in `evaluationModels`
+also resolve through this global default. Prefer model instances in aliases to
+avoid resolution cycles. Global configuration affects other AI SDK functions
+too; avoid changing it per request in a shared process.
+
+Strings require an explicitly configured provider with an `evaluationModel`
+method. There is no assumed Gateway evaluation support. Missing providers throw
+`NoSuchProviderError`; missing models or evaluation capabilities throw
+`NoSuchModelError` with `modelType: 'evaluationModel'`. Unsupported model versions
+throw `UnsupportedModelVersionError`, including models returned by registries.
+The stable `ProviderV4` and `ProviderRegistryProvider` interfaces are unchanged;
+keep the inferred registry type, or use `Experimental_EvaluationProviderRegistry`,
+to retain its experimental `evaluationModel` method.
+
 ## Question types
 
 | Type      | Criteria                                  | Answer                                                                   |
@@ -77,11 +194,27 @@ are preserved, never silently normalized.
 
 Choice and Score distributions are optional. Boolean probability is required:
 `0.98` means a strong yes and `0.02` means a strong no. It is not confidence in
-either outcome. The SDK does not promise calibration across providers or
-synthesize missing probabilities. Provider-specific confidence statistics belong
-in `providerMetadata`.
+either outcome. The SDK does not promise calibration across providers. Structured
+language-model adapters prompt the model to estimate P(true); native evaluation providers return
+their API probabilities. Provider-specific confidence statistics belong
+in `providerMetadata`. TypeSafe exposes its separate Choice/Score confidence
+statistic at `result.providerMetadata?.typesafe?.confidence`, keyed by question
+ID. It is not the selected option's probability or a portable confidence measure.
 
-Choose thresholds in application code:
+Check for optional distributions before using them. For example, an application
+can route only when a provider supplies a sufficiently high selected-option
+probability:
+
+```ts
+const answer = result.answers.department;
+const selectedProbability = answer.probabilities?.[answer.choice];
+if (selectedProbability != null && selectedProbability >= 0.9) {
+  // Route automatically; otherwise use the application's review path.
+}
+```
+
+Choose Boolean thresholds in application code, using labeled data from the task
+rather than assuming that the same threshold behaves identically across providers:
 
 ```ts
 if (result.answers.requestsRefund.probability >= 0.8) {
@@ -108,3 +241,15 @@ Unknown token counts stay `undefined`; `totalTokens` is available only when both
 input and output counts are known.
 
 For tests, use `Experimental_EvaluationMockModelV4` from `ai/test`.
+
+## Scope and examples
+
+Evaluation currently returns one complete result for one shared state. It does
+not stream answers, perform multilabel classification, or batch unrelated
+states. Run separate calls for separate states. Provider support and judgment
+quality depend on the chosen model; the SDK does not choose a model automatically.
+
+Runnable examples are in
+[`examples/ai-functions/src/evaluate`](https://github.com/vercel/ai/tree/main/examples/ai-functions/src/evaluate),
+including basic examples for TypeSafe, OpenAI, Anthropic, and Google, model
+registries, custom aliases, default-provider strings, and probability-based routing.

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

@@ -468,3 +468,13 @@ const result = await streamText({
 ```
 
 This simplifies provider usage and makes it easier to switch between providers without changing your model references throughout your codebase.
+
+## Experimental evaluation models
+
+Custom providers accept `evaluationModels` aliases, and registries expose
+`evaluationModel('provider:model')`. These methods return model instances for
+`experimental_evaluate`. An explicitly configured default provider with an
+`evaluationModel` method also enables direct string IDs; evaluation does not
+implicitly use Gateway. Registry middleware for language and image models does
+not apply to evaluation. See [Evaluation](/docs/ai-sdk-core/evaluation#model-aliases-and-registries)
+for aliases, default-provider configuration, and capability differences.

package/docs/03-ai-sdk-core/index.mdx

@@ -28,6 +28,12 @@ description: Learn about AI SDK Core.
       description: 'Learn how to do tool calling with AI SDK Core.',
       href: '/docs/ai-sdk-core/tools-and-tool-calling',
     },
+    {
+      title: 'Tool Search',
+      description:
+        'Discover tools on demand with direct calling or cache-preserving code mode.',
+      href: '/docs/ai-sdk-core/tool-search',
+    },
     {
       title: 'Code Mode',
       description:

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

@@ -14,15 +14,15 @@ state. See [Evaluation](/docs/ai-sdk-core/evaluation) for examples and semantics
 
 ## Parameters
 
-| Parameter         | Type                                              | Description                                                               |
-| ----------------- | ------------------------------------------------- | ------------------------------------------------------------------------- |
-| `model`           | `Experimental_EvaluationModel`                    | Required model instance implementing the experimental v4 evaluation spec. |
-| `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.                                                |
+| Parameter         | Type                                              | Description                                                                                                                      |
+| ----------------- | ------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| `model`           | `Experimental_EvaluationModel`                    | Required experimental v4 model instance or a string ID resolved by 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.                                                                                                       |
 
 ## Result
 
@@ -52,3 +52,16 @@ 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/01-ai-sdk-core/20-tool.mdx

@@ -65,6 +65,13 @@ export const weatherTool = tool({
               description:
                 'Information about the purpose of the tool including details on how and when it can be used by the model. Provide a string for a fixed description, or a function to derive the description from the tool-specific context and optional experimental sandbox before each model call.',
             },
+            {
+              name: 'deferLoading',
+              isOptional: true,
+              type: 'boolean',
+              description:
+                "Keep this tool out of the model context until toolSearch discovers it. Supports direct calling or code mode with toolDiscovery: 'conversation'. Discovered tools become available on the next model step. Defaults to false.",
+            },
             {
               name: 'title',
               isOptional: true,

package/docs/07-reference/01-ai-sdk-core/22-dynamic-tool.mdx

@@ -58,6 +58,13 @@ export const customTool = dynamicTool({
               description:
                 'Information about the purpose of the tool including details on how and when it can be used by the model. Provide a string for a fixed description, or a function to derive the description from the tool-specific context and optional experimental sandbox before each model call.'
             },
+            {
+              name: 'deferLoading',
+              isOptional: true,
+              type: 'boolean',
+              description:
+                "Keep this tool out of the model context until toolSearch discovers it. Supports direct calling or code mode with toolDiscovery: 'conversation'. Discovered tools become available on the next model step. Defaults to false.",
+            },
             {
               name: 'title',
               isOptional: true,

package/docs/07-reference/01-ai-sdk-core/23-tool-search.mdx

@@ -0,0 +1,75 @@
+---
+title: toolSearch
+description: Search deferred tools and load their definitions on demand for direct calling or code mode.
+---
+
+# `toolSearch()`
+
+Creates a tool that searches the surrounding generation's deferred tools by name
+and description. The factory takes no arguments. Use it with `generateText`,
+`streamText`, or `ToolLoopAgent`, either with direct tool calling or with code mode
+configured with `toolDiscovery: 'conversation'`.
+
+```ts
+import { toolSearch } from 'ai';
+
+const search = toolSearch();
+```
+
+See the [Tool Search guide](/docs/ai-sdk-core/tool-search) for direct-calling and
+code mode examples, including how code mode preserves the tool-definition cache.
+
+## Model Input
+
+The model supplies the following input to the search tool:
+
+```json
+{ "query": "weather forecast" }
+```
+
+`query` is a required, nonempty string of search keywords. Search is local and
+case-insensitive, matching words in tool names and descriptions. Camel-case names
+are split into words. Name matches rank above description matches; equal scores
+preserve registration order. Function descriptions are resolved with the current
+tool context and sandbox. No embedding service or additional model call is used.
+
+## Output
+
+```ts
+{
+  tools: [
+    { name: 'getForecast', description: 'Get the weather forecast for a city.' },
+  ],
+}
+```
+
+Results contain at most five matching tools, with their names and optional
+descriptions. They do not include schemas. No matches returns `{ tools: [] }`.
+Every returned match is queued for discovery. Newly discovered tools can only be
+called on the next model step, after their definitions have been provided. A
+parallel call in the same response as the search cannot use a newly discovered
+tool. For code mode, finish the current execution and wait for the capability
+update.
+
+## Discovery Lifecycle
+
+Before the next model step, the SDK makes discovered tools available through
+their configured callers:
+
+- **Direct calling:** the provider receives the updated tool definitions.
+- **Code mode:** the SDK appends a user message containing the updated capability
+  catalog. The provider-visible code mode definition stays unchanged. Existing
+  catalogs remain in the conversation; the latest catalog describes the complete
+  currently available tool set.
+
+Actual prompt-cache reuse depends on the provider. Code mode search still requires
+`toolDiscovery: 'conversation'`; description discovery and provider callers are
+not supported.
+
+Discovered tools remain loaded for the rest of the generation, subject to
+`activeTools`. Search cannot discover tools excluded by `activeTools`. Discovery
+state is isolated between generation calls, including calls that reuse the same
+agent or tool instances.
+
+Set a multi-step `stopWhen` condition with `generateText` and `streamText` so the
+model can search, use the discovered tools, and answer.

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

@@ -298,3 +298,20 @@ The `createProviderRegistry` function returns a `Provider` instance. It has the
     },
   ]}
 />
+
+## Experimental evaluation 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
+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.
+
+Unavailable evaluation capabilities or models throw `NoSuchModelError` with
+`modelType: 'evaluationModel'`; unknown registry providers throw
+`NoSuchProviderError`. These capabilities are structural extensions and are not
+added to the stable `ProviderV4` contract. Evaluation does not assume Gateway
+support. See [Evaluation](/docs/ai-sdk-core/evaluation#model-aliases-and-registries)
+for runnable usage patterns.

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

@@ -201,3 +201,19 @@ The `customProvider` function returns a `Provider` instance. It has the followin
     },
   ]}
 />
+
+## Experimental evaluation 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
+through an explicitly configured default provider with an `evaluationModel`
+method. Unknown aliases use the fallback provider's evaluation 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
+`NoSuchProviderError`. These capabilities are structural extensions and are not
+added to the stable `ProviderV4` contract. Evaluation does not assume Gateway
+support. See [Evaluation](/docs/ai-sdk-core/evaluation#model-aliases-and-registries)
+for runnable usage patterns.

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

@@ -115,6 +115,12 @@ It also contains the following helper functions:
 
 <IndexCards
   cards={[
+    {
+      title: 'toolSearch()',
+      description:
+        'Search deferred tools and load their definitions on demand.',
+      href: '/docs/reference/ai-sdk-core/tool-search',
+    },
     {
       title: 'tool()',
       description: 'Type inference helper function for tools.',

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

@@ -24,3 +24,7 @@ if (NoSuchModelError.isInstance(error)) {
   // Handle the 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).

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

@@ -26,3 +26,7 @@ if (NoSuchProviderError.isInstance(error)) {
   // Handle the 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).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.103",
+  "version": "7.0.104",
   "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.83",
-    "@ai-sdk/provider": "4.0.16",
-    "@ai-sdk/provider-utils": "5.0.42"
+    "@ai-sdk/gateway": "4.0.84",
+    "@ai-sdk/provider": "4.0.17",
+    "@ai-sdk/provider-utils": "5.0.43"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "5.0.85",
-    "@ai-sdk/deepseek": "3.0.46",
-    "@ai-sdk/google": "4.0.73",
-    "@ai-sdk/groq": "4.0.43",
-    "@ai-sdk/huggingface": "2.0.50",
-    "@ai-sdk/moonshotai": "3.0.51",
-    "@ai-sdk/openai": "4.0.68",
+    "@ai-sdk/amazon-bedrock": "5.0.86",
+    "@ai-sdk/deepseek": "3.0.47",
+    "@ai-sdk/google": "4.0.74",
+    "@ai-sdk/groq": "4.0.44",
+    "@ai-sdk/huggingface": "2.0.51",
+    "@ai-sdk/moonshotai": "3.0.52",
+    "@ai-sdk/openai": "4.0.69",
     "@ai-sdk/test-server": "2.0.1",
-    "@ai-sdk/xai": "5.0.1",
+    "@ai-sdk/xai": "5.0.2",
     "@edge-runtime/vm": "^5.0.0",
     "@smithy/eventstream-codec": "^4.3.3",
     "@smithy/util-utf8": "^4.3.3",

package/src/evaluate/evaluate.ts

@@ -6,7 +6,7 @@ import {
   withUserAgentSuffix,
   type ProviderOptions,
 } from '@ai-sdk/provider-utils';
-import { UnsupportedModelVersionError } from '../error/unsupported-model-version-error';
+import { resolveEvaluationModel } from '../model/resolve-model';
 import { logWarnings } from '../logger/log-warnings';
 import { prepareRetries } from '../util/prepare-retries';
 import { VERSION } from '../version';
@@ -24,7 +24,7 @@ import {
 export async function evaluate<
   const QUESTIONS extends Record<string, EvaluationQuestion>,
 >({
-  model,
+  model: modelArg,
   state,
   questions,
   maxRetries,
@@ -32,7 +32,7 @@ export async function evaluate<
   headers,
   providerOptions = {},
 }: {
-  /** An evaluation model instance. String model resolution is not yet supported. */
+  /** An evaluation model instance or an ID resolved by the configured default provider. */
   model: EvaluationModel;
   state: EvaluationModelV4CallOptions['state'];
   questions: QUESTIONS;
@@ -42,13 +42,7 @@ export async function evaluate<
   headers?: Record<string, string>;
   providerOptions?: ProviderOptions;
 }): Promise<EvaluationResult<QUESTIONS>> {
-  if (model.specificationVersion !== 'v4') {
-    throw new UnsupportedModelVersionError({
-      version: model.specificationVersion,
-      provider: model.provider,
-      modelId: model.modelId,
-    });
-  }
+  const model = resolveEvaluationModel(modelArg);
 
   validateEvaluationInput({ state, questions });
 

package/src/evaluate/evaluation-provider.ts

@@ -0,0 +1,6 @@
+import type { Experimental_EvaluationModelV4 as EvaluationModelV4 } from '@ai-sdk/provider';
+
+/** Structural extension; evaluation is not part of the stable provider contract. */
+export type EvaluationProvider = {
+  evaluationModel?: (modelId: string) => EvaluationModelV4;
+};

package/src/evaluate/evaluation-result.ts

@@ -4,7 +4,7 @@ import type {
   Experimental_EvaluationModelV4Result as EvaluationModelV4Result,
 } from '@ai-sdk/provider';
 
-export type EvaluationModel = EvaluationModelV4;
+export type EvaluationModel = string | EvaluationModelV4;
 export type EvaluationQuestion = EvaluationModelV4Question;
 
 export type EvaluationAnswer<QUESTION extends EvaluationQuestion> =