ima2-gen 3.20.0 → 3.21.0

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

@@ -1,1535 +0,0 @@
-import {
-  LanguageModelV3,
-  LanguageModelV3Content,
-  LanguageModelV3ToolCall,
-  LanguageModelV3ToolChoice,
-} from '@ai-sdk/provider';
-import {
-  createIdGenerator,
-  getErrorMessage,
-  IdGenerator,
-  ProviderOptions,
-  SystemModelMessage,
-  ToolApprovalResponse,
-  withUserAgentSuffix,
-} from '@ai-sdk/provider-utils';
-import { Tracer } from '@opentelemetry/api';
-import { NoOutputGeneratedError } from '../error';
-import { notify } from '../util/notify';
-import { logWarnings } from '../logger/log-warnings';
-import { resolveLanguageModel } from '../model/resolve-model';
-import { ModelMessage } from '../prompt';
-import {
-  CallSettings,
-  getStepTimeoutMs,
-  getTotalTimeoutMs,
-  TimeoutConfiguration,
-} from '../prompt/call-settings';
-import { convertToLanguageModelPrompt } from '../prompt/convert-to-language-model-prompt';
-import { createToolModelOutput } from '../prompt/create-tool-model-output';
-import { prepareCallSettings } from '../prompt/prepare-call-settings';
-import { prepareToolsAndToolChoice } from '../prompt/prepare-tools-and-tool-choice';
-import { Prompt } from '../prompt/prompt';
-import { standardizePrompt } from '../prompt/standardize-prompt';
-import { wrapGatewayError } from '../prompt/wrap-gateway-error';
-import { ToolCallNotFoundForApprovalError } from '../error/tool-call-not-found-for-approval-error';
-import { assembleOperationName } from '../telemetry/assemble-operation-name';
-import { getBaseTelemetryAttributes } from '../telemetry/get-base-telemetry-attributes';
-import { getTracer } from '../telemetry/get-tracer';
-import { recordSpan } from '../telemetry/record-span';
-import { selectTelemetryAttributes } from '../telemetry/select-telemetry-attributes';
-import { stringifyForTelemetry } from '../telemetry/stringify-for-telemetry';
-import { getGlobalTelemetryIntegration } from '../telemetry/get-global-telemetry-integration';
-import { TelemetrySettings } from '../telemetry/telemetry-settings';
-import {
-  LanguageModel,
-  LanguageModelRequestMetadata,
-  ToolChoice,
-} from '../types';
-import {
-  addLanguageModelUsage,
-  asLanguageModelUsage,
-  LanguageModelUsage,
-} from '../types/usage';
-import { asArray } from '../util/as-array';
-import { DownloadFunction } from '../util/download/download-function';
-import { mergeObjects } from '../util/merge-objects';
-import { prepareRetries } from '../util/prepare-retries';
-import { VERSION } from '../version';
-import type {
-  OnFinishEvent,
-  OnStartEvent,
-  OnStepFinishEvent,
-  OnStepStartEvent,
-  OnToolCallFinishEvent,
-  OnToolCallStartEvent,
-} from './callback-events';
-import { collectToolApprovals } from './collect-tool-approvals';
-import { ContentPart } from './content-part';
-import { executeToolCall } from './execute-tool-call';
-import { extractReasoningContent } from './extract-reasoning-content';
-import { extractTextContent } from './extract-text-content';
-import { GenerateTextResult } from './generate-text-result';
-import { DefaultGeneratedFile } from './generated-file';
-import { isApprovalNeeded } from './is-approval-needed';
-import { Output, text } from './output';
-import { InferCompleteOutput } from './output-utils';
-import { parseToolCall } from './parse-tool-call';
-import { PrepareStepFunction } from './prepare-step';
-import { ResponseMessage } from './response-message';
-import { DefaultStepResult, StepResult } from './step-result';
-import {
-  isStopConditionMet,
-  stepCountIs,
-  StopCondition,
-} from './stop-condition';
-import { toResponseMessages } from './to-response-messages';
-import { ToolApprovalRequestOutput } from './tool-approval-request-output';
-import { TypedToolCall } from './tool-call';
-import { ToolCallRepairFunction } from './tool-call-repair-function';
-import { TypedToolError } from './tool-error';
-import { ToolOutput } from './tool-output';
-import { TypedToolResult } from './tool-result';
-import { ToolSet } from './tool-set';
-import { mergeAbortSignals } from '../util/merge-abort-signals';
-
-const originalGenerateId = createIdGenerator({
-  prefix: 'aitxt',
-  size: 24,
-});
-
-/**
- * Include settings for generateText (requestBody and responseBody).
- */
-type GenerateTextIncludeSettings = {
-  requestBody?: boolean;
-  responseBody?: boolean;
-};
-
-/**
- * Callback that is set using the `experimental_onStart` option.
- *
- * Called when the generateText operation begins, before any LLM calls.
- * Use this callback for logging, analytics, or initializing state at the
- * start of a generation.
- *
- * @param event - The event object containing generation configuration.
- */
-export type GenerateTextOnStartCallback<
-  TOOLS extends ToolSet = ToolSet,
-  OUTPUT extends Output = Output,
-> = (
-  event: OnStartEvent<TOOLS, OUTPUT, GenerateTextIncludeSettings>,
-) => PromiseLike<void> | void;
-
-/**
- * Callback that is set using the `experimental_onStepStart` option.
- *
- * Called when a step (LLM call) begins, before the provider is called.
- * Each step represents a single LLM invocation. Multiple steps occur when
- * using tool calls (the model may be called multiple times in a loop).
- *
- * @param event - The event object containing step configuration.
- */
-export type GenerateTextOnStepStartCallback<
-  TOOLS extends ToolSet = ToolSet,
-  OUTPUT extends Output = Output,
-> = (
-  event: OnStepStartEvent<TOOLS, OUTPUT, GenerateTextIncludeSettings>,
-) => PromiseLike<void> | void;
-
-/**
- * Callback that is set using the `experimental_onToolCallStart` option.
- *
- * Called when a tool execution begins, before the tool's `execute` function is invoked.
- * Use this for logging tool invocations, tracking tool usage, or pre-execution validation.
- *
- * @param event - The event object containing tool call information.
- */
-export type GenerateTextOnToolCallStartCallback<
-  TOOLS extends ToolSet = ToolSet,
-> = (event: OnToolCallStartEvent<TOOLS>) => PromiseLike<void> | void;
-
-/**
- * Callback that is set using the `experimental_onToolCallFinish` option.
- *
- * Called when a tool execution completes, either successfully or with an error.
- * Use this for logging tool results, tracking execution time, or error handling.
- *
- * The event uses a discriminated union on the `success` field:
- * - When `success: true`: `output` contains the tool result, `error` is never present.
- * - When `success: false`: `error` contains the error, `output` is never present.
- *
- * @param event - The event object containing tool call result information.
- */
-export type GenerateTextOnToolCallFinishCallback<
-  TOOLS extends ToolSet = ToolSet,
-> = (event: OnToolCallFinishEvent<TOOLS>) => PromiseLike<void> | void;
-
-/**
- * Callback that is set using the `onStepFinish` option.
- *
- * Called when a step (LLM call) completes. The event includes all step result
- * properties (text, tool calls, usage, etc.) along with additional metadata.
- *
- * @param stepResult - The result of the step.
- */
-export type GenerateTextOnStepFinishCallback<TOOLS extends ToolSet> = (
-  event: OnStepFinishEvent<TOOLS>,
-) => Promise<void> | void;
-
-/**
- * Callback that is set using the `onFinish` option.
- *
- * Called when the entire generation completes (all steps finished).
- * The event includes the final step's result properties along with
- * aggregated data from all steps.
- *
- * @param event - The final result along with aggregated step data.
- */
-export type GenerateTextOnFinishCallback<TOOLS extends ToolSet> = (
-  event: OnFinishEvent<TOOLS>,
-) => PromiseLike<void> | void;
-
-/**
- * Generate a text and call tools for a given prompt using a language model.
- *
- * This function does not stream the output. If you want to stream the output, use `streamText` instead.
- *
- * @param model - The language model to use.
- *
- * @param tools - Tools that are accessible to and can be called by the model. The model needs to support calling tools.
- * @param toolChoice - The tool choice strategy. Default: 'auto'.
- *
- * @param system - A system message that will be part of the prompt.
- * @param prompt - A simple text prompt. You can either use `prompt` or `messages` but not both.
- * @param messages - A list of messages. You can either use `prompt` or `messages` but not both.
- *
- * @param maxOutputTokens - Maximum number of tokens to generate.
- * @param temperature - Temperature setting.
- * The value is passed through to the provider. The range depends on the provider and model.
- * It is recommended to set either `temperature` or `topP`, but not both.
- * @param topP - Nucleus sampling.
- * The value is passed through to the provider. The range depends on the provider and model.
- * It is recommended to set either `temperature` or `topP`, but not both.
- * @param topK - Only sample from the top K options for each subsequent token.
- * Used to remove "long tail" low probability responses.
- * Recommended for advanced use cases only. You usually only need to use temperature.
- * @param presencePenalty - Presence penalty setting.
- * It affects the likelihood of the model to repeat information that is already in the prompt.
- * The value is passed through to the provider. The range depends on the provider and model.
- * @param frequencyPenalty - Frequency penalty setting.
- * It affects the likelihood of the model to repeatedly use the same words or phrases.
- * The value is passed through to the provider. The range depends on the provider and model.
- * @param stopSequences - Stop sequences.
- * If set, the model will stop generating text when one of the stop sequences is generated.
- * @param seed - The seed (integer) to use for random sampling.
- * If set and supported by the model, calls will generate deterministic results.
- *
- * @param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
- * @param abortSignal - An optional abort signal that can be used to cancel the call.
- * @param timeout - An optional timeout in milliseconds. The call will be aborted if it takes longer than the specified timeout.
- * @param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
- *
- * @param experimental_context - User-defined context object that flows through the entire generation lifecycle.
- * @param experimental_onStart - Callback invoked when generation begins, before any LLM calls.
- * @param experimental_onStepStart - Callback invoked when each step begins, before the provider is called.
- * Receives step number, messages (in ModelMessage format), tools, and context.
- * @param experimental_onToolCallStart - Callback invoked before each tool execution begins.
- * Receives tool name, call ID, input, and context.
- * @param experimental_onToolCallFinish - Callback invoked after each tool execution completes.
- * Uses a discriminated union: check `success` to determine if `output` or `error` is present.
- * @param onStepFinish - Callback that is called when each step (LLM call) is finished, including intermediate steps.
- * @param onFinish - Callback that is called when all steps are finished and the response is complete.
- *
- * @returns
- * A result object that contains the generated text, the results of the tool calls, and additional information.
- */
-export async function generateText<
-  TOOLS extends ToolSet,
-  OUTPUT extends Output = Output<string, string>,
->({
-  model: modelArg,
-  tools,
-  toolChoice,
-  system,
-  prompt,
-  messages,
-  maxRetries: maxRetriesArg,
-  abortSignal,
-  timeout,
-  headers,
-  stopWhen = stepCountIs(1),
-  experimental_output,
-  output = experimental_output,
-  experimental_telemetry: telemetry,
-  providerOptions,
-  experimental_activeTools,
-  activeTools = experimental_activeTools,
-  experimental_prepareStep,
-  prepareStep = experimental_prepareStep,
-  experimental_repairToolCall: repairToolCall,
-  experimental_download: download,
-  experimental_context,
-  experimental_include: include,
-  _internal: { generateId = originalGenerateId } = {},
-  experimental_onStart: onStart,
-  experimental_onStepStart: onStepStart,
-  experimental_onToolCallStart: onToolCallStart,
-  experimental_onToolCallFinish: onToolCallFinish,
-  onStepFinish,
-  onFinish,
-  ...settings
-}: CallSettings &
-  Prompt & {
-    /**
-     * The language model to use.
-     */
-    model: LanguageModel;
-
-    /**
-     * The tools that the model can call. The model needs to support calling tools.
-     */
-    tools?: TOOLS;
-
-    /**
-     * The tool choice strategy. Default: 'auto'.
-     */
-    toolChoice?: ToolChoice<NoInfer<TOOLS>>;
-
-    /**
-     * Condition for stopping the generation when there are tool results in the last step.
-     * When the condition is an array, any of the conditions can be met to stop the generation.
-     *
-     * @default stepCountIs(1)
-     */
-    stopWhen?:
-      | StopCondition<NoInfer<TOOLS>>
-      | Array<StopCondition<NoInfer<TOOLS>>>;
-
-    /**
-     * Optional telemetry configuration (experimental).
-     */
-    experimental_telemetry?: TelemetrySettings;
-
-    /**
-     * Additional provider-specific options. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
-     */
-    providerOptions?: ProviderOptions;
-
-    /**
-     * @deprecated Use `activeTools` instead.
-     */
-    experimental_activeTools?: Array<keyof NoInfer<TOOLS>>;
-
-    /**
-     * Limits the tools that are available for the model to call without
-     * changing the tool call and result types in the result.
-     */
-    activeTools?: Array<keyof NoInfer<TOOLS>>;
-
-    /**
-     * Optional specification for parsing structured outputs from the LLM response.
-     */
-    output?: OUTPUT;
-
-    /**
-     * Optional specification for parsing structured outputs from the LLM response.
-     *
-     * @deprecated Use `output` instead.
-     */
-    experimental_output?: OUTPUT;
-
-    /**
-     * Custom download function to use for URLs.
-     *
-     * By default, files are downloaded if the model does not support the URL for the given media type.
-     */
-    experimental_download?: DownloadFunction | undefined;
-
-    /**
-     * @deprecated Use `prepareStep` instead.
-     */
-    experimental_prepareStep?: PrepareStepFunction<NoInfer<TOOLS>>;
-
-    /**
-     * Optional function that you can use to provide different settings for a step.
-     */
-    prepareStep?: PrepareStepFunction<NoInfer<TOOLS>>;
-
-    /**
-     * A function that attempts to repair a tool call that failed to parse.
-     */
-    experimental_repairToolCall?: ToolCallRepairFunction<NoInfer<TOOLS>>;
-
-    /**
-     * Callback that is called when the generateText operation begins,
-     * before any LLM calls are made.
-     */
-    experimental_onStart?: GenerateTextOnStartCallback<NoInfer<TOOLS>, OUTPUT>;
-
-    /**
-     * Callback that is called when a step (LLM call) begins,
-     * before the provider is called.
-     */
-    experimental_onStepStart?: GenerateTextOnStepStartCallback<
-      NoInfer<TOOLS>,
-      OUTPUT
-    >;
-
-    /**
-     * Callback that is called right before a tool's execute function runs.
-     */
-    experimental_onToolCallStart?: GenerateTextOnToolCallStartCallback<
-      NoInfer<TOOLS>
-    >;
-
-    /**
-     * Callback that is called right after a tool's execute function completes (or errors).
-     */
-    experimental_onToolCallFinish?: GenerateTextOnToolCallFinishCallback<
-      NoInfer<TOOLS>
-    >;
-
-    /**
-     * Callback that is called when each step (LLM call) is finished, including intermediate steps.
-     */
-    onStepFinish?: GenerateTextOnStepFinishCallback<NoInfer<TOOLS>>;
-
-    /**
-     * Callback that is called when all steps are finished and the response is complete.
-     */
-    onFinish?: GenerateTextOnFinishCallback<NoInfer<TOOLS>>;
-
-    /**
-     * Context that is passed into tool execution.
-     *
-     * Experimental (can break in patch releases).
-     *
-     * @default undefined
-     */
-    experimental_context?: unknown;
-
-    /**
-     * Settings for controlling what data is included in step results.
-     * Disabling inclusion can help reduce memory usage when processing
-     * large payloads like images.
-     *
-     * By default, all data is included for backwards compatibility.
-     */
-    experimental_include?: {
-      /**
-       * Whether to retain the request body in step results.
-       * The request body can be large when sending images or files.
-       * @default true
-       */
-      requestBody?: boolean;
-
-      /**
-       * Whether to retain the response body in step results.
-       * @default true
-       */
-      responseBody?: boolean;
-    };
-
-    /**
-     * Internal. For test use only. May change without notice.
-     */
-    _internal?: {
-      generateId?: IdGenerator;
-    };
-  }): Promise<GenerateTextResult<TOOLS, OUTPUT>> {
-  const model = resolveLanguageModel(modelArg);
-  const createGlobalTelemetry = getGlobalTelemetryIntegration<TOOLS, OUTPUT>();
-  const stopConditions = asArray(stopWhen);
-
-  const totalTimeoutMs = getTotalTimeoutMs(timeout);
-  const stepTimeoutMs = getStepTimeoutMs(timeout);
-  const stepAbortController =
-    stepTimeoutMs != null ? new AbortController() : undefined;
-  const mergedAbortSignal = mergeAbortSignals(
-    abortSignal,
-    totalTimeoutMs != null ? AbortSignal.timeout(totalTimeoutMs) : undefined,
-    stepAbortController?.signal,
-  );
-
-  const { maxRetries, retry } = prepareRetries({
-    maxRetries: maxRetriesArg,
-    abortSignal: mergedAbortSignal,
-  });
-
-  const callSettings = prepareCallSettings(settings);
-
-  const headersWithUserAgent = withUserAgentSuffix(
-    headers ?? {},
-    `ai/${VERSION}`,
-  );
-
-  const baseTelemetryAttributes = getBaseTelemetryAttributes({
-    model,
-    telemetry,
-    headers: headersWithUserAgent,
-    settings: { ...callSettings, maxRetries },
-  });
-
-  const modelInfo = { provider: model.provider, modelId: model.modelId };
-
-  const initialPrompt = await standardizePrompt({
-    system,
-    prompt,
-    messages,
-  } as Prompt);
-
-  const globalTelemetry = createGlobalTelemetry(telemetry?.integrations);
-
-  await notify({
-    event: {
-      model: modelInfo,
-      system,
-      prompt,
-      messages,
-      tools,
-      toolChoice,
-      activeTools,
-      maxOutputTokens: callSettings.maxOutputTokens,
-      temperature: callSettings.temperature,
-      topP: callSettings.topP,
-      topK: callSettings.topK,
-      presencePenalty: callSettings.presencePenalty,
-      frequencyPenalty: callSettings.frequencyPenalty,
-      stopSequences: callSettings.stopSequences,
-      seed: callSettings.seed,
-      maxRetries,
-      timeout,
-      headers,
-      providerOptions,
-      stopWhen,
-      output,
-      abortSignal,
-      include,
-      functionId: telemetry?.functionId,
-      metadata: telemetry?.metadata as Record<string, unknown> | undefined,
-      experimental_context,
-    },
-    callbacks: [
-      onStart,
-      globalTelemetry.onStart as
-        | undefined
-        | GenerateTextOnStartCallback<TOOLS, OUTPUT>,
-    ],
-  });
-
-  const tracer = getTracer(telemetry);
-
-  try {
-    return await recordSpan({
-      name: 'ai.generateText',
-      attributes: selectTelemetryAttributes({
-        telemetry,
-        attributes: {
-          ...assembleOperationName({
-            operationId: 'ai.generateText',
-            telemetry,
-          }),
-          ...baseTelemetryAttributes,
-          // model:
-          'ai.model.provider': model.provider,
-          'ai.model.id': model.modelId,
-          // specific settings that only make sense on the outer level:
-          'ai.prompt': {
-            input: () => JSON.stringify({ system, prompt, messages }),
-          },
-        },
-      }),
-      tracer,
-      fn: async span => {
-        const initialMessages = initialPrompt.messages;
-        const responseMessages: Array<ResponseMessage> = [];
-
-        const { approvedToolApprovals, deniedToolApprovals } =
-          collectToolApprovals<TOOLS>({ messages: initialMessages });
-
-        const localApprovedToolApprovals = approvedToolApprovals.filter(
-          toolApproval => !toolApproval.toolCall.providerExecuted,
-        );
-
-        if (
-          deniedToolApprovals.length > 0 ||
-          localApprovedToolApprovals.length > 0
-        ) {
-          const toolOutputs = await executeTools({
-            toolCalls: localApprovedToolApprovals.map(
-              toolApproval => toolApproval.toolCall,
-            ),
-            tools: tools as TOOLS,
-            tracer,
-            telemetry,
-            messages: initialMessages,
-            abortSignal: mergedAbortSignal,
-            experimental_context,
-            stepNumber: 0,
-            model: modelInfo,
-            onToolCallStart: [
-              onToolCallStart,
-              globalTelemetry.onToolCallStart as
-                | undefined
-                | GenerateTextOnToolCallStartCallback<TOOLS>,
-            ],
-            onToolCallFinish: [
-              onToolCallFinish,
-              globalTelemetry.onToolCallFinish as
-                | undefined
-                | GenerateTextOnToolCallFinishCallback<TOOLS>,
-            ],
-          });
-
-          const toolContent: Array<any> = [];
-
-          // add regular tool results for approved tool calls:
-          for (const output of toolOutputs) {
-            const modelOutput = await createToolModelOutput({
-              toolCallId: output.toolCallId,
-              input: output.input,
-              tool: tools?.[output.toolName],
-              output:
-                output.type === 'tool-result' ? output.output : output.error,
-              errorMode: output.type === 'tool-error' ? 'text' : 'none',
-            });
-
-            toolContent.push({
-              type: 'tool-result' as const,
-              toolCallId: output.toolCallId,
-              toolName: output.toolName,
-              output: modelOutput,
-            });
-          }
-
-          // add execution denied tool results for all denied tool approvals:
-          for (const toolApproval of deniedToolApprovals) {
-            toolContent.push({
-              type: 'tool-result' as const,
-              toolCallId: toolApproval.toolCall.toolCallId,
-              toolName: toolApproval.toolCall.toolName,
-              output: {
-                type: 'execution-denied' as const,
-                reason: toolApproval.approvalResponse.reason,
-                // For provider-executed tools, include approvalId so provider can correlate
-                ...(toolApproval.toolCall.providerExecuted && {
-                  providerOptions: {
-                    openai: {
-                      approvalId: toolApproval.approvalResponse.approvalId,
-                    },
-                  },
-                }),
-              },
-            });
-          }
-
-          responseMessages.push({
-            role: 'tool',
-            content: toolContent,
-          });
-        }
-
-        // Forward provider-executed approval responses to the provider
-        const providerExecutedToolApprovals = [
-          ...approvedToolApprovals,
-          ...deniedToolApprovals,
-        ].filter(toolApproval => toolApproval.toolCall.providerExecuted);
-
-        if (providerExecutedToolApprovals.length > 0) {
-          responseMessages.push({
-            role: 'tool',
-            content: providerExecutedToolApprovals.map(
-              toolApproval =>
-                ({
-                  type: 'tool-approval-response',
-                  approvalId: toolApproval.approvalResponse.approvalId,
-                  approved: toolApproval.approvalResponse.approved,
-                  reason: toolApproval.approvalResponse.reason,
-                  providerExecuted: true,
-                }) satisfies ToolApprovalResponse,
-            ),
-          });
-        }
-
-        const callSettings = prepareCallSettings(settings);
-
-        let currentModelResponse: Awaited<
-          ReturnType<LanguageModelV3['doGenerate']>
-        > & { response: { id: string; timestamp: Date; modelId: string } };
-        let clientToolCalls: Array<TypedToolCall<TOOLS>> = [];
-        let clientToolOutputs: Array<ToolOutput<TOOLS>> = [];
-        const steps: GenerateTextResult<TOOLS, OUTPUT>['steps'] = [];
-
-        // Track provider-executed tool calls that support deferred results
-        // (e.g., code_execution in programmatic tool calling scenarios).
-        // These tools may not return their results in the same turn as their call.
-        const pendingDeferredToolCalls = new Map<
-          string,
-          { toolName: string }
-        >();
-
-        do {
-          // Set up step timeout if configured
-          const stepTimeoutId =
-            stepTimeoutMs != null
-              ? setTimeout(() => stepAbortController!.abort(), stepTimeoutMs)
-              : undefined;
-
-          try {
-            const stepInputMessages = [...initialMessages, ...responseMessages];
-
-            const prepareStepResult = await prepareStep?.({
-              model,
-              steps,
-              stepNumber: steps.length,
-              messages: stepInputMessages,
-              experimental_context,
-            });
-
-            const stepModel = resolveLanguageModel(
-              prepareStepResult?.model ?? model,
-            );
-            const stepModelInfo = {
-              provider: stepModel.provider,
-              modelId: stepModel.modelId,
-            };
-
-            const promptMessages = await convertToLanguageModelPrompt({
-              prompt: {
-                system: prepareStepResult?.system ?? initialPrompt.system,
-                messages: prepareStepResult?.messages ?? stepInputMessages,
-              },
-              supportedUrls: await stepModel.supportedUrls,
-              download,
-            });
-
-            experimental_context =
-              prepareStepResult?.experimental_context ?? experimental_context;
-
-            const stepActiveTools =
-              prepareStepResult?.activeTools ?? activeTools;
-
-            const { toolChoice: stepToolChoice, tools: stepTools } =
-              await prepareToolsAndToolChoice({
-                tools,
-                toolChoice: prepareStepResult?.toolChoice ?? toolChoice,
-                activeTools: stepActiveTools,
-              });
-
-            const stepMessages =
-              prepareStepResult?.messages ?? stepInputMessages;
-
-            const stepSystem =
-              prepareStepResult?.system ?? initialPrompt.system;
-
-            const stepProviderOptions = mergeObjects(
-              providerOptions,
-              prepareStepResult?.providerOptions,
-            );
-
-            await notify({
-              event: {
-                stepNumber: steps.length,
-                model: stepModelInfo,
-                system: stepSystem,
-                messages: stepMessages,
-                tools,
-                toolChoice: stepToolChoice,
-                activeTools: stepActiveTools,
-                steps: [...steps],
-                providerOptions: stepProviderOptions,
-                timeout,
-                headers,
-                stopWhen,
-                output,
-                abortSignal,
-                include,
-                functionId: telemetry?.functionId,
-                metadata: telemetry?.metadata as
-                  | Record<string, unknown>
-                  | undefined,
-                experimental_context,
-              },
-              callbacks: [
-                onStepStart,
-                globalTelemetry.onStepStart as
-                  | undefined
-                  | GenerateTextOnStepStartCallback<TOOLS, OUTPUT>,
-              ],
-            });
-
-            currentModelResponse = await retry(() =>
-              recordSpan({
-                name: 'ai.generateText.doGenerate',
-                attributes: selectTelemetryAttributes({
-                  telemetry,
-                  attributes: {
-                    ...assembleOperationName({
-                      operationId: 'ai.generateText.doGenerate',
-                      telemetry,
-                    }),
-                    ...baseTelemetryAttributes,
-                    // model:
-                    'ai.model.provider': stepModel.provider,
-                    'ai.model.id': stepModel.modelId,
-                    // prompt:
-                    'ai.prompt.messages': {
-                      input: () => stringifyForTelemetry(promptMessages),
-                    },
-                    'ai.prompt.tools': {
-                      // convert the language model level tools:
-                      input: () => stepTools?.map(tool => JSON.stringify(tool)),
-                    },
-                    'ai.prompt.toolChoice': {
-                      input: () =>
-                        stepToolChoice != null
-                          ? JSON.stringify(stepToolChoice)
-                          : undefined,
-                    },
-
-                    // standardized gen-ai llm span attributes:
-                    'gen_ai.system': stepModel.provider,
-                    'gen_ai.request.model': stepModel.modelId,
-                    'gen_ai.request.frequency_penalty':
-                      settings.frequencyPenalty,
-                    'gen_ai.request.max_tokens': settings.maxOutputTokens,
-                    'gen_ai.request.presence_penalty': settings.presencePenalty,
-                    'gen_ai.request.stop_sequences': settings.stopSequences,
-                    'gen_ai.request.temperature':
-                      settings.temperature ?? undefined,
-                    'gen_ai.request.top_k': settings.topK,
-                    'gen_ai.request.top_p': settings.topP,
-                  },
-                }),
-                tracer,
-                fn: async span => {
-                  const result = await stepModel.doGenerate({
-                    ...callSettings,
-                    tools: stepTools,
-                    toolChoice: stepToolChoice,
-                    responseFormat: await output?.responseFormat,
-                    prompt: promptMessages,
-                    providerOptions: stepProviderOptions,
-                    abortSignal: mergedAbortSignal,
-                    headers: headersWithUserAgent,
-                  });
-
-                  // Fill in default values:
-                  const responseData = {
-                    id: result.response?.id ?? generateId(),
-                    timestamp: result.response?.timestamp ?? new Date(),
-                    modelId: result.response?.modelId ?? stepModel.modelId,
-                    headers: result.response?.headers,
-                    body: result.response?.body,
-                  };
-
-                  // Add response information to the span:
-                  span.setAttributes(
-                    await selectTelemetryAttributes({
-                      telemetry,
-                      attributes: {
-                        'ai.response.finishReason': result.finishReason.unified,
-                        'ai.response.text': {
-                          output: () => extractTextContent(result.content),
-                        },
-                        'ai.response.reasoning': {
-                          output: () => extractReasoningContent(result.content),
-                        },
-                        'ai.response.toolCalls': {
-                          output: () => {
-                            const toolCalls = asToolCalls(result.content);
-                            return toolCalls == null
-                              ? undefined
-                              : JSON.stringify(toolCalls);
-                          },
-                        },
-                        'ai.response.id': responseData.id,
-                        'ai.response.model': responseData.modelId,
-                        'ai.response.timestamp':
-                          responseData.timestamp.toISOString(),
-                        'ai.response.providerMetadata': JSON.stringify(
-                          result.providerMetadata,
-                        ),
-
-                        // TODO rename telemetry attributes to inputTokens and outputTokens
-                        'ai.usage.promptTokens': result.usage.inputTokens.total,
-                        'ai.usage.completionTokens':
-                          result.usage.outputTokens.total,
-
-                        // standardized gen-ai llm span attributes:
-                        'gen_ai.response.finish_reasons': [
-                          result.finishReason.unified,
-                        ],
-                        'gen_ai.response.id': responseData.id,
-                        'gen_ai.response.model': responseData.modelId,
-                        'gen_ai.usage.input_tokens':
-                          result.usage.inputTokens.total,
-                        'gen_ai.usage.output_tokens':
-                          result.usage.outputTokens.total,
-                      },
-                    }),
-                  );
-
-                  return { ...result, response: responseData };
-                },
-              }),
-            );
-
-            // parse tool calls:
-            const stepToolCalls: TypedToolCall<TOOLS>[] = await Promise.all(
-              currentModelResponse.content
-                .filter(
-                  (part): part is LanguageModelV3ToolCall =>
-                    part.type === 'tool-call',
-                )
-                .map(toolCall =>
-                  parseToolCall({
-                    toolCall,
-                    tools,
-                    repairToolCall,
-                    system,
-                    messages: stepInputMessages,
-                  }),
-                ),
-            );
-            const toolApprovalRequests: Record<
-              string,
-              ToolApprovalRequestOutput<TOOLS>
-            > = {};
-
-            // notify the tools that the tool calls are available:
-            for (const toolCall of stepToolCalls) {
-              if (toolCall.invalid) {
-                continue; // ignore invalid tool calls
-              }
-
-              const tool = tools?.[toolCall.toolName];
-
-              if (tool == null) {
-                // ignore tool calls for tools that are not available,
-                // e.g. provider-executed dynamic tools
-                continue;
-              }
-
-              if (tool?.onInputAvailable != null) {
-                await tool.onInputAvailable({
-                  input: toolCall.input,
-                  toolCallId: toolCall.toolCallId,
-                  messages: stepInputMessages,
-                  abortSignal: mergedAbortSignal,
-                  experimental_context,
-                });
-              }
-
-              if (
-                await isApprovalNeeded({
-                  tool,
-                  toolCall,
-                  messages: stepInputMessages,
-                  experimental_context,
-                })
-              ) {
-                toolApprovalRequests[toolCall.toolCallId] = {
-                  type: 'tool-approval-request',
-                  approvalId: generateId(),
-                  toolCall,
-                };
-              }
-            }
-
-            // insert error tool outputs for invalid tool calls:
-            // TODO AI SDK 6: invalid inputs should not require output parts
-            const invalidToolCalls = stepToolCalls.filter(
-              toolCall => toolCall.invalid && toolCall.dynamic,
-            );
-
-            clientToolOutputs = [];
-
-            for (const toolCall of invalidToolCalls) {
-              clientToolOutputs.push({
-                type: 'tool-error',
-                toolCallId: toolCall.toolCallId,
-                toolName: toolCall.toolName,
-                input: toolCall.input,
-                error: getErrorMessage(toolCall.error!),
-                dynamic: true,
-              });
-            }
-
-            // execute client tool calls:
-            clientToolCalls = stepToolCalls.filter(
-              toolCall => !toolCall.providerExecuted,
-            );
-
-            if (tools != null) {
-              clientToolOutputs.push(
-                ...(await executeTools({
-                  toolCalls: clientToolCalls.filter(
-                    toolCall =>
-                      !toolCall.invalid &&
-                      toolApprovalRequests[toolCall.toolCallId] == null,
-                  ),
-                  tools,
-                  tracer,
-                  telemetry,
-                  messages: stepInputMessages,
-                  abortSignal: mergedAbortSignal,
-                  experimental_context,
-                  stepNumber: steps.length,
-                  model: stepModelInfo,
-                  onToolCallStart: [
-                    onToolCallStart,
-                    globalTelemetry.onToolCallStart as
-                      | undefined
-                      | GenerateTextOnToolCallStartCallback<TOOLS>,
-                  ],
-                  onToolCallFinish: [
-                    onToolCallFinish,
-                    globalTelemetry.onToolCallFinish,
-                  ],
-                })),
-              );
-            }
-
-            // Track provider-executed tool calls that support deferred results.
-            // In programmatic tool calling, a server tool (e.g., code_execution) may
-            // trigger a client tool, and the server tool's result is deferred until
-            // the client tool's result is sent back.
-            for (const toolCall of stepToolCalls) {
-              if (!toolCall.providerExecuted) continue;
-              const tool = tools?.[toolCall.toolName];
-              if (tool?.type === 'provider' && tool.supportsDeferredResults) {
-                // Check if this tool call already has a result in the current response
-                const hasResultInResponse = currentModelResponse.content.some(
-                  part =>
-                    part.type === 'tool-result' &&
-                    part.toolCallId === toolCall.toolCallId,
-                );
-                if (!hasResultInResponse) {
-                  pendingDeferredToolCalls.set(toolCall.toolCallId, {
-                    toolName: toolCall.toolName,
-                  });
-                }
-              }
-            }
-
-            // Mark deferred tool calls as resolved when we receive their results
-            for (const part of currentModelResponse.content) {
-              if (part.type === 'tool-result') {
-                pendingDeferredToolCalls.delete(part.toolCallId);
-              }
-            }
-
-            // content:
-            const stepContent = asContent({
-              content: currentModelResponse.content,
-              toolCalls: stepToolCalls,
-              toolOutputs: clientToolOutputs,
-              toolApprovalRequests: Object.values(toolApprovalRequests),
-              tools,
-            });
-
-            // append to messages for potential next step:
-            responseMessages.push(
-              ...(await toResponseMessages({
-                content: stepContent,
-                tools,
-              })),
-            );
-
-            // Add step information (after response messages are updated):
-            // Conditionally include request.body and response.body based on include settings.
-            // Large payloads (e.g., base64-encoded images) can cause memory issues.
-            const stepRequest: LanguageModelRequestMetadata =
-              (include?.requestBody ?? true)
-                ? (currentModelResponse.request ?? {})
-                : { ...currentModelResponse.request, body: undefined };
-
-            const stepResponse = {
-              ...currentModelResponse.response,
-              // deep clone msgs to avoid mutating past messages in multi-step:
-              messages: structuredClone(responseMessages),
-              // Conditionally include response body:
-              body:
-                (include?.responseBody ?? true)
-                  ? currentModelResponse.response?.body
-                  : undefined,
-            };
-
-            const stepNumber = steps.length;
-
-            const currentStepResult: StepResult<TOOLS> = new DefaultStepResult({
-              stepNumber,
-              model: stepModelInfo,
-              functionId: telemetry?.functionId,
-              metadata: telemetry?.metadata as
-                | Record<string, unknown>
-                | undefined,
-              experimental_context,
-              content: stepContent,
-              finishReason: currentModelResponse.finishReason.unified,
-              rawFinishReason: currentModelResponse.finishReason.raw,
-              usage: asLanguageModelUsage(currentModelResponse.usage),
-              warnings: currentModelResponse.warnings,
-              providerMetadata: currentModelResponse.providerMetadata,
-              request: stepRequest,
-              response: stepResponse,
-            });
-
-            logWarnings({
-              warnings: currentModelResponse.warnings ?? [],
-              provider: stepModelInfo.provider,
-              model: stepModelInfo.modelId,
-            });
-
-            steps.push(currentStepResult);
-
-            await notify({
-              event: currentStepResult,
-              callbacks: [onStepFinish, globalTelemetry.onStepFinish],
-            });
-          } finally {
-            if (stepTimeoutId != null) {
-              clearTimeout(stepTimeoutId);
-            }
-          }
-        } while (
-          // Continue if:
-          // 1. There are client tool calls that have all been executed, OR
-          // 2. There are pending deferred results from provider-executed tools
-          ((clientToolCalls.length > 0 &&
-            clientToolOutputs.length === clientToolCalls.length) ||
-            pendingDeferredToolCalls.size > 0) &&
-          // continue until a stop condition is met:
-          !(await isStopConditionMet({ stopConditions, steps }))
-        );
-
-        // Add response information to the span:
-        span.setAttributes(
-          await selectTelemetryAttributes({
-            telemetry,
-            attributes: {
-              'ai.response.finishReason':
-                currentModelResponse.finishReason.unified,
-              'ai.response.text': {
-                output: () => extractTextContent(currentModelResponse.content),
-              },
-              'ai.response.reasoning': {
-                output: () =>
-                  extractReasoningContent(currentModelResponse.content),
-              },
-              'ai.response.toolCalls': {
-                output: () => {
-                  const toolCalls = asToolCalls(currentModelResponse.content);
-                  return toolCalls == null
-                    ? undefined
-                    : JSON.stringify(toolCalls);
-                },
-              },
-              'ai.response.providerMetadata': JSON.stringify(
-                currentModelResponse.providerMetadata,
-              ),
-
-              // TODO rename telemetry attributes to inputTokens and outputTokens
-              'ai.usage.promptTokens':
-                currentModelResponse.usage.inputTokens.total,
-              'ai.usage.completionTokens':
-                currentModelResponse.usage.outputTokens.total,
-            },
-          }),
-        );
-
-        const lastStep = steps[steps.length - 1];
-
-        const totalUsage = steps.reduce(
-          (totalUsage, step) => {
-            return addLanguageModelUsage(totalUsage, step.usage);
-          },
-          {
-            inputTokens: undefined,
-            outputTokens: undefined,
-            totalTokens: undefined,
-            reasoningTokens: undefined,
-            cachedInputTokens: undefined,
-          } as LanguageModelUsage,
-        );
-
-        await notify({
-          event: {
-            stepNumber: lastStep.stepNumber,
-            model: lastStep.model,
-            functionId: lastStep.functionId,
-            metadata: lastStep.metadata,
-            experimental_context: lastStep.experimental_context,
-            finishReason: lastStep.finishReason,
-            rawFinishReason: lastStep.rawFinishReason,
-            usage: lastStep.usage,
-            content: lastStep.content,
-            text: lastStep.text,
-            reasoningText: lastStep.reasoningText,
-            reasoning: lastStep.reasoning,
-            files: lastStep.files,
-            sources: lastStep.sources,
-            toolCalls: lastStep.toolCalls,
-            staticToolCalls: lastStep.staticToolCalls,
-            dynamicToolCalls: lastStep.dynamicToolCalls,
-            toolResults: lastStep.toolResults,
-            staticToolResults: lastStep.staticToolResults,
-            dynamicToolResults: lastStep.dynamicToolResults,
-            request: lastStep.request,
-            response: lastStep.response,
-            warnings: lastStep.warnings,
-            providerMetadata: lastStep.providerMetadata,
-            steps,
-            totalUsage,
-          },
-          callbacks: [
-            onFinish,
-            globalTelemetry.onFinish as
-              | undefined
-              | GenerateTextOnFinishCallback<TOOLS>,
-          ],
-        });
-
-        // parse output only if the last step was finished with "stop":
-        let resolvedOutput;
-        if (lastStep.finishReason === 'stop') {
-          const outputSpecification = output ?? text();
-          resolvedOutput = await outputSpecification.parseCompleteOutput(
-            { text: lastStep.text },
-            {
-              response: lastStep.response,
-              usage: lastStep.usage,
-              finishReason: lastStep.finishReason,
-            },
-          );
-        }
-
-        return new DefaultGenerateTextResult({
-          steps,
-          totalUsage,
-          output: resolvedOutput,
-        });
-      },
-    });
-  } catch (error) {
-    throw wrapGatewayError(error);
-  }
-}
-
-async function executeTools<TOOLS extends ToolSet>({
-  toolCalls,
-  tools,
-  tracer,
-  telemetry,
-  messages,
-  abortSignal,
-  experimental_context,
-  stepNumber,
-  model,
-  onToolCallStart,
-  onToolCallFinish,
-}: {
-  toolCalls: Array<TypedToolCall<TOOLS>>;
-  tools: TOOLS;
-  tracer: Tracer;
-  telemetry: TelemetrySettings | undefined;
-  messages: ModelMessage[];
-  abortSignal: AbortSignal | undefined;
-  experimental_context: unknown;
-  stepNumber: number;
-  model: { provider: string; modelId: string };
-  onToolCallStart:
-    | GenerateTextOnToolCallStartCallback<TOOLS>
-    | Array<GenerateTextOnToolCallStartCallback<TOOLS> | undefined | null>
-    | undefined;
-  onToolCallFinish:
-    | GenerateTextOnToolCallFinishCallback<TOOLS>
-    | Array<GenerateTextOnToolCallFinishCallback<TOOLS> | undefined | null>
-    | undefined;
-}): Promise<Array<ToolOutput<TOOLS>>> {
-  const toolOutputs = await Promise.all(
-    toolCalls.map(async toolCall =>
-      executeToolCall({
-        toolCall,
-        tools,
-        tracer,
-        telemetry,
-        messages,
-        abortSignal,
-        experimental_context,
-        stepNumber,
-        model,
-        onToolCallStart,
-        onToolCallFinish,
-      }),
-    ),
-  );
-
-  return toolOutputs.filter(
-    (output): output is NonNullable<typeof output> => output != null,
-  );
-}
-
-class DefaultGenerateTextResult<TOOLS extends ToolSet, OUTPUT extends Output>
-  implements GenerateTextResult<TOOLS, OUTPUT>
-{
-  readonly steps: GenerateTextResult<TOOLS, OUTPUT>['steps'];
-  readonly totalUsage: LanguageModelUsage;
-  private readonly _output: InferCompleteOutput<OUTPUT> | undefined;
-
-  constructor(options: {
-    steps: GenerateTextResult<TOOLS, OUTPUT>['steps'];
-    output: InferCompleteOutput<OUTPUT> | undefined;
-    totalUsage: LanguageModelUsage;
-  }) {
-    this.steps = options.steps;
-    this._output = options.output;
-    this.totalUsage = options.totalUsage;
-  }
-
-  private get finalStep() {
-    return this.steps[this.steps.length - 1];
-  }
-
-  get content() {
-    return this.finalStep.content;
-  }
-
-  get text() {
-    return this.finalStep.text;
-  }
-
-  get files() {
-    return this.finalStep.files;
-  }
-
-  get reasoningText() {
-    return this.finalStep.reasoningText;
-  }
-
-  get reasoning() {
-    return this.finalStep.reasoning;
-  }
-
-  get toolCalls() {
-    return this.finalStep.toolCalls;
-  }
-
-  get staticToolCalls() {
-    return this.finalStep.staticToolCalls;
-  }
-
-  get dynamicToolCalls() {
-    return this.finalStep.dynamicToolCalls;
-  }
-
-  get toolResults() {
-    return this.finalStep.toolResults;
-  }
-
-  get staticToolResults() {
-    return this.finalStep.staticToolResults;
-  }
-
-  get dynamicToolResults() {
-    return this.finalStep.dynamicToolResults;
-  }
-
-  get sources() {
-    return this.finalStep.sources;
-  }
-
-  get finishReason() {
-    return this.finalStep.finishReason;
-  }
-
-  get rawFinishReason() {
-    return this.finalStep.rawFinishReason;
-  }
-
-  get warnings() {
-    return this.finalStep.warnings;
-  }
-
-  get providerMetadata() {
-    return this.finalStep.providerMetadata;
-  }
-
-  get response() {
-    return this.finalStep.response;
-  }
-
-  get request() {
-    return this.finalStep.request;
-  }
-
-  get usage() {
-    return this.finalStep.usage;
-  }
-
-  get experimental_output() {
-    return this.output;
-  }
-
-  get output() {
-    if (this._output == null) {
-      throw new NoOutputGeneratedError();
-    }
-
-    return this._output;
-  }
-}
-
-function asToolCalls(content: Array<LanguageModelV3Content>) {
-  const parts = content.filter(
-    (part): part is LanguageModelV3ToolCall => part.type === 'tool-call',
-  );
-
-  if (parts.length === 0) {
-    return undefined;
-  }
-
-  return parts.map(toolCall => ({
-    toolCallId: toolCall.toolCallId,
-    toolName: toolCall.toolName,
-    input: toolCall.input,
-  }));
-}
-
-function asContent<TOOLS extends ToolSet>({
-  content,
-  toolCalls,
-  toolOutputs,
-  toolApprovalRequests,
-  tools,
-}: {
-  content: Array<LanguageModelV3Content>;
-  toolCalls: Array<TypedToolCall<TOOLS>>;
-  toolOutputs: Array<ToolOutput<TOOLS>>;
-  toolApprovalRequests: Array<ToolApprovalRequestOutput<TOOLS>>;
-  tools: TOOLS | undefined;
-}): Array<ContentPart<TOOLS>> {
-  const contentParts: Array<ContentPart<TOOLS>> = [];
-
-  for (const part of content) {
-    switch (part.type) {
-      case 'text':
-      case 'reasoning':
-      case 'source':
-        contentParts.push(part);
-        break;
-
-      case 'file': {
-        contentParts.push({
-          type: 'file' as const,
-          file: new DefaultGeneratedFile(part),
-          ...(part.providerMetadata != null
-            ? { providerMetadata: part.providerMetadata }
-            : {}),
-        });
-        break;
-      }
-
-      case 'tool-call': {
-        contentParts.push(
-          toolCalls.find(toolCall => toolCall.toolCallId === part.toolCallId)!,
-        );
-        break;
-      }
-
-      case 'tool-result': {
-        const toolCall = toolCalls.find(
-          toolCall => toolCall.toolCallId === part.toolCallId,
-        );
-
-        // Handle deferred results for provider-executed tools (e.g., programmatic tool calling).
-        // When a server tool (like code_execution) triggers a client tool, the server tool's
-        // result may be deferred to a later turn. In this case, there's no matching tool-call
-        // in the current response.
-        if (toolCall == null) {
-          const tool = tools?.[part.toolName];
-          const supportsDeferredResults =
-            tool?.type === 'provider' && tool.supportsDeferredResults;
-
-          if (!supportsDeferredResults) {
-            throw new Error(`Tool call ${part.toolCallId} not found.`);
-          }
-
-          // Create tool result without tool call input (deferred result)
-          if (part.isError) {
-            contentParts.push({
-              type: 'tool-error' as const,
-              toolCallId: part.toolCallId,
-              toolName: part.toolName as keyof TOOLS & string,
-              input: undefined,
-              error: part.result,
-              providerExecuted: true,
-              dynamic: part.dynamic,
-            } as TypedToolError<TOOLS>);
-          } else {
-            contentParts.push({
-              type: 'tool-result' as const,
-              toolCallId: part.toolCallId,
-              toolName: part.toolName as keyof TOOLS & string,
-              input: undefined,
-              output: part.result,
-              providerExecuted: true,
-              dynamic: part.dynamic,
-            } as TypedToolResult<TOOLS>);
-          }
-          break;
-        }
-
-        if (part.isError) {
-          contentParts.push({
-            type: 'tool-error' as const,
-            toolCallId: part.toolCallId,
-            toolName: part.toolName as keyof TOOLS & string,
-            input: toolCall.input,
-            error: part.result,
-            providerExecuted: true,
-            dynamic: toolCall.dynamic,
-          } as TypedToolError<TOOLS>);
-        } else {
-          contentParts.push({
-            type: 'tool-result' as const,
-            toolCallId: part.toolCallId,
-            toolName: part.toolName as keyof TOOLS & string,
-            input: toolCall.input,
-            output: part.result,
-            providerExecuted: true,
-            dynamic: toolCall.dynamic,
-          } as TypedToolResult<TOOLS>);
-        }
-        break;
-      }
-
-      case 'tool-approval-request': {
-        const toolCall = toolCalls.find(
-          toolCall => toolCall.toolCallId === part.toolCallId,
-        );
-
-        if (toolCall == null) {
-          throw new ToolCallNotFoundForApprovalError({
-            toolCallId: part.toolCallId,
-            approvalId: part.approvalId,
-          });
-        }
-
-        contentParts.push({
-          type: 'tool-approval-request' as const,
-          approvalId: part.approvalId,
-          toolCall,
-        });
-        break;
-      }
-    }
-  }
-
-  return [...contentParts, ...toolOutputs, ...toolApprovalRequests];
-}