ai 7.0.102 → 7.0.104

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

@@ -0,0 +1,255 @@
+---
+title: Evaluation
+description: Evaluate Choice, Score, and Boolean questions against shared state.
+---
+
+# Evaluation
+
+`experimental_evaluate` evaluates named questions against one shared state using
+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 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';
+
+async function triage(model: Experimental_EvaluationModel, message: string) {
+  return experimental_evaluate({
+    model,
+    state: { message },
+    questions: {
+      department: {
+        type: 'choice',
+        instructions: 'Which team should handle this?',
+        criteria: {
+          billing: 'Payments and refunds',
+          support: 'Other requests',
+        },
+      },
+      severity: {
+        type: 'score',
+        instructions: 'How severe is the issue?',
+        criteria: ['Cosmetic', 'Workaround exists', 'Blocking; no workaround'],
+      },
+      requestsRefund: {
+        type: 'boolean',
+        instructions: 'Is the customer requesting money back?',
+      },
+    },
+  });
+}
+```
+
+## 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                                                                   |
+| --------- | ----------------------------------------- | ------------------------------------------------------------------------ |
+| `choice`  | A nonempty map of options to descriptions | `choice`, inferred as a union of option keys; optional `probabilities`   |
+| `score`   | At least two ordered level descriptions   | Fractional `score` in `[0, levels.length - 1]`; optional `probabilities` |
+| `boolean` | Optional `true` and `false` descriptions  | Required `probability`, the model-estimated probability of true          |
+
+Instructions and descriptions can be strings, JSON objects, or JSON arrays.
+Descriptions can also be `null`. Core treats structured descriptions as content;
+it does not interpret their keys. Functions, class instances, cycles, undefined
+values, and nonfinite numbers are not JSON-compatible.
+
+Answers retain question IDs and have the same `type` as their question. When a
+Choice distribution is supplied, it includes every option and the selected
+choice has maximal probability. Score distributions use string keys for
+zero-based level indices, and the score equals the probability-weighted mean.
+Without a distribution, a score is the model's estimated position on the rubric.
+
+Distributions must sum to one, and weighted scores must agree with their
+distributions. The default absolute tolerance is `0.000001`. Providers that round
+their output can declare `rounding.probabilityDecimals` and
+`rounding.scoreDecimals` (integers from 0 to 15). Validation then also allows half
+a unit in the last decimal place per rounded probability or score, accumulated
+over the sum or weighted mean. For example, probabilities rounded to two decimal
+places can sum to `0.99` even when their unrounded values sum to one. The result
+includes this `rounding` information. Invalid output is rejected; native values
+are preserved, never silently normalized.
+
+## Probabilities and confidence
+
+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. 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.
+
+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) {
+  // Route to the refunds queue.
+}
+```
+
+## Errors and cancellation
+
+The model's `supportedQuestionTypes` are checked before calling the provider.
+Any unsupported question fails the entire call with
+`Experimental_EvaluationUnsupportedQuestionTypeError`. Successful calls return
+an answer for every question; there is no partial success or automatic model
+substitution.
+
+Invalid inputs throw `InvalidArgumentError`. Missing answers, mismatched answer
+types, invalid options, scores, or probabilities throw `InvalidResponseDataError`.
+Transient provider failures use the normal retry policy (`maxRetries: 2` by
+default). Use `abortSignal` to cancel evaluation, `headers` for request headers,
+and `providerOptions` for provider-specific settings.
+
+The result includes `usage`, `warnings`, `providerMetadata`, and `response`.
+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/42-batch.mdx

@@ -66,8 +66,7 @@ support are:
 
 See the provider documentation for the supported models, limits, and native
 batch behavior. For example, OpenAI batch support is available through the
-Responses API, not `openai.chat()`, and xAI batch support is available through
-the Responses API, not `xai.chat()`.
+Responses API, not `openai.chat()`.
 
 ## Starting a batch
 

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/04-ai-sdk-ui/03-chatbot-message-persistence.mdx

