ai 7.0.127 → 7.0.129

package/src/decide/decision-result.ts

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

package/src/decide/index.ts

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

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

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

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

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

package/src/error/index.ts

@@ -1,8 +1,10 @@
+import { Experimental_DecisionUnsupportedQuestionTypeError } from '@ai-sdk/provider';
+
 export {
   AISDKError,
   APICallError,
   EmptyResponseBodyError,
-  Experimental_EvaluationUnsupportedQuestionTypeError,
+  Experimental_DecisionUnsupportedQuestionTypeError,
   InvalidPromptError,
   InvalidResponseDataError,
   JSONParseError,
@@ -41,3 +43,10 @@ export { InvalidMessageRoleError } from '../prompt/invalid-message-role-error';
 export { MessageConversionError } from '../prompt/message-conversion-error';
 export { DownloadError } from '@ai-sdk/provider-utils';
 export { RetryError } from '../util/retry-error';
+
+/** @deprecated Use `Experimental_DecisionUnsupportedQuestionTypeError` instead. */
+export const Experimental_EvaluationUnsupportedQuestionTypeError =
+  Experimental_DecisionUnsupportedQuestionTypeError;
+/** @deprecated Use `Experimental_DecisionUnsupportedQuestionTypeError` instead. */
+export type Experimental_EvaluationUnsupportedQuestionTypeError =
+  Experimental_DecisionUnsupportedQuestionTypeError;

package/src/generate-object/generate-object.ts

@@ -263,6 +263,16 @@ export async function generateObject<
       };
     },
 ): Promise<GenerateObjectResult<RESULT>> {
+  logWarnings({
+    warnings: [
+      {
+        type: 'deprecated',
+        setting: 'generateObject',
+        message: 'Use generateText with an output setting instead.',
+      },
+    ],
+  });
+
   const {
     model: modelArg,
     output = 'object',

package/src/generate-object/stream-object.ts

@@ -353,6 +353,16 @@ export function streamObject<
       : never
     : never
 > {
+  logWarnings({
+    warnings: [
+      {
+        type: 'deprecated',
+        setting: 'streamObject',
+        message: 'Use streamText with an output setting instead.',
+      },
+    ],
+  });
+
   const {
     model,
     output = 'object',

package/src/generate-speech/generated-audio-file.ts

@@ -1,3 +1,4 @@
+import { InvalidResponseDataError } from '@ai-sdk/provider';
 import {
   DefaultGeneratedFile,
   type GeneratedFile,
@@ -41,10 +42,10 @@ export class DefaultGeneratedAudioFile
     }
 
     if (!format) {
-      // TODO this should be an AI SDK error
-      throw new Error(
-        'Audio format must be provided or determinable from media type',
-      );
+      throw new InvalidResponseDataError({
+        data: mediaType,
+        message: `Could not determine audio format from media type: ${mediaType}`,
+      });
     }
 
     this.format = format;

package/src/generate-speech/index.ts

@@ -1,5 +1,6 @@
 import type { SpeechResult } from './generate-speech-result';
 import { generateSpeech } from './generate-speech';
+import { logWarnings } from '../logger/log-warnings';
 
 export { generateSpeech } from './generate-speech';
 export type { SpeechResult } from './generate-speech-result';
@@ -14,7 +15,18 @@ export type {
 /**
  * @deprecated Use `generateSpeech` instead.
  */
-const experimental_generateSpeech = generateSpeech;
+const experimental_generateSpeech: typeof generateSpeech = options => {
+  logWarnings({
+    warnings: [
+      {
+        type: 'deprecated',
+        setting: 'experimental_generateSpeech',
+        message: 'Use generateSpeech instead.',
+      },
+    ],
+  });
+  return generateSpeech(options);
+};
 export { experimental_generateSpeech };
 
 /**

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

@@ -0,0 +1,127 @@
+import type { Context, ToolSet } from '@ai-sdk/provider-utils';
+import { NoOutputGeneratedError } from '../error/no-output-generated-error';
+import type { LanguageModelUsage } from '../types/usage';
+import type { GenerateTextResult } from './generate-text-result';
+import type { Output } from './output';
+import type { InferCompleteOutput } from './output-utils';
+import { convertToReasoningOutputs } from './reasoning-output';
+import type { ResponseMessage } from './response-message';
+
+export 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/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';
@@ -1100,7 +1099,9 @@ export async function generateText<
               > = {};
               const blockedToolCallIds = new Set<string>();
 
-              const generatedFileDataCache = new WeakMap();
+              const generatedFileDataCache: Parameters<
+                typeof convertLanguageModelContent
+              >[0]['generatedFileDataCache'] = new WeakMap();
               const modelCallContent = await convertLanguageModelContent({
                 content: currentModelResponse.content,
                 toolCalls: stepToolCalls,
@@ -1687,122 +1688,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/generate-text/tool-approval-signature.ts

@@ -3,12 +3,15 @@ import { hashCanonical, toBase64url } from '../util/canonical-hash';
 
 const encoder = new TextEncoder();
 
-function fromBase64url(str: string): Uint8Array {
+function fromBase64url(str: string) {
   return convertBase64ToUint8Array(str);
 }
 
 async function importKey(secret: string | Uint8Array): Promise<CryptoKey> {
-  const keyData = typeof secret === 'string' ? encoder.encode(secret) : secret;
+  const keyData =
+    typeof secret === 'string'
+      ? encoder.encode(secret)
+      : (secret as Uint8Array<ArrayBuffer>);
   return crypto.subtle.importKey(
     'raw',
     keyData,
@@ -26,7 +29,7 @@ function buildPayload(
   toolCallId: string,
   toolName: string,
   inputDigest: string,
-): Uint8Array {
+) {
   return encoder.encode(
     JSON.stringify([
       'ai-sdk-tool-approval-v1',
@@ -49,7 +52,7 @@ function buildLegacyPayload(
   toolCallId: string,
   toolName: string,
   inputDigest: string,
-): Uint8Array {
+) {
   return encoder.encode(
     `${approvalId}\n${toolCallId}\n${toolName}\n${inputDigest}`,
   );

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
    */
@@ -18,7 +18,8 @@ declare global {
   /**
    * The warning logger to use for the AI SDK.
    *
-   * If not set, the default logger is the console.warn function.
+   * If not set, warnings use process.emitWarning when available, otherwise
+   * console.warn. Deprecations are emitted once per code by the default logger.
    *
    * If set to false, no warnings are logged.
    */

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';