ai 7.0.127 → 7.0.128

package/src/generate-text/generate-text.ts

@@ -15,7 +15,7 @@ import {
   type ProviderOptions,
   type ToolSet,
 } from '@ai-sdk/provider-utils';
-import { NoOutputGeneratedError, ToolChoiceViolationError } from '../error';
+import { ToolChoiceViolationError } from '../error';
 import { logWarnings } from '../logger/log-warnings';
 import { resolveLanguageModel } from '../model/resolve-model';
 import type { ModelMessage } from '../prompt';
@@ -76,6 +76,7 @@ import type {
   GenerateTextOnStepFinishCallback,
   GenerateTextOnStepStartCallback,
 } from './generate-text-events';
+import { DefaultGenerateTextResult } from './default-generate-text-result';
 import type { GenerateTextResult } from './generate-text-result';
 import { isToolExecutionAllowedFinishReason } from './is-tool-execution-allowed-finish-reason';
 import type {
@@ -83,11 +84,9 @@ import type {
   OnLanguageModelCallStartCallback,
 } from './language-model-events';
 import { text, type Output } from './output';
-import type { InferCompleteOutput } from './output-utils';
 import { parseToolCall } from './parse-tool-call';
 import type { PrepareStepFunction } from './prepare-step';
 import { prepareStepCallSettings } from './prepare-step-call-settings';
-import { convertToReasoningOutputs } from './reasoning-output';
 import { resolveToolApproval } from './resolve-tool-approval';
 import type { ResponseMessage } from './response-message';
 import { createRestrictedTelemetryDispatcher } from './restricted-telemetry-dispatcher';
@@ -1687,122 +1686,3 @@ async function executeTools<TOOLS extends ToolSet>({
     (result): result is NonNullable<typeof result> => result != null,
   );
 }
-
-class DefaultGenerateTextResult<
-  TOOLS extends ToolSet,
-  RUNTIME_CONTEXT extends Context,
-  OUTPUT extends Output,
-> implements GenerateTextResult<TOOLS, RUNTIME_CONTEXT, OUTPUT> {
-  readonly steps: GenerateTextResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>['steps'];
-  readonly totalUsage: LanguageModelUsage;
-  private readonly _output: InferCompleteOutput<OUTPUT> | undefined;
-
-  constructor(options: {
-    initialResponseMessages: Array<ResponseMessage>;
-    steps: GenerateTextResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>['steps'];
-    output: InferCompleteOutput<OUTPUT> | undefined;
-    totalUsage: LanguageModelUsage;
-  }) {
-    this.initialResponseMessages = options.initialResponseMessages;
-    this.steps = options.steps;
-    this._output = options.output;
-    this.totalUsage = options.totalUsage;
-  }
-
-  private readonly initialResponseMessages: Array<ResponseMessage>;
-
-  get finalStep() {
-    return this.steps.at(-1)!;
-  }
-
-  get content() {
-    return this.steps.flatMap(step => step.content);
-  }
-
-  get text() {
-    return this.finalStep.text;
-  }
-
-  get files() {
-    return this.steps.flatMap(step => step.files);
-  }
-
-  get reasoningText() {
-    return this.finalStep.reasoningText;
-  }
-
-  get reasoning() {
-    return convertToReasoningOutputs(this.finalStep.reasoning);
-  }
-
-  get toolCalls() {
-    return this.steps.flatMap(step => step.toolCalls);
-  }
-
-  get staticToolCalls() {
-    return this.steps.flatMap(step => step.staticToolCalls);
-  }
-
-  get dynamicToolCalls() {
-    return this.steps.flatMap(step => step.dynamicToolCalls);
-  }
-
-  get toolResults() {
-    return this.steps.flatMap(step => step.toolResults);
-  }
-
-  get staticToolResults() {
-    return this.steps.flatMap(step => step.staticToolResults);
-  }
-
-  get dynamicToolResults() {
-    return this.steps.flatMap(step => step.dynamicToolResults);
-  }
-
-  get sources() {
-    return this.steps.flatMap(step => step.sources);
-  }
-
-  get finishReason() {
-    return this.finalStep.finishReason;
-  }
-
-  get rawFinishReason() {
-    return this.finalStep.rawFinishReason;
-  }
-
-  get warnings() {
-    return this.steps.flatMap(step => step.warnings ?? []);
-  }
-
-  get providerMetadata() {
-    return this.finalStep.providerMetadata;
-  }
-
-  get response() {
-    return this.finalStep.response;
-  }
-
-  get responseMessages() {
-    return [
-      ...this.initialResponseMessages,
-      ...this.steps.flatMap(step => step.response.messages),
-    ];
-  }
-
-  get request() {
-    return this.finalStep.request;
-  }
-
-  get usage() {
-    return this.totalUsage;
-  }
-
-  get output() {
-    if (this._output == null) {
-      throw new NoOutputGeneratedError();
-    }
-
-    return this._output;
-  }
-}

package/src/global.ts

@@ -9,7 +9,7 @@ declare global {
    * String model ids are resolved to the default provider and model id.
    *
    * If not set, the default provider is the Vercel AI gateway provider.
-   * Experimental evaluation requires an explicitly configured evaluation-capable provider.
+   * An explicitly configured provider must support decision models to use experimental_decide.
    *
    * @see https://ai-sdk.dev/docs/ai-sdk-core/provider-management#global-provider-configuration
    */

package/src/index.ts

@@ -41,7 +41,7 @@ export * from './agent';
 export * from './batch';
 export * from './embed';
 export * from './error';
-export * from './evaluate';
+export * from './decide';
 export * from './generate-image';
 export * from './generate-object';
 export * from './generate-speech';

package/src/middleware/extract-reasoning-middleware.ts

@@ -3,14 +3,16 @@ import type {
   LanguageModelV4StreamPart,
 } from '@ai-sdk/provider';
 import type { LanguageModelMiddleware } from '../types/language-model-middleware';
+import { InvalidArgumentError } from '../error/invalid-argument-error';
 import { createIdMap } from '../util/create-id-map';
 import { getPotentialStartIndex } from '../util/get-potential-start-index';
 
 /**
- * Extracts an XML-tagged reasoning section from the generated text and exposes it
+ * Extracts a delimited reasoning section from the generated text and exposes it
  * as a `reasoning` property on the result.
  *
- * @param tagName - The name of the XML tag to extract reasoning from.
+ * @param tagName - An XML tag name (without angle brackets), or literal opening
+ * and closing delimiters for formats such as Gemma's thought channel.
  * @param separator - The separator to use between reasoning and text sections.
  * @param startWithReasoning - Whether to start with reasoning tokens.
  */
@@ -19,12 +21,26 @@ export function extractReasoningMiddleware({
   separator = '\n',
   startWithReasoning = false,
 }: {
-  tagName: string;
+  tagName: string | { opening: string; closing: string };
   separator?: string;
   startWithReasoning?: boolean;
 }): LanguageModelMiddleware {
-  const openingTag = `<${tagName}>`;
-  const closingTag = `</${tagName}>`;
+  const openingTag =
+    typeof tagName === 'string' ? `<${tagName}>` : tagName.opening;
+  const closingTag =
+    typeof tagName === 'string' ? `</${tagName}>` : tagName.closing;
+
+  if (openingTag.length === 0 || closingTag.length === 0) {
+    throw new InvalidArgumentError({
+      parameter: 'tagName',
+      value: tagName,
+      message: 'Reasoning delimiters must not be empty.',
+    });
+  }
+
+  // Delimiters are literal strings, including regex metacharacters such as `|`.
+  const escapedOpeningTag = openingTag.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const escapedClosingTag = closingTag.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 
   return {
     specificationVersion: 'v4',
@@ -40,7 +56,10 @@ export function extractReasoningMiddleware({
 
         const text = startWithReasoning ? openingTag + part.text : part.text;
 
-        const regexp = new RegExp(`${openingTag}(.*?)${closingTag}`, 'gs');
+        const regexp = new RegExp(
+          `${escapedOpeningTag}(.*?)${escapedClosingTag}`,
+          'gs',
+        );
         const matches = Array.from(text.matchAll(regexp));
 
         if (!matches.length) {

package/src/model/resolve-model.ts

@@ -1,7 +1,7 @@
 import { gateway } from '@ai-sdk/gateway';
 import {
   NoSuchModelError,
-  type Experimental_EvaluationModelV4 as EvaluationModelV4,
+  type Experimental_DecisionModelV4 as DecisionModelV4,
   type EmbeddingModelV4,
   type Experimental_SpeechTranslationModelV4,
   type Experimental_VideoModelV4,
@@ -12,8 +12,8 @@ import {
   type SpeechModelV4,
   type TranscriptionModelV4,
 } from '@ai-sdk/provider';
-import type { EvaluationModel } from '../evaluate/evaluation-result';
-import type { EvaluationProvider } from '../evaluate/evaluation-provider';
+import type { DecisionModel } from '../decide/decision-result';
+import type { DecisionProvider } from '../decide/decision-provider';
 import { UnsupportedModelVersionError } from '../error';
 import type { EmbeddingModel } from '../types/embedding-model';
 import type { LanguageModel } from '../types/language-model';
@@ -217,29 +217,30 @@ export function resolveRerankingModel(model: RerankingModel): RerankingModelV4 {
   return asRerankingModelV4(model);
 }
 
-export function resolveEvaluationModel(
-  model: EvaluationModel,
-): EvaluationModelV4 {
+export function resolveDecisionModel(model: DecisionModel): DecisionModelV4 {
   if (typeof model === 'string') {
     // Use the original provider so experimental methods and their receiver survive.
     const provider = (globalThis.AI_SDK_DEFAULT_PROVIDER ??
-      gateway) as EvaluationProvider;
+      gateway) as DecisionProvider;
 
-    if (typeof provider?.evaluationModel !== 'function') {
+    const factory:
+      | ((modelId: string) => Exclude<DecisionModel, string>)
+      | undefined = provider.decisionModel ?? provider.evaluationModel;
+    if (typeof factory !== 'function') {
       throw new NoSuchModelError({
         modelId: model,
-        modelType: 'evaluationModel',
+        modelType: 'decisionModel',
         message:
-          'The default provider does not support evaluation models. ' +
-          'Pass an evaluation model instance or configure AI_SDK_DEFAULT_PROVIDER with an evaluationModel method.',
+          'The default provider does not support decision models. ' +
+          'Pass a decision model instance or configure AI_SDK_DEFAULT_PROVIDER with a decisionModel method.',
       });
     }
 
-    const resolvedModel = provider.evaluationModel(model);
+    const resolvedModel = factory.call(provider, model);
     if (resolvedModel == null) {
       throw new NoSuchModelError({
         modelId: model,
-        modelType: 'evaluationModel',
+        modelType: 'decisionModel',
       });
     }
     model = resolvedModel;
@@ -253,10 +254,40 @@ export function resolveEvaluationModel(
     });
   }
 
-  return model;
+  if ('doDecide' in model) {
+    return model;
+  }
+
+  const legacyModel = model;
+  return {
+    specificationVersion: legacyModel.specificationVersion,
+    provider: legacyModel.provider,
+    modelId: legacyModel.modelId,
+    supportedQuestionTypes: legacyModel.supportedQuestionTypes,
+    doDecide: options => legacyModel.doEvaluate(options),
+  };
 }
 
 function getGlobalProvider(): ProviderV4 {
   const provider = globalThis.AI_SDK_DEFAULT_PROVIDER ?? gateway;
   return asProviderV4(provider);
 }
+
+/** Internal adapter for deprecated provider factories. */
+export function asEvaluationModel(model: DecisionModelV4): DecisionModelV4 & {
+  doEvaluate: DecisionModelV4['doDecide'];
+} {
+  if ('doEvaluate' in model && typeof model.doEvaluate === 'function') {
+    return model as DecisionModelV4 & {
+      doEvaluate: DecisionModelV4['doDecide'];
+    };
+  }
+  return {
+    specificationVersion: model.specificationVersion,
+    provider: model.provider,
+    modelId: model.modelId,
+    supportedQuestionTypes: model.supportedQuestionTypes,
+    doDecide: options => model.doDecide(options),
+    doEvaluate: options => model.doDecide(options),
+  };
+}

package/src/registry/custom-provider.ts

@@ -1,5 +1,5 @@
 import {
-  type Experimental_EvaluationModelV4 as EvaluationModelV4,
+  type Experimental_DecisionModelV4 as DecisionModelV4,
   type EmbeddingModelV4,
   type Experimental_VideoModelV3,
   type Experimental_VideoModelV4,
@@ -15,8 +15,8 @@ import {
   type SpeechModelV4,
   type TranscriptionModelV4,
 } from '@ai-sdk/provider';
-import type { EvaluationModel } from '../evaluate/evaluation-result';
-import type { EvaluationProvider } from '../evaluate/evaluation-provider';
+import type { DecisionModel } from '../decide/decision-result';
+import type { DecisionProvider } from '../decide/decision-provider';
 import { asProviderV4 } from '../model/as-provider-v4';
 import {
   resolveEmbeddingModel,
@@ -26,7 +26,8 @@ import {
   resolveSpeechModel,
   resolveTranscriptionModel,
   resolveVideoModel,
-  resolveEvaluationModel,
+  resolveDecisionModel,
+  asEvaluationModel,
 } from '../model/resolve-model';
 import type { EmbeddingModel } from '../types/embedding-model';
 import type { ImageModel } from '../types/image-model';
@@ -53,7 +54,7 @@ type ProviderWithOptionalVideoModel = {
  * @param {Record<string, SpeechModel>} [options.speechModels] - A record of speech models, where keys are model IDs and values are speech model instances.
  * @param {Record<string, RerankingModel>} [options.rerankingModels] - A record of reranking models, where keys are model IDs and values are reranking model instances.
  * @param {Record<string, VideoModel>} [options.videoModels] - A record of video models, where keys are model IDs and values are video model instances.
- * @param {Record<string, EvaluationModel>} [options.evaluationModels] - Experimental evaluation models or default-provider model IDs, keyed by alias.
+ * @param {Record<string, DecisionModel>} [options.decisionModels] - Experimental decision models or default-provider model IDs, keyed by alias.
  * @param {FilesV4} [options.files] - A files interface for uploading files.
  * @param {SkillsV4} [options.skills] - A skills interface for uploading skills.
  * @param {ProviderV2 | ProviderV3 | ProviderV4} [options.fallbackProvider] - An optional fallback provider to use when a requested model is not found in the custom provider.
@@ -72,9 +73,9 @@ export function customProvider<
   FILES extends FilesV4 | undefined = undefined,
   SKILLS extends SkillsV4 | undefined = undefined,
   FALLBACK extends ProviderV2 | ProviderV3 | ProviderV4 | undefined = undefined,
-  EVALUATION_MODELS extends Record<string, EvaluationModel> = Record<
+  DECISION_MODELS extends Record<string, DecisionModel> = Record<
     string,
-    EvaluationModel
+    DecisionModel
   >,
 >({
   languageModels,
@@ -84,6 +85,7 @@ export function customProvider<
   speechModels,
   rerankingModels,
   videoModels,
+  decisionModels: decisionModelsArg,
   evaluationModels,
   files,
   skills,
@@ -96,7 +98,9 @@ export function customProvider<
   speechModels?: SPEECH_MODELS;
   rerankingModels?: RERANKING_MODELS;
   videoModels?: VIDEO_MODELS;
-  evaluationModels?: EVALUATION_MODELS;
+  decisionModels?: DECISION_MODELS;
+  /** @deprecated Use `decisionModels` instead. When both are set, `decisionModels` takes precedence. */
+  evaluationModels?: DECISION_MODELS;
   files?: FILES;
   skills?: SKILLS;
   fallbackProvider?: FALLBACK;
@@ -110,9 +114,11 @@ export function customProvider<
   rerankingModel(modelId: ExtractModelId<RERANKING_MODELS>): RerankingModelV4;
   speechModel(modelId: ExtractModelId<SPEECH_MODELS>): SpeechModelV4;
   videoModel(modelId: ExtractModelId<VIDEO_MODELS>): Experimental_VideoModelV4;
-  evaluationModel(
-    modelId: ExtractModelId<EVALUATION_MODELS>,
-  ): EvaluationModelV4;
+  decisionModel(modelId: ExtractModelId<DECISION_MODELS>): DecisionModelV4;
+  /** @deprecated Use `decisionModel` instead. */
+  evaluationModel(modelId: ExtractModelId<DECISION_MODELS>): DecisionModelV4 & {
+    doEvaluate: DecisionModelV4['doDecide'];
+  };
 } & (FILES extends FilesV4
     ? { files(): FilesV4 }
     : [FALLBACK] extends [{ files: () => FilesV4 }]
@@ -123,6 +129,7 @@ export function customProvider<
     : [FALLBACK] extends [{ skills: () => SkillsV4 }]
       ? { skills(): SkillsV4 }
       : { skills?(): SkillsV4 }) {
+  const decisionModels = decisionModelsArg ?? evaluationModels;
   const fallbackProvider =
     fallbackProviderArg == null ? undefined : asProviderV4(fallbackProviderArg);
 
@@ -138,9 +145,13 @@ export function customProvider<
     videoModel(
       modelId: ExtractModelId<VIDEO_MODELS>,
     ): Experimental_VideoModelV4;
+    decisionModel(modelId: ExtractModelId<DECISION_MODELS>): DecisionModelV4;
+    /** @deprecated Use `decisionModel` instead. */
     evaluationModel(
-      modelId: ExtractModelId<EVALUATION_MODELS>,
-    ): EvaluationModelV4;
+      modelId: ExtractModelId<DECISION_MODELS>,
+    ): DecisionModelV4 & {
+      doEvaluate: DecisionModelV4['doDecide'];
+    };
   } = {
     specificationVersion: 'v4',
     languageModel(modelId: ExtractModelId<LANGUAGE_MODELS>): LanguageModelV4 {
@@ -227,25 +238,26 @@ export function customProvider<
 
       throw new NoSuchModelError({ modelId, modelType: 'rerankingModel' });
     },
-    evaluationModel(
-      modelId: ExtractModelId<EVALUATION_MODELS>,
-    ): EvaluationModelV4 {
-      if (
-        evaluationModels != null &&
-        Object.hasOwn(evaluationModels, modelId)
-      ) {
-        return resolveEvaluationModel(evaluationModels[modelId]);
+    decisionModel(modelId: ExtractModelId<DECISION_MODELS>): DecisionModelV4 {
+      if (decisionModels != null && Object.hasOwn(decisionModels, modelId)) {
+        return resolveDecisionModel(decisionModels[modelId]);
       }
 
-      const provider = fallbackProviderArg as EvaluationProvider | undefined;
-      if (typeof provider?.evaluationModel === 'function') {
-        const model = provider.evaluationModel(modelId);
+      const provider = fallbackProviderArg as DecisionProvider | undefined;
+      const factory:
+        | ((modelId: string) => Exclude<DecisionModel, string>)
+        | undefined = provider?.decisionModel ?? provider?.evaluationModel;
+      if (typeof factory === 'function') {
+        const model = factory.call(provider, modelId);
         if (model != null) {
-          return resolveEvaluationModel(model);
+          return resolveDecisionModel(model);
         }
       }
 
-      throw new NoSuchModelError({ modelId, modelType: 'evaluationModel' });
+      throw new NoSuchModelError({ modelId, modelType: 'decisionModel' });
+    },
+    evaluationModel(modelId: ExtractModelId<DECISION_MODELS>) {
+      return asEvaluationModel(this.decisionModel(modelId));
     },
     videoModel(
       modelId: ExtractModelId<VIDEO_MODELS>,

package/src/registry/index.ts

@@ -1,3 +1,6 @@
+import type { ProviderV3, ProviderV4 } from '@ai-sdk/provider';
+import type { DecisionProviderRegistry } from './provider-registry';
+
 export { customProvider } from './custom-provider';
 export { NoSuchProviderError } from './no-such-provider-error';
 export {
@@ -6,4 +9,13 @@ export {
 } from './provider-registry';
 export type { ProviderRegistryProvider } from './provider-registry';
 
-export type { EvaluationProviderRegistry as Experimental_EvaluationProviderRegistry } from './provider-registry';
+export type { DecisionProviderRegistry as Experimental_DecisionProviderRegistry } from './provider-registry';
+
+/** @deprecated Use `Experimental_DecisionProviderRegistry` instead. */
+export type Experimental_EvaluationProviderRegistry<
+  PROVIDERS extends Record<string, ProviderV4 | ProviderV3> = Record<
+    string,
+    ProviderV4 | ProviderV3
+  >,
+  SEPARATOR extends string = ':',
+> = DecisionProviderRegistry<PROVIDERS, SEPARATOR>;

package/src/registry/no-such-provider-error.ts

@@ -26,6 +26,8 @@ export class NoSuchProviderError extends NoSuchModelError {
       | 'speechModel'
       | 'rerankingModel'
       | 'videoModel'
+      | 'decisionModel'
+      /** @deprecated Use `decisionModel` instead. */
       | 'evaluationModel';
     providerId: string;
     availableProviders: string[];