@ai-sdk/openai 4.0.0-beta.1 → 4.0.0-beta.11

package/src/responses/openai-responses-language-model.ts

@@ -1,18 +1,18 @@
 import {
   APICallError,
   JSONValue,
-  LanguageModelV3,
-  LanguageModelV3Prompt,
-  LanguageModelV3CallOptions,
-  LanguageModelV3Content,
-  LanguageModelV3FinishReason,
-  LanguageModelV3GenerateResult,
-  LanguageModelV3ProviderTool,
-  LanguageModelV3StreamPart,
-  LanguageModelV3StreamResult,
-  LanguageModelV3ToolApprovalRequest,
-  SharedV3ProviderMetadata,
-  SharedV3Warning,
+  LanguageModelV4,
+  LanguageModelV4Prompt,
+  LanguageModelV4CallOptions,
+  LanguageModelV4Content,
+  LanguageModelV4FinishReason,
+  LanguageModelV4GenerateResult,
+  LanguageModelV4ProviderTool,
+  LanguageModelV4StreamPart,
+  LanguageModelV4StreamResult,
+  LanguageModelV4ToolApprovalRequest,
+  SharedV4ProviderMetadata,
+  SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
@@ -38,6 +38,10 @@ import { imageGenerationOutputSchema } from '../tool/image-generation';
 import { localShellInputSchema } from '../tool/local-shell';
 import { mcpOutputSchema } from '../tool/mcp';
 import { shellInputSchema, shellOutputSchema } from '../tool/shell';
+import {
+  toolSearchInputSchema,
+  toolSearchOutputSchema,
+} from '../tool/tool-search';
 import { webSearchOutputSchema } from '../tool/web-search';
 import {
   convertOpenAIResponsesUsage,
@@ -77,7 +81,7 @@ import {
  * so that tool results reference the correct tool call.
  */
 function extractApprovalRequestIdToToolCallIdMapping(
-  prompt: LanguageModelV3Prompt,
+  prompt: LanguageModelV4Prompt,
 ): Record<string, string> {
   const mapping: Record<string, string> = {};
   for (const message of prompt) {
@@ -94,8 +98,8 @@ function extractApprovalRequestIdToToolCallIdMapping(
   return mapping;
 }
 
-export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
-  readonly specificationVersion = 'v3';
+export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
+  readonly specificationVersion = 'v4';
 
   readonly modelId: OpenAIResponsesModelId;
 
@@ -129,8 +133,8 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
     tools,
     toolChoice,
     responseFormat,
-  }: LanguageModelV3CallOptions) {
-    const warnings: SharedV3Warning[] = [];
+  }: LanguageModelV4CallOptions) {
+    const warnings: SharedV4Warning[] = [];
     const modelCapabilities = getOpenAILanguageModelCapabilities(this.modelId);
 
     if (topK != null) {
@@ -193,11 +197,8 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
         'openai.web_search_preview': 'web_search_preview',
         'openai.mcp': 'mcp',
         'openai.apply_patch': 'apply_patch',
+        'openai.tool_search': 'tool_search',
       },
-      resolveProviderToolName: tool =>
-        tool.id === 'openai.custom'
-          ? (tool.args as { name?: string }).name
-          : undefined,
     });
 
     const customProviderToolNames = new Set<string>();
@@ -273,7 +274,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
           tool.type === 'provider' &&
           (tool.id === 'openai.web_search' ||
             tool.id === 'openai.web_search_preview'),
-      ) as LanguageModelV3ProviderTool | undefined
+      ) as LanguageModelV4ProviderTool | undefined
     )?.name;
 
     if (webSearchToolName) {
@@ -454,8 +455,8 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
   }
 
   async doGenerate(
-    options: LanguageModelV3CallOptions,
-  ): Promise<LanguageModelV3GenerateResult> {
+    options: LanguageModelV4CallOptions,
+  ): Promise<LanguageModelV4GenerateResult> {
     const {
       args: body,
       warnings,
@@ -500,11 +501,12 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
       });
     }
 
