@ai-sdk/openai 3.0.14 → 3.0.15

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

@@ -0,0 +1,578 @@
+import {
+  LanguageModelV3Prompt,
+  LanguageModelV3ToolApprovalResponsePart,
+  SharedV3Warning,
+  UnsupportedFunctionalityError,
+} from '@ai-sdk/provider';
+import {
+  convertToBase64,
+  isNonNullable,
+  parseProviderOptions,
+  ToolNameMapping,
+  validateTypes,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { applyPatchOutputSchema } from '../tool/apply-patch';
+import {
+  localShellInputSchema,
+  localShellOutputSchema,
+} from '../tool/local-shell';
+import { shellInputSchema, shellOutputSchema } from '../tool/shell';
+import {
+  OpenAIResponsesFunctionCallOutput,
+  OpenAIResponsesInput,
+  OpenAIResponsesReasoning,
+} from './openai-responses-api';
+
+/**
+ * Check if a string is a file ID based on the given prefixes
+ * Returns false if prefixes is undefined (disables file ID detection)
+ */
+function isFileId(data: string, prefixes?: readonly string[]): boolean {
+  if (!prefixes) return false;
+  return prefixes.some(prefix => data.startsWith(prefix));
+}
+
+export async function convertToOpenAIResponsesInput({
+  prompt,
+  toolNameMapping,
+  systemMessageMode,
+  providerOptionsName,
+  fileIdPrefixes,
+  store,
+  hasConversation = false,
+  hasLocalShellTool = false,
+  hasShellTool = false,
+  hasApplyPatchTool = false,
+}: {
+  prompt: LanguageModelV3Prompt;
+  toolNameMapping: ToolNameMapping;
+  systemMessageMode: 'system' | 'developer' | 'remove';
+  providerOptionsName: string;
+  fileIdPrefixes?: readonly string[];
+  store: boolean;
+  hasConversation?: boolean; // when true, skip assistant messages that already have item IDs
+  hasLocalShellTool?: boolean;
+  hasShellTool?: boolean;
+  hasApplyPatchTool?: boolean;
+}): Promise<{
+  input: OpenAIResponsesInput;
+  warnings: Array<SharedV3Warning>;
+}> {
+  const input: OpenAIResponsesInput = [];
+  const warnings: Array<SharedV3Warning> = [];
+  const processedApprovalIds = new Set<string>();
+
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case 'system': {
+        switch (systemMessageMode) {
+          case 'system': {
+            input.push({ role: 'system', content });
+            break;
+          }
+          case 'developer': {
+            input.push({ role: 'developer', content });
+            break;
+          }
+          case 'remove': {
+            warnings.push({
+              type: 'other',
+              message: 'system messages are removed for this model',
+            });
+            break;
+          }
+          default: {
+            const _exhaustiveCheck: never = systemMessageMode;
+            throw new Error(
+              `Unsupported system message mode: ${_exhaustiveCheck}`,
+            );
+          }
+        }
+        break;
+      }
+
+      case 'user': {
+        input.push({
+          role: 'user',
+          content: content.map((part, index) => {
+            switch (part.type) {
+              case 'text': {
+                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) {
+                    return {
+                      type: 'input_file',
+                      file_url: part.data.toString(),
+                    };
+                  }
+                  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}`,
+                  });
+                }
+              }
+            }
+          }),
+        });
+
+        break;
+      }
+
+      case 'assistant': {
+        const reasoningMessages: Record<string, OpenAIResponsesReasoning> = {};
+
+        for (const part of content) {
+          switch (part.type) {
+            case 'text': {
+              const id = part.providerOptions?.[providerOptionsName]?.itemId as
+                | string
+                | undefined;
+
+              // when using conversation, skip items that already exist in the conversation context to avoid "Duplicate item found" errors
+              if (hasConversation && id != null) {
+                break;
+              }
+
+              // item references reduce the payload size
+              if (store && id != null) {
+                input.push({ type: 'item_reference', id });
+                break;
+              }
+
+              input.push({
+                role: 'assistant',
+                content: [{ type: 'output_text', text: part.text }],
+                id,
+              });
+
+              break;
+            }
+            case 'tool-call': {
+              const id = (part.providerOptions?.[providerOptionsName]?.itemId ??
+                (
+                  part as {
+                    providerMetadata?: {
+                      [providerOptionsName]?: { itemId?: string };
+                    };
+                  }
+                ).providerMetadata?.[providerOptionsName]?.itemId) as
+                | string
+                | undefined;
+
+              if (hasConversation && id != null) {
+                break;
+              }
+
+              if (part.providerExecuted) {
+                if (store && id != null) {
+                  input.push({ type: 'item_reference', id });
+                }
+                break;
+              }
+
+              if (store && id != null) {
+                input.push({ type: 'item_reference', id });
+                break;
+              }
+
+              const resolvedToolName = toolNameMapping.toProviderToolName(
+                part.toolName,
+              );
+
+              if (hasLocalShellTool && resolvedToolName === 'local_shell') {
+                const parsedInput = await validateTypes({
+                  value: part.input,
+                  schema: localShellInputSchema,
+                });
+                input.push({
+                  type: 'local_shell_call',
+                  call_id: part.toolCallId,
+                  id: id!,
+                  action: {
+                    type: 'exec',
+                    command: parsedInput.action.command,
+                    timeout_ms: parsedInput.action.timeoutMs,
+                    user: parsedInput.action.user,
+                    working_directory: parsedInput.action.workingDirectory,
+                    env: parsedInput.action.env,
+                  },
+                });
+
+                break;
+              }
+
+              if (hasShellTool && resolvedToolName === 'shell') {
+                const parsedInput = await validateTypes({
+                  value: part.input,
+                  schema: shellInputSchema,
+                });
+                input.push({
+                  type: 'shell_call',
+                  call_id: part.toolCallId,
+                  id: id!,
+                  status: 'completed',
+                  action: {
+                    commands: parsedInput.action.commands,
+                    timeout_ms: parsedInput.action.timeoutMs,
+                    max_output_length: parsedInput.action.maxOutputLength,
+                  },
+                });
+
+                break;
+              }
+
+              input.push({
+                type: 'function_call',
+                call_id: part.toolCallId,
+                name: resolvedToolName,
+                arguments: JSON.stringify(part.input),
+                id,
+              });
+              break;
+            }
+
+            // assistant tool result parts are from provider-executed tools:
+            case 'tool-result': {
+              // Skip execution-denied results - these are synthetic results from denied
+              // approvals and have no corresponding item in OpenAI's store.
+              // Check both the direct type and if it was transformed to json with execution-denied inside
+              if (
+                part.output.type === 'execution-denied' ||
+                (part.output.type === 'json' &&
+                  typeof part.output.value === 'object' &&
+                  part.output.value != null &&
+                  'type' in part.output.value &&
+                  part.output.value.type === 'execution-denied')
+              ) {
+                break;
+              }
+
+              if (hasConversation) {
+                break;
+              }
+
+              if (store) {
+                const itemId =
+                  (
+                    part as {
+                      providerMetadata?: {
+                        [providerOptionsName]?: { itemId?: string };
+                      };
+                    }
+                  ).providerMetadata?.[providerOptionsName]?.itemId ??
+                  part.toolCallId;
+                input.push({ type: 'item_reference', id: itemId });
+              } else {
+                warnings.push({
+                  type: 'other',
+                  message: `Results for OpenAI tool ${part.toolName} are not sent to the API when store is false`,
+                });
+              }
+
+              break;
+            }
+
+            case 'reasoning': {
+              const providerOptions = await parseProviderOptions({
+                provider: providerOptionsName,
+                providerOptions: part.providerOptions,
+                schema: openaiResponsesReasoningProviderOptionsSchema,
+              });
+
+              const reasoningId = providerOptions?.itemId;
+
+              if (hasConversation && reasoningId != null) {
+                break;
+              }
+
+              if (reasoningId != null) {
+                const reasoningMessage = reasoningMessages[reasoningId];
+
+                if (store) {
+                  // use item references to refer to reasoning (single reference)
+                  // when the first part is encountered
+                  if (reasoningMessage === undefined) {
+                    input.push({ type: 'item_reference', id: reasoningId });
+
+                    // store unused reasoning message to mark id as used
+                    reasoningMessages[reasoningId] = {
+                      type: 'reasoning',
+                      id: reasoningId,
+                      summary: [],
+                    };
+                  }
+                } else {
+                  const summaryParts: Array<{
+                    type: 'summary_text';
+                    text: string;
+                  }> = [];
+
+                  if (part.text.length > 0) {
+                    summaryParts.push({
+                      type: 'summary_text',
+                      text: part.text,
+                    });
+                  } else if (reasoningMessage !== undefined) {
+                    warnings.push({
+                      type: 'other',
+                      message: `Cannot append empty reasoning part to existing reasoning sequence. Skipping reasoning part: ${JSON.stringify(part)}.`,
+                    });
+                  }
+
+                  if (reasoningMessage === undefined) {
+                    reasoningMessages[reasoningId] = {
+                      type: 'reasoning',
+                      id: reasoningId,
+                      encrypted_content:
+                        providerOptions?.reasoningEncryptedContent,
+                      summary: summaryParts,
+                    };
+                    input.push(reasoningMessages[reasoningId]);
+                  } else {
+                    reasoningMessage.summary.push(...summaryParts);
+
+                    // updated encrypted content to enable setting it in the last summary part:
+                    if (providerOptions?.reasoningEncryptedContent != null) {
+                      reasoningMessage.encrypted_content =
+                        providerOptions.reasoningEncryptedContent;
+                    }
+                  }
+                }
+              } else {
+                warnings.push({
+                  type: 'other',
+                  message: `Non-OpenAI reasoning parts are not supported. Skipping reasoning part: ${JSON.stringify(part)}.`,
+                });
+              }
+              break;
+            }
+          }
+        }
+
+        break;
+      }
+
+      case 'tool': {
+        for (const part of content) {
+          if (part.type === 'tool-approval-response') {
+            const approvalResponse =
+              part as LanguageModelV3ToolApprovalResponsePart;
+
+            if (processedApprovalIds.has(approvalResponse.approvalId)) {
+              continue;
+            }
+            processedApprovalIds.add(approvalResponse.approvalId);
+
+            if (store) {
+              input.push({
+                type: 'item_reference',
+                id: approvalResponse.approvalId,
+              });
+            }
+
+            input.push({
+              type: 'mcp_approval_response',
+              approval_request_id: approvalResponse.approvalId,
+              approve: approvalResponse.approved,
+            });
+            continue;
+          }
+
+          const output = part.output;
+
+          // Skip execution-denied with approvalId - already handled via tool-approval-response
+          if (output.type === 'execution-denied') {
+            const approvalId = (
+              output.providerOptions?.openai as { approvalId?: string }
+            )?.approvalId;
+
+            if (approvalId) {
+              continue;
+            }
+          }
+
+          const resolvedToolName = toolNameMapping.toProviderToolName(
+            part.toolName,
+          );
+
+          if (
+            hasLocalShellTool &&
+            resolvedToolName === 'local_shell' &&
+            output.type === 'json'
+          ) {
+            const parsedOutput = await validateTypes({
+              value: output.value,
+              schema: localShellOutputSchema,
+            });
+
+            input.push({
+              type: 'local_shell_call_output',
+              call_id: part.toolCallId,
+              output: parsedOutput.output,
+            });
+            continue;
+          }
+
+          if (
+            hasShellTool &&
+            resolvedToolName === 'shell' &&
+            output.type === 'json'
+          ) {
+            const parsedOutput = await validateTypes({
+              value: output.value,
+              schema: shellOutputSchema,
+            });
+
+            input.push({
+              type: 'shell_call_output',
+              call_id: part.toolCallId,
+              output: parsedOutput.output.map(item => ({
+                stdout: item.stdout,
+                stderr: item.stderr,
+                outcome:
+                  item.outcome.type === 'timeout'
+                    ? { type: 'timeout' as const }
+                    : {
+                        type: 'exit' as const,
+                        exit_code: item.outcome.exitCode,
+                      },
+              })),
+            });
+            continue;
+          }
+
+          if (
+            hasApplyPatchTool &&
+            part.toolName === 'apply_patch' &&
+            output.type === 'json'
+          ) {
+            const parsedOutput = await validateTypes({
+              value: output.value,
+              schema: applyPatchOutputSchema,
+            });
+
+            input.push({
+              type: 'apply_patch_call_output',
+              call_id: part.toolCallId,
+              status: parsedOutput.status,
+              output: parsedOutput.output,
+            });
+            continue;
+          }
+
+          let contentValue: OpenAIResponsesFunctionCallOutput['output'];
+          switch (output.type) {
+            case 'text':
+            case 'error-text':
+              contentValue = output.value;
+              break;
+            case 'execution-denied':
+              contentValue = output.reason ?? 'Tool execution denied.';
+              break;
+            case 'json':
+            case 'error-json':
+              contentValue = JSON.stringify(output.value);
+              break;
+            case 'content':
+              contentValue = output.value
+                .map(item => {
+                  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': {
+                      return {
+                        type: 'input_file' as const,
+                        filename: item.filename ?? 'data',
+                        file_data: `data:${item.mediaType};base64,${item.data}`,
+                      };
+                    }
+
+                    default: {
+                      warnings.push({
+                        type: 'other',
+                        message: `unsupported tool content part type: ${item.type}`,
+                      });
+                      return undefined;
+                    }
+                  }
+                })
+                .filter(isNonNullable);
+              break;
+          }
+
+          input.push({
+            type: 'function_call_output',
+            call_id: part.toolCallId,
+            output: contentValue,
+          });
+        }
+
+        break;
+      }
+
+      default: {
+        const _exhaustiveCheck: never = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+
+  return { input, warnings };
+}
+
+const openaiResponsesReasoningProviderOptionsSchema = z.object({
+  itemId: z.string().nullish(),
+  reasoningEncryptedContent: z.string().nullish(),
+});
+
+export type OpenAIResponsesReasoningProviderOptions = z.infer<
+  typeof openaiResponsesReasoningProviderOptionsSchema
+>;

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

@@ -0,0 +1,22 @@
+import { LanguageModelV3FinishReason } from '@ai-sdk/provider';
+
+export function mapOpenAIResponseFinishReason({
+  finishReason,
+  hasFunctionCall,
+}: {
+  finishReason: string | null | undefined;
+  // flag that checks if there have been client-side tool calls (not executed by openai)
+  hasFunctionCall: boolean;
+}): LanguageModelV3FinishReason['unified'] {
+  switch (finishReason) {
+    case undefined:
+    case null:
+      return hasFunctionCall ? 'tool-calls' : 'stop';
+    case 'max_output_tokens':
+      return 'length';
+    case 'content_filter':
+      return 'content-filter';
+    default:
+      return hasFunctionCall ? 'tool-calls' : 'other';
+  }
+}

package/src/responses/openai-responses-api.test.ts

@@ -0,0 +1,89 @@
+import { InferSchema } from '@ai-sdk/provider-utils';
+import { describe, expectTypeOf, it } from 'vitest';
+import {
+  openaiResponsesChunkSchema,
+  openaiResponsesResponseSchema,
+} from './openai-responses-api';
+
+/**
+ * expectTypeOf is utilized to ensure that the required sections of openaiResponsesChunkSchema
+ * and openaiResponsesResponseSchema are of the same type.
+ */
+
+describe('openaiResponses schema alignment', () => {
+  type Chunk = InferSchema<typeof openaiResponsesChunkSchema>;
+  type Response = InferSchema<typeof openaiResponsesResponseSchema>;
+
+  it('matches annotation shape between chunk and response schemas', () => {
+    type ChunkAnnotation = Extract<
+      Chunk,
+      { type: 'response.output_text.annotation.added' }
+    >['annotation'];
+
+    type ResponseAnnotation = Extract<
+      NonNullable<Response['output']>[number],
+      { type: 'message' }
+    >['content'][number]['annotations'][number];
+
+    expectTypeOf<ChunkAnnotation>().toEqualTypeOf<ResponseAnnotation>();
+  });
+
+  it('aligns web_search_call actions', () => {
+    type ChunkWebSearchAction = Extract<
+      Extract<Chunk, { type: 'response.output_item.done' }>['item'],
+      { type: 'web_search_call' }
+    >['action'];
+
+    type ResponseWebSearchAction = Extract<
+      NonNullable<Response['output']>[number],
+      { type: 'web_search_call' }
+    >['action'];
+
+    expectTypeOf<ChunkWebSearchAction>().toEqualTypeOf<ResponseWebSearchAction>();
+  });
+
+  it('aligns code_interpreter outputs', () => {
+    type ChunkCodeInterpreterOutputs = Extract<
+      Extract<Chunk, { type: 'response.output_item.done' }>['item'],
+      { type: 'code_interpreter_call' }
+    >['outputs'];
+
+    type ResponseCodeInterpreterOutputs = Extract<
+      NonNullable<Response['output']>[number],
+      { type: 'code_interpreter_call' }
+    >['outputs'];
+
+    expectTypeOf<ChunkCodeInterpreterOutputs>().toEqualTypeOf<ResponseCodeInterpreterOutputs>();
+  });
+
+  it('aligns file_search_call results', () => {
+    type ChunkFileSearchResults = Extract<
+      Extract<Chunk, { type: 'response.output_item.done' }>['item'],
+      { type: 'file_search_call' }
+    >['results'];
+
+    type ResponseFileSearchResults = Extract<
+      NonNullable<Response['output']>[number],
+      { type: 'file_search_call' }
+    >['results'];
+
+    expectTypeOf<ChunkFileSearchResults>().toEqualTypeOf<ResponseFileSearchResults>();
+  });
+
+  it('aligns output_text logprobs', () => {
+    type ChunkLogprobs = Extract<
+      Chunk,
+      { type: 'response.output_text.delta' }
+    >['logprobs'];
+
+    type ResponseLogprobs = Extract<
+      Extract<
+        NonNullable<Response['output']>[number],
+        { type: 'message' }
+      >['content'][number],
+      { type: 'output_text' }
+    >['logprobs'];
+
+    expectTypeOf<ChunkLogprobs>().toEqualTypeOf<ResponseLogprobs>();
+  });
+});