ai 7.0.127 → 7.0.128

package/src/{evaluate/evaluate.ts → decide/decide.ts}

@@ -1,6 +1,6 @@
 import {
-  Experimental_EvaluationUnsupportedQuestionTypeError as EvaluationUnsupportedQuestionTypeError,
-  type Experimental_EvaluationModelV4CallOptions as EvaluationModelV4CallOptions,
+  Experimental_DecisionUnsupportedQuestionTypeError as DecisionUnsupportedQuestionTypeError,
+  type Experimental_DecisionModelV4CallOptions as DecisionModelV4CallOptions,
 } from '@ai-sdk/provider';
 import {
   createIdGenerator,
@@ -8,33 +8,33 @@ import {
   type Context,
   type ProviderOptions,
 } from '@ai-sdk/provider-utils';
-import { resolveEvaluationModel } from '../model/resolve-model';
+import { resolveDecisionModel } from '../model/resolve-model';
 import { logWarnings } from '../logger/log-warnings';
 import type { TelemetryOptions } from '../telemetry/telemetry-options';
 import type { Callback } from '../util/callback';
 import { notify } from '../util/notify';
 import { prepareRetries } from '../util/prepare-retries';
 import { VERSION } from '../version';
-import type { EvaluateEndEvent, EvaluateStartEvent } from './evaluate-events';
+import type { DecideEndEvent, DecideStartEvent } from './decide-events';
 import type {
-  EvaluationModel,
-  EvaluationQuestion,
-  EvaluationResult,
-} from './evaluation-result';
+  DecisionModel,
+  DecisionQuestion,
+  DecisionResult,
+} from './decision-result';
 import { createRestrictedTelemetryDispatcher } from './restricted-telemetry-dispatcher';
 import {
-  validateEvaluationInput,
-  validateEvaluationAnswers,
-} from './validate-evaluation';
+  validateDecisionInput,
+  validateDecisionAnswers,
+} from './validate-decision';
 
 const originalGenerateCallId = createIdGenerator({
   prefix: 'call',
   size: 24,
 });
 