-    const content: Array<LanguageModelV3Content> = [];
+    const content: Array<LanguageModelV4Content> = [];
     const logprobs: Array<OpenAIResponsesLogprobs> = [];
 
     // flag that checks if there have been client-side tool calls (not executed by openai)
     let hasFunctionCall = false;
+    const hostedToolSearchCallIds: string[] = [];
 
     // map response content to content array (defined when there is no error)
     for (const part of response.output!) {
@@ -551,6 +553,54 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
           break;
         }
 
+        case 'tool_search_call': {
+          const toolCallId = part.call_id ?? part.id;
+          const isHosted = part.execution === 'server';
+
+          if (isHosted) {
+            hostedToolSearchCallIds.push(toolCallId);
+          }
+
+          content.push({
+            type: 'tool-call',
+            toolCallId,
+            toolName: toolNameMapping.toCustomToolName('tool_search'),
+            input: JSON.stringify({
+              arguments: part.arguments,
+              call_id: part.call_id,
+            } satisfies InferSchema<typeof toolSearchInputSchema>),
+            ...(isHosted ? { providerExecuted: true } : {}),
+            providerMetadata: {
+              [providerOptionsName]: {
+                itemId: part.id,
+              },
+            },
+          });
+
+          break;
+        }
+
+        case 'tool_search_output': {
+          const toolCallId =
+            part.call_id ?? hostedToolSearchCallIds.shift() ?? part.id;
+
+          content.push({
+            type: 'tool-result',
+            toolCallId,
+            toolName: toolNameMapping.toCustomToolName('tool_search'),
+            result: {
+              tools: part.tools,
+            } satisfies InferSchema<typeof toolSearchOutputSchema>,
+            providerMetadata: {
+              [providerOptionsName]: {
+                itemId: part.id,
+              },
+            },
+          });
+
+          break;
+        }
+
         case 'local_shell_call': {
           content.push({
             type: 'tool-call',
@@ -621,7 +671,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
               logprobs.push(contentPart.logprobs);
             }
 
-            const providerMetadata: SharedV3ProviderMetadata[string] = {
+            const providerMetadata: SharedV4ProviderMetadata[string] = {
               itemId: part.id,
               ...(part.phase != null && { phase: part.phase }),
               ...(contentPart.annotations.length > 0 && {
@@ -833,7 +883,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
             type: 'tool-approval-request',
             approvalId: approvalRequestId,
             toolCallId: dummyToolCallId,
-          } satisfies LanguageModelV3ToolApprovalRequest);
+          } satisfies LanguageModelV4ToolApprovalRequest);
           break;
         }
 
@@ -930,7 +980,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
       }
     }
 
