@ai-sdk/openai 3.0.13 → 3.0.15

package/src/chat/convert-to-openai-chat-messages.ts

@@ -0,0 +1,225 @@
+import {
+  SharedV3Warning,
+  LanguageModelV3Prompt,
+  UnsupportedFunctionalityError,
+} from '@ai-sdk/provider';
+import { OpenAIChatPrompt } from './openai-chat-prompt';
+import { convertToBase64 } from '@ai-sdk/provider-utils';
+
+export function convertToOpenAIChatMessages({
+  prompt,
+  systemMessageMode = 'system',
+}: {
+  prompt: LanguageModelV3Prompt;
+  systemMessageMode?: 'system' | 'developer' | 'remove';
+}): {
+  messages: OpenAIChatPrompt;
+  warnings: Array<SharedV3Warning>;
+} {
+  const messages: OpenAIChatPrompt = [];
+  const warnings: Array<SharedV3Warning> = [];
+
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case 'system': {
+        switch (systemMessageMode) {
+          case 'system': {
+            messages.push({ role: 'system', content });
+            break;
+          }
+          case 'developer': {
+            messages.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': {
+        if (content.length === 1 && content[0].type === 'text') {
+          messages.push({ role: 'user', content: content[0].text });
+          break;
+        }
+
+        messages.push({
+          role: 'user',
+          content: content.map((part, index) => {
+            switch (part.type) {
+              case 'text': {
+                return { type: 'text', text: part.text };
+              }
+              case 'file': {
+                if (part.mediaType.startsWith('image/')) {
+                  const mediaType =
+                    part.mediaType === 'image/*'
+                      ? 'image/jpeg'
+                      : part.mediaType;
+
+                  return {
+                    type: 'image_url',
+                    image_url: {
+                      url:
+                        part.data instanceof URL
+                          ? part.data.toString()
+                          : `data:${mediaType};base64,${convertToBase64(part.data)}`,
+
+                      // OpenAI specific extension: image detail
+                      detail: part.providerOptions?.openai?.imageDetail,
+                    },
+                  };
+                } else if (part.mediaType.startsWith('audio/')) {
+                  if (part.data instanceof URL) {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: 'audio file parts with URLs',
+                    });
+                  }
+
+                  switch (part.mediaType) {
+                    case 'audio/wav': {
+                      return {
+                        type: 'input_audio',
+                        input_audio: {
+                          data: convertToBase64(part.data),
+                          format: 'wav',
+                        },
+                      };
+                    }
+                    case 'audio/mp3':
+                    case 'audio/mpeg': {
+                      return {
+                        type: 'input_audio',
+                        input_audio: {
+                          data: convertToBase64(part.data),
+                          format: 'mp3',
+                        },
+                      };
+                    }
+
+                    default: {
+                      throw new UnsupportedFunctionalityError({
+                        functionality: `audio content parts with media type ${part.mediaType}`,
+                      });
+                    }
+                  }
+                } else if (part.mediaType === 'application/pdf') {
+                  if (part.data instanceof URL) {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: 'PDF file parts with URLs',
+                    });
+                  }
+
+                  return {
+                    type: 'file',
+                    file:
+                      typeof part.data === 'string' &&
+                      part.data.startsWith('file-')
+                        ? { 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': {
+        let text = '';
+        const toolCalls: Array<{
+          id: string;
+          type: 'function';
+          function: { name: string; arguments: string };
+        }> = [];
+
+        for (const part of content) {
+          switch (part.type) {
+            case 'text': {
+              text += part.text;
+              break;
+            }
+            case 'tool-call': {
+              toolCalls.push({
+                id: part.toolCallId,
+                type: 'function',
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.input),
+                },
+              });
+              break;
+            }
+          }
+        }
+
+        messages.push({
+          role: 'assistant',
+          content: text,
+          tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+        });
+
+        break;
+      }
+
+      case 'tool': {
+        for (const toolResponse of content) {
+          if (toolResponse.type === 'tool-approval-response') {
+            continue;
+          }
+          const output = toolResponse.output;
+
+          let contentValue: string;
+          switch (output.type) {
+            case 'text':
+            case 'error-text':
+              contentValue = output.value;
+              break;
+            case 'execution-denied':
+              contentValue = output.reason ?? 'Tool execution denied.';
+              break;
+            case 'content':
+            case 'json':
+            case 'error-json':
+              contentValue = JSON.stringify(output.value);
+              break;
+          }
+
+          messages.push({
+            role: 'tool',
+            tool_call_id: toolResponse.toolCallId,
+            content: contentValue,
+          });
+        }
+        break;
+      }
+
+      default: {
+        const _exhaustiveCheck: never = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+
+  return { messages, warnings };
+}

package/src/chat/get-response-metadata.ts

@@ -0,0 +1,15 @@
+export function getResponseMetadata({
+  id,
+  model,
+  created,
+}: {
+  id?: string | undefined | null;
+  created?: number | undefined | null;
+  model?: string | undefined | null;
+}) {
+  return {
+    id: id ?? undefined,
+    modelId: model ?? undefined,
+    timestamp: created ? new Date(created * 1000) : undefined,
+  };
+}

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

@@ -0,0 +1,19 @@
+import { LanguageModelV3FinishReason } from '@ai-sdk/provider';
+
+export function mapOpenAIFinishReason(
+  finishReason: string | null | undefined,
+): LanguageModelV3FinishReason['unified'] {
+  switch (finishReason) {
+    case 'stop':
+      return 'stop';
+    case 'length':
+      return 'length';
+    case 'content_filter':
+      return 'content-filter';
+    case 'function_call':
+    case 'tool_calls':
+      return 'tool-calls';
+    default:
+      return 'other';
+  }
+}

package/src/chat/openai-chat-api.ts

@@ -0,0 +1,198 @@
+import { JSONSchema7 } from '@ai-sdk/provider';
+import { InferSchema, lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { openaiErrorDataSchema } from '../openai-error';
+
+export interface OpenAIChatFunctionTool {
+  type: 'function';
+  function: {
+    name: string;
+    description: string | undefined;
+    parameters: JSONSchema7;
+    strict?: boolean;
+  };
+}
+
+export type OpenAIChatToolChoice =
+  | 'auto'
+  | 'none'
+  | 'required'
+  | { type: 'function'; function: { name: string } };
+
+// limited version of the schema, focussed on what is needed for the implementation
+// this approach limits breakages when the API changes and increases efficiency
+export const openaiChatResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      id: z.string().nullish(),
+      created: z.number().nullish(),
+      model: z.string().nullish(),
+      choices: z.array(
+        z.object({
+          message: z.object({
+            role: z.literal('assistant').nullish(),
+            content: z.string().nullish(),
+            tool_calls: z
+              .array(
+                z.object({
+                  id: z.string().nullish(),
+                  type: z.literal('function'),
+                  function: z.object({
+                    name: z.string(),
+                    arguments: z.string(),
+                  }),
+                }),
+              )
+              .nullish(),
+            annotations: z
+              .array(
+                z.object({
+                  type: z.literal('url_citation'),
+                  url_citation: z.object({
+                    start_index: z.number(),
+                    end_index: z.number(),
+                    url: z.string(),
+                    title: z.string(),
+                  }),
+                }),
+              )
+              .nullish(),
+          }),
+          index: z.number(),
+          logprobs: z
+            .object({
+              content: z
+                .array(
+                  z.object({
+                    token: z.string(),
+                    logprob: z.number(),
+                    top_logprobs: z.array(
+                      z.object({
+                        token: z.string(),
+                        logprob: z.number(),
+                      }),
+                    ),
+                  }),
+                )
+                .nullish(),
+            })
+            .nullish(),
+          finish_reason: z.string().nullish(),
+        }),
+      ),
+      usage: z
+        .object({
+          prompt_tokens: z.number().nullish(),
+          completion_tokens: z.number().nullish(),
+          total_tokens: z.number().nullish(),
+          prompt_tokens_details: z
+            .object({
+              cached_tokens: z.number().nullish(),
+            })
+            .nullish(),
+          completion_tokens_details: z
+            .object({
+              reasoning_tokens: z.number().nullish(),
+              accepted_prediction_tokens: z.number().nullish(),
+              rejected_prediction_tokens: z.number().nullish(),
+            })
+            .nullish(),
+        })
+        .nullish(),
+    }),
+  ),
+);
+
+// limited version of the schema, focussed on what is needed for the implementation
+// this approach limits breakages when the API changes and increases efficiency
+export const openaiChatChunkSchema = lazySchema(() =>
+  zodSchema(
+    z.union([
+      z.object({
+        id: z.string().nullish(),
+        created: z.number().nullish(),
+        model: z.string().nullish(),
+        choices: z.array(
+          z.object({
+            delta: z
+              .object({
+                role: z.enum(['assistant']).nullish(),
+                content: z.string().nullish(),
+                tool_calls: z
+                  .array(
+                    z.object({
+                      index: z.number(),
+                      id: z.string().nullish(),
+                      type: z.literal('function').nullish(),
+                      function: z.object({
+                        name: z.string().nullish(),
+                        arguments: z.string().nullish(),
+                      }),
+                    }),
+                  )
+                  .nullish(),
+                annotations: z
+                  .array(
+                    z.object({
+                      type: z.literal('url_citation'),
+                      url_citation: z.object({
+                        start_index: z.number(),
+                        end_index: z.number(),
+                        url: z.string(),
+                        title: z.string(),
+                      }),
+                    }),
+                  )
+                  .nullish(),
+              })
+              .nullish(),
+            logprobs: z
+              .object({
+                content: z
+                  .array(
+                    z.object({
+                      token: z.string(),
+                      logprob: z.number(),
+                      top_logprobs: z.array(
+                        z.object({
+                          token: z.string(),
+                          logprob: z.number(),
+                        }),
+                      ),
+                    }),
+                  )
+                  .nullish(),
+              })
+              .nullish(),
+            finish_reason: z.string().nullish(),
+            index: z.number(),
+          }),
+        ),
+        usage: z
+          .object({
+            prompt_tokens: z.number().nullish(),
+            completion_tokens: z.number().nullish(),
+            total_tokens: z.number().nullish(),
+            prompt_tokens_details: z
+              .object({
+                cached_tokens: z.number().nullish(),
+              })
+              .nullish(),
+            completion_tokens_details: z
+              .object({
+                reasoning_tokens: z.number().nullish(),
+                accepted_prediction_tokens: z.number().nullish(),
+                rejected_prediction_tokens: z.number().nullish(),
+              })
+              .nullish(),
+          })
+          .nullish(),
+      }),
+      openaiErrorDataSchema,
+    ]),
+  ),
+);
+
+export type OpenAIChatResponse = InferSchema<typeof openaiChatResponseSchema>;
+
+export type OpenAIChatChunk = InferSchema<typeof openaiChatChunkSchema>;