@@ -92,6 +92,41 @@ export async function loadChat(id: string): Promise<UIMessage[]> {
 
 When processing messages on the server that contain tool calls, custom metadata, or data parts, you should validate them using `validateUIMessages` before sending them to the model.
 
+### Migrating deprecated tool `rawInput`
+
+Older persisted tool parts in the `output-error` state may contain `rawInput`.
+This field is deprecated and will be removed in the next major version. Store
+tool arguments in `input` instead. AI SDK emits a deprecation warning when
+`validateUIMessages`, `safeValidateUIMessages`, or `convertToModelMessages`
+encounters a defined `rawInput` value. UI stream processing also warns when it
+reconstructs a static `output-error` part with `rawInput`.
+
+Migrate each legacy part by copying `rawInput` to `input` when `input` is
+`null` or `undefined`, then remove `rawInput`. This preserves the current
+backward-compatible conversion behavior:
+
+```ts
+import { isToolUIPart } from 'ai';
+
+const migratedParts = message.parts.map(part => {
+  if (
+    !isToolUIPart(part) ||
+    part.state !== 'output-error' ||
+    !('rawInput' in part) ||
+    part.rawInput === undefined
+  ) {
+    return part;
+  }
+
+  const { rawInput, ...partWithoutRawInput } = part;
+
+  return {
+    ...partWithoutRawInput,
+    input: part.input ?? rawInput,
+  };
+});
+```
+
 ### Validation with tools
 
 When your messages include tool calls, validate them against your tool definitions:

package/docs/06-advanced/11-secure-url-fetching.mdx

@@ -60,7 +60,13 @@ On Node.js, the default validated download fetch uses `node:dns` and an
 The connector uses those exact results, closing both hostname-to-private-IP and
 DNS-rebinding bypasses.
 
-If you inject or globally replace `fetch`, it is responsible for equivalent DNS
+Wrapping or replacing global `fetch` does not disable this protection: the
+default Node.js download transport is independent of global `fetch`.
+
+Bun, Deno, Cloudflare Workers, and framework edge runtimes use their platform
+fetch, even when they expose a Node-compatible `process` object.
+
+If you explicitly inject a custom `fetch`, it is responsible for equivalent DNS
 validation and connection pinning. Other runtimes do not expose Node's
 DNS/socket hooks, so server deployments on those runtimes should restrict
 network egress to private, loopback, link-local, and cloud-metadata ranges.
@@ -78,7 +84,7 @@ code.
 
 ### 2. Harden an injected `fetch`
 
-The Node.js default is already pinned. If you inject or globally replace
+The Node.js default is already pinned. If you explicitly inject a custom
 `fetch`, back it with an `undici`
 `Agent` whose `connect.lookup` validates the resolved IP and lets the socket
 connect only to a safe address — closing both the hostname-to-private and the

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

@@ -0,0 +1,67 @@
+---
+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 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
+
+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/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/32-validate-ui-messages.mdx

@@ -99,3 +99,15 @@ const validatedMessages = await validateUIMessages({
   tools,
 });
 ```
+
+## Deprecated `rawInput` field
+
+For backward compatibility, validation still accepts `rawInput` on tool parts
+in the `output-error` state. When a defined `rawInput` value is found,
+`validateUIMessages` emits an AI SDK deprecation warning through
+`AI_SDK_LOG_WARNINGS`.
+
+Migrate persisted messages to store tool arguments in `input` and remove
+`rawInput`. For backward compatibility, conversion uses `rawInput` as a
+fallback when `input` is `null` or `undefined`. `rawInput` will be removed in
+the next major version.

package/docs/07-reference/01-ai-sdk-core/33-safe-validate-ui-messages.mdx

@@ -33,6 +33,18 @@ if (!result.success) {
 }
 ```
 
+## Deprecated `rawInput` field
+
+For backward compatibility, validation still accepts `rawInput` on tool parts
+in the `output-error` state. When a defined `rawInput` value is found,
+`safeValidateUIMessages` emits an AI SDK deprecation warning through
+`AI_SDK_LOG_WARNINGS`.
+
+Migrate persisted messages to store tool arguments in `input` and remove
+`rawInput`. For backward compatibility, conversion uses `rawInput` as a
+fallback when `input` is `null` or `undefined`. `rawInput` will be removed in
+the next major version.
+
 ## Advanced Usage
 
 Comprehensive validation with custom metadata, data parts, and tools:

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/02-ai-sdk-ui/31-convert-to-model-messages.mdx

@@ -70,6 +70,18 @@ A Promise that resolves to an array of [`ModelMessage`](/docs/reference/ai-sdk-c
   ]}
 />
 
+## Deprecated `rawInput` field
+
+Tool parts in the `output-error` state should store their tool arguments in
+`input`. The legacy `rawInput` field remains supported for persisted messages,
+but `convertToModelMessages` emits an AI SDK deprecation warning when it
+encounters a defined value.
+
+When both fields are present, `input` takes precedence when it is non-nullish.
+For backward compatibility, `rawInput` remains the fallback when `input` is
+`null` or `undefined`. Migrate stored messages to `input` before the next major
+version, when `rawInput` will be removed.
+
 ## Tool Approval States
 
 `convertToModelMessages` preserves tool approval state from UI messages when converting them back into `ModelMessage`s for a follow-up `generateText` or `streamText` call.