@ai-sdk/openai 4.0.0-beta.6 → 4.0.0-beta.74

package/src/openai-provider.ts

@@ -1,33 +1,40 @@
-import {
+import type {
   EmbeddingModelV4,
+  FilesV4,
   ImageModelV4,
   LanguageModelV4,
   ProviderV4,
+  Experimental_RealtimeFactoryV4 as RealtimeFactoryV4,
+  Experimental_RealtimeFactoryV4GetTokenOptions as RealtimeFactoryV4GetTokenOptions,
   SpeechModelV4,
+  SkillsV4,
   TranscriptionModelV4,
 } from '@ai-sdk/provider';
 import {
-  FetchFunction,
   loadApiKey,
   loadOptionalSetting,
   withoutTrailingSlash,
   withUserAgentSuffix,
+  type FetchFunction,
 } from '@ai-sdk/provider-utils';
 import { OpenAIChatLanguageModel } from './chat/openai-chat-language-model';
-import { OpenAIChatModelId } from './chat/openai-chat-options';
+import type { OpenAIChatModelId } from './chat/openai-chat-language-model-options';
 import { OpenAICompletionLanguageModel } from './completion/openai-completion-language-model';
-import { OpenAICompletionModelId } from './completion/openai-completion-options';
+import type { OpenAICompletionModelId } from './completion/openai-completion-language-model-options';
 import { OpenAIEmbeddingModel } from './embedding/openai-embedding-model';
-import { OpenAIEmbeddingModelId } from './embedding/openai-embedding-options';
+import { OpenAIFiles } from './files/openai-files';
+import type { OpenAIEmbeddingModelId } from './embedding/openai-embedding-model-options';
 import { OpenAIImageModel } from './image/openai-image-model';
-import { OpenAIImageModelId } from './image/openai-image-options';
+import type { OpenAIImageModelId } from './image/openai-image-model-options';
 import { openaiTools } from './openai-tools';
+import { OpenAIRealtimeModel } from './realtime/openai-realtime-model';
 import { OpenAIResponsesLanguageModel } from './responses/openai-responses-language-model';
-import { OpenAIResponsesModelId } from './responses/openai-responses-options';
+import type { OpenAIResponsesModelId } from './responses/openai-responses-language-model-options';
 import { OpenAISpeechModel } from './speech/openai-speech-model';
-import { OpenAISpeechModelId } from './speech/openai-speech-options';
+import type { OpenAISpeechModelId } from './speech/openai-speech-model-options';
 import { OpenAITranscriptionModel } from './transcription/openai-transcription-model';
-import { OpenAITranscriptionModelId } from './transcription/openai-transcription-options';
+import type { OpenAITranscriptionModelId } from './transcription/openai-transcription-model-options';
+import { OpenAISkills } from './skills/openai-skills';
 import { VERSION } from './version';
 
 export interface OpenAIProvider extends ProviderV4 {
@@ -93,6 +100,22 @@ export interface OpenAIProvider extends ProviderV4 {
    */
   speech(modelId: OpenAISpeechModelId): SpeechModelV4;
 
+  /**
+   * Creates an experimental realtime model for bidirectional audio/text
+   * communication over WebSocket.
+   */
+  experimental_realtime: RealtimeFactoryV4;
+
+  /**
+   * Returns a FilesV4 interface for uploading files to OpenAI.
+   */
+  files(): FilesV4;
+
+  /**
+   * Returns a SkillsV4 interface for uploading skills to OpenAI.
+   */
+  skills(): SkillsV4;
+
   /**
    * OpenAI-specific tools.
    */
@@ -216,6 +239,22 @@ export function createOpenAI(
       fetch: options.fetch,
     });
 
+  const createFiles = () =>
+    new OpenAIFiles({
+      provider: `${providerName}.files`,
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  const createSkills = () =>
+    new OpenAISkills({
+      provider: `${providerName}.skills`,
+      url: ({ path }) => `${baseURL}${path}`,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
   const createLanguageModel = (modelId: OpenAIResponsesModelId) => {
     if (new.target) {
       throw new Error(
@@ -232,10 +271,38 @@ export function createOpenAI(
       url: ({ path }) => `${baseURL}${path}`,
       headers: getHeaders,
       fetch: options.fetch,
+      // Soft-deprecated. TODO: remove in v8
       fileIdPrefixes: ['file-'],
     });
   };
 
+  const createRealtimeModel = (modelId: string) =>
+    new OpenAIRealtimeModel(modelId, {
+      provider: `${providerName}.realtime`,
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  const experimentalRealtimeFactory = Object.assign(
+    (modelId: string) => createRealtimeModel(modelId),
+    {
+      getToken: async (tokenOptions: RealtimeFactoryV4GetTokenOptions) => {
+        const model = createRealtimeModel(tokenOptions.model);
+        const secret = await model.doCreateClientSecret({
+          sessionConfig: tokenOptions.sessionConfig,
+          expiresAfterSeconds: tokenOptions.expiresAfterSeconds,
+        });
+
+        return {
+          token: secret.token,
+          url: secret.url,
+          expiresAt: secret.expiresAt,
+        };
+      },
+    },
+  ) as RealtimeFactoryV4;
+
   const provider = function (modelId: OpenAIResponsesModelId) {
     return createLanguageModel(modelId);
   };
@@ -258,6 +325,10 @@ export function createOpenAI(
 
   provider.speech = createSpeechModel;
   provider.speechModel = createSpeechModel;
+  provider.files = createFiles;
+  provider.skills = createSkills;
+
+  provider.experimental_realtime = experimentalRealtimeFactory;
 
   provider.tools = openaiTools;
 

package/src/openai-stream-error.ts

@@ -0,0 +1,181 @@
+import { APICallError } from '@ai-sdk/provider';
+import type { ParseResult } from '@ai-sdk/provider-utils';
+
+type StreamError = {
+  message: string;
+  code?: string | number | null;
+  type?: string | null;
+  frame: unknown;
+};
+
+export async function throwIfOpenAIStreamErrorBeforeOutput<T>({
+  stream,
+  getError,
+  isOutputChunk,
+  url,
+  requestBodyValues,
+  responseHeaders,
+}: {
+  stream: ReadableStream<ParseResult<T>>;
+  getError: (chunk: T) => unknown | undefined;
+  isOutputChunk: (chunk: T) => boolean;
+  url: string;
+  requestBodyValues: unknown;
+  responseHeaders?: Record<string, string>;
+}): Promise<ReadableStream<ParseResult<T>>> {
+  const [streamForEarlyError, streamForConsumer] = stream.tee();
+  const reader = streamForEarlyError.getReader();
+
+  try {
+    while (true) {
+      const result = await reader.read();
+
+      if (result.done) {
+        return streamForConsumer;
+      }
+
+      const chunk = result.value;
+
+      if (!chunk.success) {
+        return streamForConsumer;
+      }
+
+      const errorFrame = getError(chunk.value);
+
+      if (errorFrame != null) {
+        streamForConsumer.cancel().catch(() => {});
+        throw createOpenAIStreamError({
+          frame: errorFrame,
+          url,
+          requestBodyValues,
+          responseHeaders,
+        });
+      }
+
+      if (isOutputChunk(chunk.value)) {
+        return streamForConsumer;
+      }
+    }
+  } finally {
+    reader.cancel().catch(() => {});
+    reader.releaseLock();
+  }
+}
+
+function createOpenAIStreamError({
+  frame,
+  url,
+  requestBodyValues,
+  responseHeaders,
+}: {
+  frame: unknown;
+  url: string;
+  requestBodyValues: unknown;
+  responseHeaders?: Record<string, string>;
+}): APICallError {
+  const streamError = parseStreamError(frame);
+  return new APICallError({
+    message:
+      streamError?.message ??
+      'OpenAI stream failed before any output was generated',
+    url,
+    requestBodyValues,
+    statusCode: streamError == null ? 500 : getStatusCode(streamError),
+    responseHeaders,
+    responseBody: JSON.stringify(frame),
+    data: frame,
+  });
+}
+
+function parseStreamError(frame: unknown): StreamError | undefined {
+  const value = asRecord(frame);
+
+  if (value == null) {
+    return undefined;
+  }
+
+  if (value.type === 'response.failed') {
+    const response = asRecord(value.response);
+    const responseError = asRecord(response?.error);
+
+    return typeof responseError?.message === 'string'
+      ? {
+          message: responseError.message,
+          code: getStringOrNumber(responseError.code),
+          type: 'response.failed',
+          frame,
+        }
+      : undefined;
+  }
+
+  const error = asRecord(value.error) ?? value;
+
+  return typeof error.message === 'string' &&
+    (asRecord(value.error) != null ||
+      typeof error.type === 'string' ||
+      'code' in error ||
+      'param' in error)
+    ? {
+        message: error.message,
+        code: getStringOrNumber(error.code),
+        type: typeof error.type === 'string' ? error.type : undefined,
+        frame,
+      }
+    : undefined;
+}
+
+function getStatusCode(error: StreamError): number {
+  if (typeof error.code === 'number' && isHttpErrorStatusCode(error.code)) {
+    return error.code;
+  }
+
+  if (typeof error.code === 'string' && /^\d{3}$/.test(error.code)) {
+    const numericCode = Number(error.code);
+    if (isHttpErrorStatusCode(numericCode)) {
+      return numericCode;
+    }
+  }
+
+  const discriminator = [error.code, error.type]
+    .filter(value => typeof value === 'string' || typeof value === 'number')
+    .join(' ')
+    .toLowerCase();
+
+  if (
+    ['insufficient_quota', 'rate_limit'].some(term =>
+      discriminator.includes(term),
+    )
+  ) {
+    return 429;
+  }
+  if (discriminator.includes('authentication')) return 401;
+  if (discriminator.includes('permission')) return 403;
+  if (discriminator.includes('not_found')) return 404;
+  if (
+    ['invalid', 'bad_request', 'context_length'].some(term =>
+      discriminator.includes(term),
+    )
+  ) {
+    return 400;
+  }
+  if (discriminator.includes('overload')) return 503;
+  if (discriminator.includes('timeout')) return 504;
+
+  return 500;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return typeof value === 'object' && value != null
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+function getStringOrNumber(value: unknown): string | number | undefined {
+  return typeof value === 'string' || typeof value === 'number'
+    ? value
+    : undefined;
+}
+
+function isHttpErrorStatusCode(value: number): boolean {
+  return Number.isInteger(value) && value >= 400 && value <= 599;
+}

package/src/openai-tools.ts

@@ -5,6 +5,7 @@ import { fileSearch } from './tool/file-search';
 import { imageGeneration } from './tool/image-generation';
 import { localShell } from './tool/local-shell';
 import { shell } from './tool/shell';
+import { toolSearch } from './tool/tool-search';
 import { webSearch } from './tool/web-search';
 import { webSearchPreview } from './tool/web-search-preview';
 import { mcp } from './tool/mcp';
@@ -24,7 +25,6 @@ export const openaiTools = {
    * Lark syntax). The model returns a `custom_tool_call` output item whose
    * `input` field is a string matching the specified grammar.
    *
-   * @param name - The name of the custom tool.
    * @param description - An optional description of the tool.
    * @param format - The output format constraint (grammar type, syntax, and definition).
    */
@@ -123,4 +123,15 @@ export const openaiTools = {
    * @param serverUrl - URL for the MCP server.
    */
   mcp,
+
+  /**
+   * Tool search allows the model to dynamically search for and load deferred
+   * tools into the model's context as needed. This helps reduce overall token
+   * usage, cost, and latency by only loading tools when the model needs them.
+   *
+   * To use tool search, mark functions or namespaces with `defer_loading: true`
+   * in the tools array. The model will use tool search to load these tools
+   * when it determines they are needed.
+   */
+  toolSearch,
 };

package/src/realtime/index.ts

@@ -0,0 +1,2 @@
+export { OpenAIRealtimeModel as Experimental_OpenAIRealtimeModel } from './openai-realtime-model';
+export type { OpenAIRealtimeModelConfig as Experimental_OpenAIRealtimeModelConfig } from './openai-realtime-model';