-    const providerMetadata: SharedV3ProviderMetadata = {
+    const providerMetadata: SharedV4ProviderMetadata = {
       [providerOptionsName]: {
         responseId: response.id,
         ...(logprobs.length > 0 ? { logprobs } : {}),
@@ -966,8 +1016,8 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
   }
 
   async doStream(
-    options: LanguageModelV3CallOptions,
-  ): Promise<LanguageModelV3StreamResult> {
+    options: LanguageModelV4CallOptions,
+  ): Promise<LanguageModelV4StreamResult> {
     const {
       args: body,
       warnings,
@@ -1006,7 +1056,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
       string
     >();
 
-    let finishReason: LanguageModelV3FinishReason = {
+    let finishReason: LanguageModelV4FinishReason = {
       unified: 'other',
       raw: undefined,
     };
@@ -1026,6 +1076,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
             hasDiff: boolean;
             endEmitted: boolean;
           };
+          toolSearchExecution?: 'server' | 'client';
         }
       | undefined
     > = {};
@@ -1054,12 +1105,13 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
     > = {};
 
     let serviceTier: string | undefined;
+    const hostedToolSearchCallIds: string[] = [];
 
     return {
       stream: response.pipeThrough(
         new TransformStream<
           ParseResult<OpenAIResponsesChunk>,
-          LanguageModelV3StreamPart
+          LanguageModelV4StreamPart
         >({
           start(controller) {
             controller.enqueue({ type: 'stream-start', warnings });
@@ -1188,6 +1240,28 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
                   input: '{}',
                   providerExecuted: true,
                 });
+              } else if (value.item.type === 'tool_search_call') {
+                const toolCallId = value.item.id;
+                const toolName =
+                  toolNameMapping.toCustomToolName('tool_search');
+                const isHosted = value.item.execution === 'server';
+
+                ongoingToolCalls[value.output_index] = {
+                  toolName,
+                  toolCallId,
+                  toolSearchExecution: value.item.execution ?? 'server',
+                };
+
+                if (isHosted) {
+                  controller.enqueue({
+                    type: 'tool-input-start',
+                    id: toolCallId,
+                    toolName,
+                    providerExecuted: true,
+                  });
+                }
+              } else if (value.item.type === 'tool_search_output') {
+                // handled on output_item.done so we can pair it with the call
               } else if (
                 value.item.type === 'mcp_call' ||
                 value.item.type === 'mcp_list_tools' ||
@@ -1418,6 +1492,67 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
                     result: value.item.result,
                   } satisfies InferSchema<typeof imageGenerationOutputSchema>,
                 });
+              } else if (value.item.type === 'tool_search_call') {
+                const toolCall = ongoingToolCalls[value.output_index];
+                const isHosted = value.item.execution === 'server';
+
+                if (toolCall != null) {
+                  const toolCallId = isHosted
+                    ? toolCall.toolCallId
+                    : (value.item.call_id ?? value.item.id);
+
+                  if (isHosted) {
+                    hostedToolSearchCallIds.push(toolCallId);
+                  } else {
+                    controller.enqueue({
+                      type: 'tool-input-start',
+                      id: toolCallId,
+                      toolName: toolCall.toolName,
+                    });
+                  }
+
+                  controller.enqueue({
+                    type: 'tool-input-end',
+                    id: toolCallId,
+                  });
+
+                  controller.enqueue({
+                    type: 'tool-call',
+                    toolCallId,
+                    toolName: toolCall.toolName,
+                    input: JSON.stringify({
+                      arguments: value.item.arguments,
+                      call_id: isHosted ? null : toolCallId,
+                    } satisfies InferSchema<typeof toolSearchInputSchema>),
+                    ...(isHosted ? { providerExecuted: true } : {}),
+                    providerMetadata: {
+                      [providerOptionsName]: {
+                        itemId: value.item.id,
+                      },
+                    },
+                  });
+                }
+
+                ongoingToolCalls[value.output_index] = undefined;
+              } else if (value.item.type === 'tool_search_output') {
+                const toolCallId =
+                  value.item.call_id ??
+                  hostedToolSearchCallIds.shift() ??
+                  value.item.id;
+
+                controller.enqueue({
+                  type: 'tool-result',
+                  toolCallId,
+                  toolName: toolNameMapping.toCustomToolName('tool_search'),
+                  result: {
+                    tools: value.item.tools,
+                  } satisfies InferSchema<typeof toolSearchOutputSchema>,
+                  providerMetadata: {
+                    [providerOptionsName]: {
+                      itemId: value.item.id,
+                    },
+                  },
+                });
               } else if (value.item.type === 'mcp_call') {
                 ongoingToolCalls[value.output_index] = undefined;
 
@@ -1941,7 +2076,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
           },
 
           flush(controller) {
-            const providerMetadata: SharedV3ProviderMetadata = {
+            const providerMetadata: SharedV4ProviderMetadata = {
               [providerOptionsName]: {
                 responseId: responseId,
                 ...(logprobs.length > 0 ? { logprobs } : {}),

package/src/responses/openai-responses-options.ts

@@ -37,11 +37,12 @@ export const openaiResponsesReasoningModelIds = [
   'gpt-5.2-chat-latest',
   'gpt-5.2-pro',
   'gpt-5.2-codex',
+  'gpt-5.3-chat-latest',
+  'gpt-5.3-codex',
   'gpt-5.4',
   'gpt-5.4-2026-03-05',
   'gpt-5.4-pro',
   'gpt-5.4-pro-2026-03-05',
-  'gpt-5.3-codex',
 ] as const;
 
 export const openaiResponsesModelIds = [
@@ -98,11 +99,12 @@ export type OpenAIResponsesModelId =
   | 'gpt-5.2-pro'
   | 'gpt-5.2-pro-2025-12-11'
   | 'gpt-5.2-codex'
+  | 'gpt-5.3-chat-latest'
+  | 'gpt-5.3-codex'
   | 'gpt-5.4'
   | 'gpt-5.4-2026-03-05'
   | 'gpt-5.4-pro'
   | 'gpt-5.4-pro-2026-03-05'
-  | 'gpt-5.3-codex'
   | 'gpt-5-2025-08-07'
   | 'gpt-5-chat-latest'
   | 'gpt-5-codex'

package/src/responses/openai-responses-prepare-tools.ts

@@ -1,6 +1,6 @@
 import {
-  LanguageModelV3CallOptions,
-  SharedV3Warning,
+  LanguageModelV4CallOptions,
+  SharedV4Warning,
   UnsupportedFunctionalityError,
 } from '@ai-sdk/provider';
 import { ToolNameMapping, validateTypes } from '@ai-sdk/provider-utils';
@@ -10,6 +10,7 @@ import { imageGenerationArgsSchema } from '../tool/image-generation';
 import { customArgsSchema } from '../tool/custom';
 import { mcpArgsSchema } from '../tool/mcp';
 import { shellArgsSchema } from '../tool/shell';
+import { toolSearchArgsSchema } from '../tool/tool-search';
 import { webSearchArgsSchema } from '../tool/web-search';
 import { webSearchPreviewArgsSchema } from '../tool/web-search-preview';
 import { OpenAIResponsesTool } from './openai-responses-api';
@@ -20,8 +21,8 @@ export async function prepareResponsesTools({
   toolNameMapping,
   customProviderToolNames,
 }: {
-  tools: LanguageModelV3CallOptions['tools'];
-  toolChoice: LanguageModelV3CallOptions['toolChoice'] | undefined;
+  tools: LanguageModelV4CallOptions['tools'];
+  toolChoice: LanguageModelV4CallOptions['toolChoice'] | undefined;
   toolNameMapping?: ToolNameMapping;
   customProviderToolNames?: Set<string>;
 }): Promise<{
@@ -39,12 +40,12 @@ export async function prepareResponsesTools({
     | { type: 'mcp' }
     | { type: 'image_generation' }
     | { type: 'apply_patch' };
-  toolWarnings: SharedV3Warning[];
+  toolWarnings: SharedV4Warning[];
 }> {
   // when the tools array is empty, change it to undefined to prevent errors:
   tools = tools?.length ? tools : undefined;
 
-  const toolWarnings: SharedV3Warning[] = [];
+  const toolWarnings: SharedV4Warning[] = [];
 
   if (tools == null) {
     return { tools: undefined, toolChoice: undefined, toolWarnings };
@@ -56,15 +57,22 @@ export async function prepareResponsesTools({
 
   for (const tool of tools) {
     switch (tool.type) {
-      case 'function':
+      case 'function': {
+        const openaiOptions = tool.providerOptions?.openai as
+          | { deferLoading?: boolean }
+          | undefined;
+        const deferLoading = openaiOptions?.deferLoading;
+
         openaiTools.push({
           type: 'function',
           name: tool.name,
           description: tool.description,
           parameters: tool.inputSchema,
           ...(tool.strict != null ? { strict: tool.strict } : {}),
+          ...(deferLoading != null ? { defer_loading: deferLoading } : {}),
         });
         break;
+      }
       case 'provider': {
         switch (tool.id) {
           case 'openai.file_search': {
@@ -241,11 +249,28 @@ export async function prepareResponsesTools({
 
             openaiTools.push({
               type: 'custom',
-              name: args.name,
+              name: tool.name,
               description: args.description,
               format: args.format,
             });
-            resolvedCustomProviderToolNames.add(args.name);
+            resolvedCustomProviderToolNames.add(tool.name);
+            break;
+          }
+          case 'openai.tool_search': {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: toolSearchArgsSchema,
+            });
+            openaiTools.push({
+              type: 'tool_search',
+              ...(args.execution != null ? { execution: args.execution } : {}),
+              ...(args.description != null
+                ? { description: args.description }
+                : {}),
+              ...(args.parameters != null
+                ? { parameters: args.parameters }
+                : {}),
+            });
             break;
           }
         }

package/src/speech/openai-speech-model.ts

@@ -1,4 +1,4 @@
-import { SpeechModelV3, SharedV3Warning } from '@ai-sdk/provider';
+import { SpeechModelV4, SharedV4Warning } from '@ai-sdk/provider';
 import {
   combineHeaders,
   createBinaryResponseHandler,
@@ -19,8 +19,8 @@ interface OpenAISpeechModelConfig extends OpenAIConfig {
   };
 }
 
-export class OpenAISpeechModel implements SpeechModelV3 {
-  readonly specificationVersion = 'v3';
+export class OpenAISpeechModel implements SpeechModelV4 {
+  readonly specificationVersion = 'v4';
 
   get provider(): string {
     return this.config.provider;
@@ -39,8 +39,8 @@ export class OpenAISpeechModel implements SpeechModelV3 {
     instructions,
     language,
     providerOptions,
-  }: Parameters<SpeechModelV3['doGenerate']>[0]) {
-    const warnings: SharedV3Warning[] = [];
+  }: Parameters<SpeechModelV4['doGenerate']>[0]) {
+    const warnings: SharedV4Warning[] = [];
 
     // Parse provider options
     const openAIOptions = await parseProviderOptions({
@@ -98,8 +98,8 @@ export class OpenAISpeechModel implements SpeechModelV3 {
   }
 
   async doGenerate(
-    options: Parameters<SpeechModelV3['doGenerate']>[0],
-  ): Promise<Awaited<ReturnType<SpeechModelV3['doGenerate']>>> {
+    options: Parameters<SpeechModelV4['doGenerate']>[0],
+  ): Promise<Awaited<ReturnType<SpeechModelV4['doGenerate']>>> {
     const currentDate = this.config._internal?.currentDate?.() ?? new Date();
     const { requestBody, warnings } = await this.getArgs(options);
 

package/src/tool/custom.ts

@@ -8,7 +8,6 @@ import { z } from 'zod/v4';
 export const customArgsSchema = lazySchema(() =>
   zodSchema(
     z.object({
-      name: z.string(),
       description: z.string().optional(),
       format: z
         .union([
@@ -31,11 +30,6 @@ const customInputSchema = lazySchema(() => zodSchema(z.string()));
 export const customToolFactory = createProviderToolFactory<
   string,
   {
-    /**
-     * The name of the custom tool, used to identify it in the API.
-     */
-    name: string;
-
     /**
      * An optional description of what the tool does.
      */

package/src/tool/tool-search.ts

@@ -0,0 +1,98 @@
+import { JSONObject } from '@ai-sdk/provider';
+import {
+  createProviderToolFactoryWithOutputSchema,
+  FlexibleSchema,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const toolSearchArgsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      execution: z.enum(['server', 'client']).optional(),
+      description: z.string().optional(),
+      parameters: z.record(z.string(), z.unknown()).optional(),
+    }),
+  ),
+);
+
+export const toolSearchInputSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      arguments: z.unknown().optional(),
+      call_id: z.string().nullish(),
+    }),
+  ),
+);
+
+export const toolSearchOutputSchema: FlexibleSchema<{
+  tools: Array<JSONObject>;
+}> = lazySchema(() =>
+  zodSchema(
+    z.object({
+      tools: z.array(z.record(z.string(), z.unknown())),
+    }),
+  ),
+) as FlexibleSchema<{ tools: Array<JSONObject> }>;
+
+const toolSearchToolFactory = createProviderToolFactoryWithOutputSchema<
+  {
+    /**
+     * The arguments from the tool_search_call.
+     * This is preserved for multi-turn conversation reconstruction.
+     */
+    arguments?: unknown;
+
+    /**
+     * The call ID from the tool_search_call.
+     * Present for client-executed tool search; null for hosted.
+     */
+    call_id?: string | null;
+  },
+  {
+    /**
+     * The tools that were loaded by the tool search.
+     * These are the deferred tools that the model requested to load.
+     * Each tool is represented as a JSON object with properties depending on its type.
+     *
+     * Common properties include:
+     * - `type`: The type of the tool (e.g., 'function', 'web_search', etc.)
+     * - `name`: The name of the tool (for function tools)
+     * - `description`: A description of the tool
+     * - `deferLoading`: Whether this tool was deferred (had defer_loading: true)
+     * - `parameters`: The JSON Schema for the function parameters (for function tools)
+     * - `strict`: Whether to enable strict schema adherence (for function tools)
+     */
+    tools: Array<JSONObject>;
+  },
+  {
+    /**
+     * Whether the tool search is executed by the server (hosted) or client.
+     * - `'server'` (default): OpenAI performs the search across deferred tools.
+     * - `'client'`: The model emits a `tool_search_call` and your `execute`
+     *   function performs the lookup, returning the tools to load.
+     */
+    execution?: 'server' | 'client';
+
+    /**
+     * A description of the tool search capability.
+     * Only used for client-executed tool search.
+     */
+    description?: string;
+
+    /**
+     * JSON Schema for the search arguments your application expects.
+     * Only used for client-executed tool search.
+     */
+    parameters?: Record<string, unknown>;
+  }
+>({
+  id: 'openai.tool_search',
+  inputSchema: toolSearchInputSchema,
+  outputSchema: toolSearchOutputSchema,
+});
+
+export const toolSearch = (
+  args: Parameters<typeof toolSearchToolFactory>[0] = {},
+) => toolSearchToolFactory(args);

package/src/transcription/openai-transcription-model.ts

@@ -1,7 +1,7 @@
 import {
-  TranscriptionModelV3,
-  TranscriptionModelV3CallOptions,
-  SharedV3Warning,
+  TranscriptionModelV4,
+  TranscriptionModelV4CallOptions,
+  SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
@@ -21,7 +21,7 @@ import {
 } from './openai-transcription-options';
 
 export type OpenAITranscriptionCallOptions = Omit<
-  TranscriptionModelV3CallOptions,
+  TranscriptionModelV4CallOptions,
   'providerOptions'
 > & {
   providerOptions?: {
@@ -96,8 +96,8 @@ const languageMap = {
   welsh: 'cy',
 };
 
-export class OpenAITranscriptionModel implements TranscriptionModelV3 {
-  readonly specificationVersion = 'v3';
+export class OpenAITranscriptionModel implements TranscriptionModelV4 {
+  readonly specificationVersion = 'v4';
 
   get provider(): string {
     return this.config.provider;
@@ -113,7 +113,7 @@ export class OpenAITranscriptionModel implements TranscriptionModelV3 {
     mediaType,
     providerOptions,
   }: OpenAITranscriptionCallOptions) {
-    const warnings: SharedV3Warning[] = [];
+    const warnings: SharedV4Warning[] = [];
 
     // Parse provider options
     const openAIOptions = await parseProviderOptions({
@@ -176,7 +176,7 @@ export class OpenAITranscriptionModel implements TranscriptionModelV3 {
 
   async doGenerate(
     options: OpenAITranscriptionCallOptions,
-  ): Promise<Awaited<ReturnType<TranscriptionModelV3['doGenerate']>>> {
+  ): Promise<Awaited<ReturnType<TranscriptionModelV4['doGenerate']>>> {
     const currentDate = this.config._internal?.currentDate?.() ?? new Date();
     const { formData, warnings } = await this.getArgs(options);