-/** Evaluate typed questions against one shared state. Experimental. */
-export async function evaluate<
-  const QUESTIONS extends Record<string, EvaluationQuestion>,
+/** Decide answers to typed questions against one shared state. Experimental. */
+export async function decide<
+  const QUESTIONS extends Record<string, DecisionQuestion>,
   RUNTIME_CONTEXT extends Context = Context,
 >({
   model: modelArg,
@@ -50,9 +50,9 @@ export async function evaluate<
   onEnd,
   _internal: { generateCallId = originalGenerateCallId } = {},
 }: {
-  /** An evaluation model instance or an ID resolved by the configured default provider. */
-  model: EvaluationModel;
-  state: EvaluationModelV4CallOptions['state'];
+  /** A decision model instance or an ID resolved by the configured default provider. */
+  model: DecisionModel;
+  state: DecisionModelV4CallOptions['state'];
   questions: QUESTIONS;
   /** Maximum retries for transient provider failures. Defaults to 2. */
   maxRetries?: number;
@@ -63,22 +63,22 @@ export async function evaluate<
   telemetry?: TelemetryOptions<RUNTIME_CONTEXT>;
   /** User-defined runtime context. Treat runtime context as immutable. */
   runtimeContext?: RUNTIME_CONTEXT;
-  /** Called when the evaluate operation begins. */
-  onStart?: Callback<EvaluateStartEvent<RUNTIME_CONTEXT>>;
-  /** Called when the evaluate operation completes. */
-  onEnd?: Callback<EvaluateEndEvent<RUNTIME_CONTEXT>>;
+  /** Called when the decide operation begins. */
+  onStart?: Callback<DecideStartEvent<RUNTIME_CONTEXT>>;
+  /** Called when the decide operation completes. */
+  onEnd?: Callback<DecideEndEvent<RUNTIME_CONTEXT>>;
   /** Internal. For test use only. May change without notice. */
   _internal?: {
     generateCallId?: () => string;
   };
-}): Promise<EvaluationResult<QUESTIONS>> {
-  const model = resolveEvaluationModel(modelArg);
+}): Promise<DecisionResult<QUESTIONS>> {
+  const model = resolveDecisionModel(modelArg);
 
-  validateEvaluationInput({ state, questions });
+  validateDecisionInput({ state, questions });
 
   for (const [questionId, question] of Object.entries(questions)) {
     if (!model.supportedQuestionTypes.includes(question.type)) {
-      throw new EvaluationUnsupportedQuestionTypeError({
+      throw new DecisionUnsupportedQuestionTypeError({
         questionId,
         questionType: question.type,
         provider: model.provider,
@@ -101,7 +101,7 @@ export async function evaluate<
       await execute());
   const startEvent = {
     callId,
-    operationId: 'ai.evaluate' as const,
+    operationId: 'ai.decide' as const,
     runtimeContext,
     provider: model.provider,
     modelId: model.modelId,
@@ -112,7 +112,7 @@ export async function evaluate<
     providerOptions,
   };
   return await runInTracingChannelSpan({
-    type: 'experimental_evaluate',
+    type: 'experimental_decide',
     event: startEvent,
     execute: async () => {
       await notify({
@@ -123,7 +123,7 @@ export async function evaluate<
       try {
         const modelCallEvent = {
           callId,
-          operationId: 'ai.evaluate.doEvaluate' as const,
+          operationId: 'ai.decide.doDecide' as const,
           provider: model.provider,
           modelId: model.modelId,
           state,
@@ -132,12 +132,12 @@ export async function evaluate<
         await notify({
           event: modelCallEvent,
           callbacks: [
-            telemetryDispatcher.experimental_onEvaluationModelCallStart,
+            telemetryDispatcher.experimental_onDecisionModelCallStart,
           ],
         });
         const result = await retry(async () => {
           abortSignal?.throwIfAborted();
-          return await model.doEvaluate({
+          return await model.doDecide({
             state,
             questions,
             abortSignal,
@@ -147,16 +147,14 @@ export async function evaluate<
         });
 
         abortSignal?.throwIfAborted();
-        validateEvaluationAnswers({
+        validateDecisionAnswers({
           questions,
           answers: result.answers,
           rounding: result.rounding,
         });
         await notify({
           event: { ...modelCallEvent, ...result },
-          callbacks: [
-            telemetryDispatcher.experimental_onEvaluationModelCallEnd,
-          ],
+          callbacks: [telemetryDispatcher.experimental_onDecisionModelCallEnd],
         });
 
         logWarnings({
@@ -167,8 +165,8 @@ export async function evaluate<
 
         const inputTokens = result.usage?.inputTokens;
         const outputTokens = result.usage?.outputTokens;
-        const evaluationResult: EvaluationResult<QUESTIONS> = {
-          answers: result.answers as EvaluationResult<QUESTIONS>['answers'],
+        const decisionResult: DecisionResult<QUESTIONS> = {
+          answers: result.answers as DecisionResult<QUESTIONS>['answers'],
           usage: {
             inputTokens,
             outputTokens,
@@ -188,11 +186,11 @@ export async function evaluate<
         };
 
         await notify({
-          event: { ...startEvent, ...evaluationResult },
+          event: { ...startEvent, ...decisionResult },
           callbacks: [onEnd, telemetryDispatcher.onEnd],
         });
 
-        return evaluationResult;
+        return decisionResult;
       } catch (error) {
         await telemetryDispatcher.onError?.({ callId, error });
         throw error;

package/src/decide/decision-provider.ts

@@ -0,0 +1,11 @@
+import type {
+  Experimental_DecisionModelV4 as DecisionModelV4,
+  Experimental_EvaluationModelV4 as EvaluationModelV4,
+} from '@ai-sdk/provider';
+
+/** Structural extension; decision is not part of the stable provider contract. */
+export type DecisionProvider = {
+  decisionModel?: (modelId: string) => DecisionModelV4;
+  /** @deprecated Use `decisionModel` instead. */
+  evaluationModel?: (modelId: string) => EvaluationModelV4;
+};

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-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-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;
+  }
+}