@ai-sdk/openai 4.0.0-beta.4 → 4.0.0-beta.41

package/src/responses/convert-to-openai-responses-input.ts

@@ -1,15 +1,19 @@
 import {
-  LanguageModelV3Prompt,
-  LanguageModelV3ToolApprovalResponsePart,
-  SharedV3Warning,
   UnsupportedFunctionalityError,
+  type LanguageModelV4Prompt,
+  type LanguageModelV4ToolApprovalResponsePart,
+  type SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
   convertToBase64,
+  getTopLevelMediaType,
   isNonNullable,
+  parseJSON,
   parseProviderOptions,
-  ToolNameMapping,
+  resolveFullMediaType,
+  resolveProviderReference,
   validateTypes,
+  type ToolNameMapping,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 import {
@@ -21,16 +25,27 @@ import {
   localShellOutputSchema,
 } from '../tool/local-shell';
 import { shellInputSchema, shellOutputSchema } from '../tool/shell';
-import {
+import type {
+  OpenAIResponsesCompactionItem,
   OpenAIResponsesCustomToolCallOutput,
   OpenAIResponsesFunctionCallOutput,
   OpenAIResponsesInput,
   OpenAIResponsesReasoning,
 } from './openai-responses-api';
+import {
+  toolSearchInputSchema,
+  toolSearchOutputSchema,
+} from '../tool/tool-search';
+
+function serializeToolCallArguments(input: unknown): string {
+  return JSON.stringify(input === undefined ? {} : input);
+}
 
 /**
- * Check if a string is a file ID based on the given prefixes
- * Returns false if prefixes is undefined (disables file ID detection)
+ * This is soft-deprecated. Use provider references instead. Kept for backward compatibility
+ * with the `fileIdPrefixes` option.
+ *
+ * TODO: remove in v8
  */
 function isFileId(data: string, prefixes?: readonly string[]): boolean {
   if (!prefixes) return false;
@@ -50,10 +65,11 @@ export async function convertToOpenAIResponsesInput({
   hasApplyPatchTool = false,
   customProviderToolNames,
 }: {
-  prompt: LanguageModelV3Prompt;
+  prompt: LanguageModelV4Prompt;
   toolNameMapping: ToolNameMapping;
   systemMessageMode: 'system' | 'developer' | 'remove';
   providerOptionsName: string;
+  /** @deprecated Use provider references instead. */
   fileIdPrefixes?: readonly string[];
   store: boolean;
   hasConversation?: boolean; // when true, skip assistant messages that already have item IDs
@@ -63,10 +79,10 @@ export async function convertToOpenAIResponsesInput({
   customProviderToolNames?: Set<string>;
 }): Promise<{
   input: OpenAIResponsesInput;
-  warnings: Array<SharedV3Warning>;
+  warnings: Array<SharedV4Warning>;
 }> {
   let input: OpenAIResponsesInput = [];
-  const warnings: Array<SharedV3Warning> = [];
+  const warnings: Array<SharedV4Warning> = [];
   const processedApprovalIds = new Set<string>();
 
   for (const { role, content } of prompt) {
@@ -107,46 +123,79 @@ export async function convertToOpenAIResponsesInput({
                 return { type: 'input_text', text: part.text };
               }
               case 'file': {
-                if (part.mediaType.startsWith('image/')) {
-                  const mediaType =
-                    part.mediaType === 'image/*'
-                      ? 'image/jpeg'
-                      : part.mediaType;
-
-                  return {
-                    type: 'input_image',
-                    ...(part.data instanceof URL
-                      ? { image_url: part.data.toString() }
-                      : typeof part.data === 'string' &&
-                          isFileId(part.data, fileIdPrefixes)
-                        ? { file_id: part.data }
-                        : {
-                            image_url: `data:${mediaType};base64,${convertToBase64(part.data)}`,
-                          }),
-                    detail:
-                      part.providerOptions?.[providerOptionsName]?.imageDetail,
-                  };
-                } else if (part.mediaType === 'application/pdf') {
-                  if (part.data instanceof URL) {
+                switch (part.data.type) {
+                  case 'reference': {
+                    const fileId = resolveProviderReference({
+                      reference: part.data.reference,
+                      provider: providerOptionsName,
+                    });
+
+                    if (getTopLevelMediaType(part.mediaType) === 'image') {
+                      return {
+                        type: 'input_image',
+                        file_id: fileId,
+                        detail:
+                          part.providerOptions?.[providerOptionsName]
+                            ?.imageDetail,
+                      };
+                    }
+
                     return {
                       type: 'input_file',
-                      file_url: part.data.toString(),
+                      file_id: fileId,
                     };
                   }
-                  return {
-                    type: 'input_file',
-                    ...(typeof part.data === 'string' &&
-                    isFileId(part.data, fileIdPrefixes)
-                      ? { file_id: part.data }
-                      : {
-                          filename: part.filename ?? `part-${index}.pdf`,
-                          file_data: `data:application/pdf;base64,${convertToBase64(part.data)}`,
-                        }),
-                  };
-                } else {
-                  throw new UnsupportedFunctionalityError({
-                    functionality: `file part media type ${part.mediaType}`,
-                  });
+                  case 'text': {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: 'text file parts',
+                    });
+                  }
+                  case 'url':
+                  case 'data': {
+                    const topLevel = getTopLevelMediaType(part.mediaType);
+
+                    if (topLevel === 'image') {
+                      return {
+                        type: 'input_image',
+                        ...(part.data.type === 'url'
+                          ? { image_url: part.data.url.toString() }
+                          : typeof part.data.data === 'string' &&
+                              isFileId(part.data.data, fileIdPrefixes)
+                            ? { file_id: part.data.data }
+                            : {
+                                image_url: `data:${resolveFullMediaType({ part })};base64,${convertToBase64(part.data.data)}`,
+                              }),
+                        detail:
+                          part.providerOptions?.[providerOptionsName]
+                            ?.imageDetail,
+                      };
+                    } else {
+                      if (part.data.type === 'url') {
+                        return {
+                          type: 'input_file',
+                          file_url: part.data.url.toString(),
+                        };
+                      }
+
+                      const fullMediaType = resolveFullMediaType({ part });
+                      if (fullMediaType !== 'application/pdf') {
+                        throw new UnsupportedFunctionalityError({
+                          functionality: `file part media type ${fullMediaType}`,
+                        });
+                      }
+
+                      return {
+                        type: 'input_file',
+                        ...(typeof part.data.data === 'string' &&
+                        isFileId(part.data.data, fileIdPrefixes)
+                          ? { file_id: part.data.data }
+                          : {
+                              filename: part.filename ?? `part-${index}.pdf`,
+                              file_data: `data:application/pdf;base64,${convertToBase64(part.data.data)}`,
+                            }),
+                      };
+                    }
+                  }
                 }
               }
             }
@@ -206,6 +255,41 @@ export async function convertToOpenAIResponsesInput({
                 break;
               }
 
+              const resolvedToolName = toolNameMapping.toProviderToolName(
+                part.toolName,
+              );
+
+              if (resolvedToolName === 'tool_search') {
+                if (store && id != null) {
+                  input.push({ type: 'item_reference', id });
+                  break;
+                }
+
+                const parsedInput =
+                  typeof part.input === 'string'
+                    ? await parseJSON({
+                        text: part.input,
+                        schema: toolSearchInputSchema,
+                      })
+                    : await validateTypes({
+                        value: part.input,
+                        schema: toolSearchInputSchema,
+                      });
+
+                const execution =
+                  parsedInput.call_id != null ? 'client' : 'server';
+
+                input.push({
+                  type: 'tool_search_call',
+                  id: id ?? part.toolCallId,
+                  execution,
+                  call_id: parsedInput.call_id ?? null,
+                  status: 'completed',
+                  arguments: parsedInput.arguments,
+                });
+                break;
+              }
+
               if (part.providerExecuted) {
                 if (store && id != null) {
                   input.push({ type: 'item_reference', id });
@@ -218,10 +302,6 @@ export async function convertToOpenAIResponsesInput({
                 break;
               }
 
-              const resolvedToolName = toolNameMapping.toProviderToolName(
-                part.toolName,
-              );
-
               if (hasLocalShellTool && resolvedToolName === 'local_shell') {
                 const parsedInput = await validateTypes({
                   value: part.input,
@@ -298,7 +378,7 @@ export async function convertToOpenAIResponsesInput({
                 type: 'function_call',
                 call_id: part.toolCallId,
                 name: resolvedToolName,
-                arguments: JSON.stringify(part.input),
+                arguments: serializeToolCallArguments(part.input),
                 id,
               });
               break;
@@ -328,6 +408,35 @@ export async function convertToOpenAIResponsesInput({
                 part.toolName,
               );
 
+              if (resolvedResultToolName === 'tool_search') {
+                const itemId =
+                  (
+                    part.providerOptions?.[providerOptionsName] as
+                      | { itemId?: string }
+                      | undefined
+                  )?.itemId ?? part.toolCallId;
+
+                if (store) {
+                  input.push({ type: 'item_reference', id: itemId });
+                } else if (part.output.type === 'json') {
+                  const parsedOutput = await validateTypes({
+                    value: part.output.value,
+                    schema: toolSearchOutputSchema,
+                  });
+
+                  input.push({
+                    type: 'tool_search_output',
+                    id: itemId,
+                    execution: 'server',
+                    call_id: null,
+                    status: 'completed',
+                    tools: parsedOutput.tools,
+                  });
+                }
+
+                break;
+              }
+
               /*
                * Shell tool results are separate output items (shell_call_output)
                * with their own item IDs distinct from the shell_call's item ID.
@@ -478,6 +587,36 @@ export async function convertToOpenAIResponsesInput({
               }
               break;
             }
+
+            case 'custom': {
+              if (part.kind === 'openai.compaction') {
+                const providerOpts =
+                  part.providerOptions?.[providerOptionsName];
+                const id = providerOpts?.itemId as string | undefined;
+
+                if (hasConversation && id != null) {
+                  break;
+                }
+
+                if (store && id != null) {
+                  input.push({ type: 'item_reference', id });
+                  break;
+                }
+
+                const encryptedContent = providerOpts?.encryptedContent as
+                  | string
+                  | undefined;
+
+                if (id != null) {
+                  input.push({
+                    type: 'compaction',
+                    id,
+                    encrypted_content: encryptedContent!,
+                  } satisfies OpenAIResponsesCompactionItem);
+                }
+              }
+              break;
+            }
           }
         }
 
@@ -488,7 +627,7 @@ export async function convertToOpenAIResponsesInput({
         for (const part of content) {
           if (part.type === 'tool-approval-response') {
             const approvalResponse =
-              part as LanguageModelV3ToolApprovalResponsePart;
+              part as LanguageModelV4ToolApprovalResponsePart;
 
             if (processedApprovalIds.has(approvalResponse.approvalId)) {
               continue;
@@ -527,6 +666,22 @@ export async function convertToOpenAIResponsesInput({
             part.toolName,
           );
 
+          if (resolvedToolName === 'tool_search' && output.type === 'json') {
+            const parsedOutput = await validateTypes({
+              value: output.value,
+              schema: toolSearchOutputSchema,
+            });
+
+            input.push({
+              type: 'tool_search_output',
+              execution: 'client',
+              call_id: part.toolCallId,
+              status: 'completed',
+              tools: parsedOutput.tools,
+            });
+            continue;
+          }
+
           if (
             hasLocalShellTool &&
             resolvedToolName === 'local_shell' &&
@@ -600,7 +755,7 @@ export async function convertToOpenAIResponsesInput({
                 outputValue = output.value;
                 break;
               case 'execution-denied':
-                outputValue = output.reason ?? 'Tool execution denied.';
+                outputValue = output.reason ?? 'Tool call execution denied.';
                 break;
               case 'json':
               case 'error-json':
@@ -612,22 +767,29 @@ export async function convertToOpenAIResponsesInput({
                     switch (item.type) {
                       case 'text':
                         return { type: 'input_text' as const, text: item.text };
-                      case 'image-data':
-                        return {
-                          type: 'input_image' as const,
-                          image_url: `data:${item.mediaType};base64,${item.data}`,
-                        };
-                      case 'image-url':
-                        return {
-                          type: 'input_image' as const,
-                          image_url: item.url,
-                        };
                       case 'file-data':
+                        if (item.mediaType.startsWith('image/')) {
+                          return {
+                            type: 'input_image' as const,
+                            image_url: `data:${item.mediaType};base64,${item.data}`,
+                          };
+                        }
                         return {
                           type: 'input_file' as const,
                           filename: item.filename ?? 'data',
                           file_data: `data:${item.mediaType};base64,${item.data}`,
                         };
+                      case 'file-url':
+                        if (item.mediaType.startsWith('image/')) {
+                          return {
+                            type: 'input_image' as const,
+                            image_url: item.url,
+                          };
+                        }
+                        return {
+                          type: 'input_file' as const,
+                          file_url: item.url,
+                        };
                       default:
                         warnings.push({
                           type: 'other',
@@ -656,7 +818,7 @@ export async function convertToOpenAIResponsesInput({
               contentValue = output.value;
               break;
             case 'execution-denied':
-              contentValue = output.reason ?? 'Tool execution denied.';
+              contentValue = output.reason ?? 'Tool call execution denied.';
               break;
             case 'json':
             case 'error-json':
@@ -670,25 +832,30 @@ export async function convertToOpenAIResponsesInput({
                       return { type: 'input_text' as const, text: item.text };
                     }
 
-                    case 'image-data': {
-                      return {
-                        type: 'input_image' as const,
-                        image_url: `data:${item.mediaType};base64,${item.data}`,
-                      };
-                    }
-
-                    case 'image-url': {
+                    case 'file-data': {
+                      if (item.mediaType.startsWith('image/')) {
+                        return {
+                          type: 'input_image' as const,
+                          image_url: `data:${item.mediaType};base64,${item.data}`,
+                        };
+                      }
                       return {
-                        type: 'input_image' as const,
-                        image_url: item.url,
+                        type: 'input_file' as const,
+                        filename: item.filename ?? 'data',
+                        file_data: `data:${item.mediaType};base64,${item.data}`,
                       };
                     }
 
-                    case 'file-data': {
+                    case 'file-url': {
+                      if (item.mediaType.startsWith('image/')) {
+                        return {
+                          type: 'input_image' as const,
+                          image_url: item.url,
+                        };
+                      }
                       return {
                         type: 'input_file' as const,
-                        filename: item.filename ?? 'data',
-                        file_data: `data:${item.mediaType};base64,${item.data}`,
+                        file_url: item.url,
                       };
                     }
 

package/src/responses/map-openai-responses-finish-reason.ts

@@ -1,4 +1,4 @@
-import { LanguageModelV3FinishReason } from '@ai-sdk/provider';
+import type { LanguageModelV4FinishReason } from '@ai-sdk/provider';
 
 export function mapOpenAIResponseFinishReason({
   finishReason,
@@ -7,7 +7,7 @@ export function mapOpenAIResponseFinishReason({
   finishReason: string | null | undefined;
   // flag that checks if there have been client-side tool calls (not executed by openai)
   hasFunctionCall: boolean;
-}): LanguageModelV3FinishReason['unified'] {
+}): LanguageModelV4FinishReason['unified'] {
   switch (finishReason) {
     case undefined:
     case null: