@nocobase/plugin-ai 2.1.7 → 2.1.8

package/dist/node_modules/openai/src/client.ts

@@ -11,16 +11,21 @@ import type { APIResponseProps } from './internal/parse';
 import { getPlatformHeaders } from './internal/detect-platform';
 import * as Shims from './internal/shims';
 import * as Opts from './internal/request-options';
-import * as qs from './internal/qs';
+import { stringifyQuery } from './internal/utils/query';
 import { VERSION } from './version';
 import * as Errors from './core/error';
 import * as Pagination from './core/pagination';
+import type { WorkloadIdentity } from './auth/types';
+import { WorkloadIdentityAuth } from './auth/workload-identity-auth';
+import { OAuthError, SubjectTokenProviderError } from './core/error';
 import {
   AbstractPage,
   type ConversationCursorPageParams,
   ConversationCursorPageResponse,
   type CursorPageParams,
   CursorPageResponse,
+  type NextCursorPageParams,
+  NextCursorPageResponse,
   PageResponse,
 } from './core/pagination';
 import * as Uploads from './core/uploads';
@@ -93,11 +98,17 @@ import {
   Moderations,
 } from './resources/moderations';
 import {
+  ImageInputReferenceParam,
   Video,
+  VideoCreateCharacterParams,
+  VideoCreateCharacterResponse,
   VideoCreateError,
   VideoCreateParams,
   VideoDeleteResponse,
   VideoDownloadContentParams,
+  VideoEditParams,
+  VideoExtendParams,
+  VideoGetCharacterResponse,
   VideoListParams,
   VideoModel,
   VideoRemixParams,
@@ -106,6 +117,7 @@ import {
   Videos,
   VideosPage,
 } from './resources/videos';
+import { Admin } from './resources/admin/admin';
 import { Audio, AudioModel, AudioResponseFormat } from './resources/audio/audio';
 import { Beta } from './resources/beta/beta';
 import { Chat } from './resources/chat/chat';
@@ -232,6 +244,8 @@ import {
 } from './internal/utils/log';
 import { isEmptyObj } from './internal/utils/values';
 
+const WORKLOAD_IDENTITY_API_KEY_PLACEHOLDER = 'workload-identity-auth';
+
 export type ApiKeySetter = () => Promise<string>;
 
 export interface ClientOptions {
@@ -245,8 +259,15 @@ export interface ClientOptions {
    * - The function must return a non-empty string; otherwise an OpenAIError is thrown.
    * - If the function throws, the error is wrapped in an OpenAIError with the original
    *   error available as `cause`.
+   * - Mutually exclusive with `workloadIdentity`.
    */
-  apiKey?: string | ApiKeySetter | undefined;
+  apiKey?: string | ApiKeySetter | null | undefined;
+
+  /**
+   * Defaults to process.env['OPENAI_ADMIN_KEY'].
+   */
+  adminAPIKey?: string | null | undefined;
+
   /**
    * Defaults to process.env['OPENAI_ORG_ID'].
    */
@@ -279,6 +300,7 @@ export interface ClientOptions {
    * @unit milliseconds
    */
   timeout?: number | undefined;
+
   /**
    * Additional `RequestInit` options to be passed to `fetch` calls.
    * Properties will be overridden by per-request `fetchOptions`.
@@ -335,13 +357,20 @@ export interface ClientOptions {
    * Defaults to globalThis.console.
    */
   logger?: Logger | undefined;
+
+  /**
+   * Workload identity configuration for OAuth2 token exchange authentication.
+   * Mutually exclusive with `apiKey`.
+   */
+  workloadIdentity?: WorkloadIdentity | undefined;
 }
 
 /**
  * API Client for interfacing with the OpenAI API.
  */
 export class OpenAI {
-  apiKey: string;
+  apiKey: string | null;
+  adminAPIKey: string | null;
   organization: string | null;
   project: string | null;
   webhookSecret: string | null;
@@ -357,11 +386,13 @@ export class OpenAI {
   #encoder: Opts.RequestEncoder;
   protected idempotencyHeader?: string;
   protected _options: ClientOptions;
+  private _workloadIdentityAuth?: WorkloadIdentityAuth;
 
   /**
    * API Client for interfacing with the OpenAI API.
    *
-   * @param {string | undefined} [opts.apiKey=process.env['OPENAI_API_KEY'] ?? undefined]
+   * @param {string | null | undefined} [opts.apiKey=process.env['OPENAI_API_KEY'] ?? null]
+   * @param {string | null | undefined} [opts.adminAPIKey=process.env['OPENAI_ADMIN_KEY'] ?? null]
    * @param {string | null | undefined} [opts.organization=process.env['OPENAI_ORG_ID'] ?? null]
    * @param {string | null | undefined} [opts.project=process.env['OPENAI_PROJECT_ID'] ?? null]
    * @param {string | null | undefined} [opts.webhookSecret=process.env['OPENAI_WEBHOOK_SECRET'] ?? null]
@@ -376,27 +407,35 @@ export class OpenAI {
    */
   constructor({
     baseURL = readEnv('OPENAI_BASE_URL'),
-    apiKey = readEnv('OPENAI_API_KEY'),
+    apiKey = readEnv('OPENAI_API_KEY') ?? null,
+    adminAPIKey = readEnv('OPENAI_ADMIN_KEY') ?? null,
     organization = readEnv('OPENAI_ORG_ID') ?? null,
     project = readEnv('OPENAI_PROJECT_ID') ?? null,
     webhookSecret = readEnv('OPENAI_WEBHOOK_SECRET') ?? null,
+    workloadIdentity,
     ...opts
   }: ClientOptions = {}) {
-    if (apiKey === undefined) {
-      throw new Errors.OpenAIError(
-        'Missing credentials. Please pass an `apiKey`, or set the `OPENAI_API_KEY` environment variable.',
-      );
-    }
-
     const options: ClientOptions = {
       apiKey,
+      adminAPIKey,
       organization,
       project,
       webhookSecret,
+      workloadIdentity,
       ...opts,
       baseURL: baseURL || `https://api.openai.com/v1`,
     };
 
+    if (apiKey && workloadIdentity) {
+      throw new Errors.OpenAIError('The `apiKey` and `workloadIdentity` options are mutually exclusive');
+    }
+
+    if (!apiKey && !adminAPIKey && !workloadIdentity) {
+      throw new Errors.OpenAIError(
+        'Missing credentials. Please pass an `apiKey`, `workloadIdentity`, `adminAPIKey`, or set the `OPENAI_API_KEY` or `OPENAI_ADMIN_KEY` environment variable.',
+      );
+    }
+
     if (!options.dangerouslyAllowBrowser && isRunningInBrowser()) {
       throw new Errors.OpenAIError(
         "It looks like you're running in a browser-like environment.\n\nThis is disabled by default, as it risks exposing your secret API credentials to attackers.\nIf you understand the risks and have appropriate mitigations in place,\nyou can set the `dangerouslyAllowBrowser` option to `true`, e.g.,\n\nnew OpenAI({ apiKey, dangerouslyAllowBrowser: true });\n\nhttps://help.openai.com/en/articles/5112595-best-practices-for-api-key-safety\n",
@@ -418,9 +457,26 @@ export class OpenAI {
     this.fetch = options.fetch ?? Shims.getDefaultFetch();
     this.#encoder = Opts.FallbackEncoder;
 
+    const customHeadersEnv = readEnv('OPENAI_CUSTOM_HEADERS');
+    if (customHeadersEnv) {
+      const parsed: Record<string, string> = {};
+      for (const line of customHeadersEnv.split('\n')) {
+        const colon = line.indexOf(':');
+        if (colon >= 0) {
+          parsed[line.substring(0, colon).trim()] = line.substring(colon + 1).trim();
+        }
+      }
+      options.defaultHeaders = buildHeaders([parsed, options.defaultHeaders]);
+    }
+
     this._options = options;
 
-    this.apiKey = typeof apiKey === 'string' ? apiKey : 'Missing Key';
+    if (workloadIdentity) {
+      this._workloadIdentityAuth = new WorkloadIdentityAuth(workloadIdentity, this.fetch);
+    }
+
+    this.apiKey = typeof apiKey === 'string' ? apiKey : null;
+    this.adminAPIKey = adminAPIKey;
     this.organization = organization;
     this.project = project;
     this.webhookSecret = webhookSecret;
@@ -439,7 +495,9 @@ export class OpenAI {
       logLevel: this.logLevel,
       fetch: this.fetch,
       fetchOptions: this.fetchOptions,
-      apiKey: this.apiKey,
+      apiKey: this._options.apiKey,
+      adminAPIKey: this.adminAPIKey,
+      workloadIdentity: this._options.workloadIdentity,
       organization: this.organization,
       project: this.project,
       webhookSecret: this.webhookSecret,
@@ -459,16 +517,61 @@ export class OpenAI {
     return this._options.defaultQuery;
   }
 
-  protected validateHeaders({ values, nulls }: NullableHeaders) {
-    return;
+  protected validateHeaders(
+    { values, nulls }: NullableHeaders,
+    schemes: { bearerAuth?: boolean; adminAPIKeyAuth?: boolean } = {
+      bearerAuth: true,
+      adminAPIKeyAuth: true,
+    },
+  ) {
+    if (values.get('authorization') || values.get('api-key')) {
+      return;
+    }
+    if (nulls.has('authorization') || nulls.has('api-key')) {
+      return;
+    }
+
+    if (this._workloadIdentityAuth && schemes.bearerAuth) {
+      return;
+    }
+
+    throw new Error(
+      'Could not resolve authentication method. Expected either apiKey or adminAPIKey to be set. Or for one of the "Authorization" or "api-key" headers to be explicitly omitted',
+    );
+  }
+
+  protected async authHeaders(
+    opts: FinalRequestOptions,
+    schemes: { bearerAuth?: boolean; adminAPIKeyAuth?: boolean } = {
+      bearerAuth: true,
+      adminAPIKeyAuth: true,
+    },
+  ): Promise<NullableHeaders | undefined> {
+    return buildHeaders([
+      schemes.bearerAuth ? await this.bearerAuth(opts) : null,
+      schemes.adminAPIKeyAuth ? await this.adminAPIKeyAuth(opts) : null,
+    ]);
   }
 
-  protected async authHeaders(opts: FinalRequestOptions): Promise<NullableHeaders | undefined> {
+  protected async bearerAuth(opts: FinalRequestOptions): Promise<NullableHeaders | undefined> {
+    if (this._workloadIdentityAuth) {
+      return buildHeaders([{ Authorization: `Bearer ${await this._workloadIdentityAuth.getToken()}` }]);
+    }
+    if (this.apiKey == null) {
+      return undefined;
+    }
     return buildHeaders([{ Authorization: `Bearer ${this.apiKey}` }]);
   }
 
-  protected stringifyQuery(query: Record<string, unknown>): string {
-    return qs.stringify(query, { arrayFormat: 'brackets' });
+  protected async adminAPIKeyAuth(opts: FinalRequestOptions): Promise<NullableHeaders | undefined> {
+    if (this.adminAPIKey == null) {
+      return undefined;
+    }
+    return buildHeaders([{ Authorization: `Bearer ${this.adminAPIKey}` }]);
+  }
+
+  protected stringifyQuery(query: object | Record<string, unknown>): string {
+    return stringifyQuery(query);
   }
 
   private getUserAgent(): string {
@@ -525,12 +628,13 @@ export class OpenAI {
       : new URL(baseURL + (baseURL.endsWith('/') && path.startsWith('/') ? path.slice(1) : path));
 
     const defaultQuery = this.defaultQuery();
-    if (!isEmptyObj(defaultQuery)) {
-      query = { ...defaultQuery, ...query };
+    const pathQuery = Object.fromEntries(url.searchParams);
+    if (!isEmptyObj(defaultQuery) || !isEmptyObj(pathQuery)) {
+      query = { ...pathQuery, ...defaultQuery, ...query };
     }
 
     if (typeof query === 'object' && query && !Array.isArray(query)) {
-      url.search = this.stringifyQuery(query as Record<string, unknown>);
+      url.search = this.stringifyQuery(query);
     }
 
     return url.toString();
@@ -540,7 +644,10 @@ export class OpenAI {
    * Used as a callback for mutating the given `FinalRequestOptions` object.
    */
   protected async prepareOptions(options: FinalRequestOptions): Promise<void> {
-    await this._callApiKey();
+    const security = options.__security ?? { bearerAuth: true };
+    if (security.bearerAuth) {
+      await this._callApiKey();
+    }
   }
 
   /**
@@ -632,8 +739,9 @@ export class OpenAI {
       throw new Errors.APIUserAbortError();
     }
 
+    const security = options.__security ?? { bearerAuth: true };
     const controller = new AbortController();
-    const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(castToError);
+    const response = await this.fetchWithAuth(url, req, timeout, controller, security).catch(castToError);
     const headersTime = Date.now();
 
     if (response instanceof globalThis.Error) {
@@ -675,10 +783,16 @@ export class OpenAI {
           message: response.message,
         }),
       );
+      if (response instanceof OAuthError || response instanceof SubjectTokenProviderError) {
+        throw response;
+      }
       if (isTimeout) {
         throw new Errors.APIConnectionTimeoutError();
       }
-      throw new Errors.APIConnectionError({ cause: response });
+      throw new Errors.APIConnectionError({
+        message: getConnectionErrorMessage(response),
+        cause: response,
+      });
     }
 
     const specialHeaders = [...response.headers.entries()]
@@ -690,6 +804,29 @@ export class OpenAI {
     } with status ${response.status} in ${headersTime - startTime}ms`;
 
     if (!response.ok) {
+      if (
+        response.status === 401 &&
+        this._workloadIdentityAuth &&
+        security.bearerAuth &&
+        !options.__metadata?.['hasStreamingBody'] &&
+        !options.__metadata?.['workloadIdentityTokenRefreshed']
+      ) {
+        await Shims.CancelReadableStream(response.body);
+        this._workloadIdentityAuth.invalidateToken();
+
+        return this.makeRequest(
+          {
+            ...options,
+            __metadata: {
+              ...options.__metadata,
+              workloadIdentityTokenRefreshed: true,
+            },
+          },
+          retriesRemaining,
+          retryOfRequestLogID ?? requestLogID,
+        );
+      }
+
       const shouldRetry = await this.shouldRetry(response);
       if (retriesRemaining && shouldRetry) {
         const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
@@ -778,6 +915,30 @@ export class OpenAI {
     return new Pagination.PagePromise<PageClass, Item>(this as any as OpenAI, request, Page);
   }
 
+  protected async fetchWithAuth(
+    url: RequestInfo,
+    init: RequestInit,
+    timeout: number,
+    controller: AbortController,
+    schemes: { bearerAuth?: boolean; adminAPIKeyAuth?: boolean } = {
+      bearerAuth: true,
+      adminAPIKeyAuth: true,
+    },
+  ): Promise<Response> {
+    if (this._workloadIdentityAuth && schemes.bearerAuth) {
+      const headers = init.headers as Headers;
+      const authHeader = headers.get('Authorization');
+      if (!authHeader || authHeader === `Bearer ${WORKLOAD_IDENTITY_API_KEY_PLACEHOLDER}`) {
+        const token = await this._workloadIdentityAuth.getToken();
+        headers.set('Authorization', `Bearer ${token}`);
+      }
+    }
+
+    const response = await this.fetchWithTimeout(url, init, timeout, controller);
+
+    return response;
+  }
+
   async fetchWithTimeout(
     url: RequestInfo,
     init: RequestInit | undefined,
@@ -865,9 +1026,9 @@ export class OpenAI {
       }
     }
 
-    // If the API asks us to wait a certain amount of time (and it's a reasonable amount),
-    // just do what it says, but otherwise calculate a default
-    if (!(timeoutMillis && 0 <= timeoutMillis && timeoutMillis < 60 * 1000)) {
+    // If the API asks us to wait a certain amount of time, just do what it
+    // says, but otherwise calculate a default
+    if (timeoutMillis === undefined) {
       const maxRetries = options.maxRetries ?? this.maxRetries;
       timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
     }
@@ -901,7 +1062,15 @@ export class OpenAI {
     const url = this.buildURL(path!, query as Record<string, unknown>, defaultBaseURL);
     if ('timeout' in options) validatePositiveInteger('timeout', options.timeout);
     options.timeout = options.timeout ?? this.timeout;
-    const { bodyHeaders, body } = this.buildBody({ options });
+    const { bodyHeaders, body, isStreamingBody } = this.buildBody({ options });
+
+    if (isStreamingBody) {
+      inputOptions.__metadata = {
+        ...inputOptions.__metadata,
+        hasStreamingBody: true,
+      };
+    }
+
     const reqHeaders = await this.buildHeaders({ options: inputOptions, method, bodyHeaders, retryCount });
 
     const req: FinalizedRequestInit = {
@@ -946,13 +1115,13 @@ export class OpenAI {
         'OpenAI-Organization': this.organization,
         'OpenAI-Project': this.project,
       },
-      await this.authHeaders(options),
+      await this.authHeaders(options, options.__security ?? { bearerAuth: true }),
       this._options.defaultHeaders,
       bodyHeaders,
       options.headers,
     ]);
 
-    this.validateHeaders(headers);
+    this.validateHeaders(headers, options.__security ?? { bearerAuth: true });
 
     return headers.values;
   }
@@ -966,11 +1135,26 @@ export class OpenAI {
   private buildBody({ options: { body, headers: rawHeaders } }: { options: FinalRequestOptions }): {
     bodyHeaders: HeadersLike;
     body: BodyInit | undefined;
+    isStreamingBody: boolean;
   } {
     if (!body) {
-      return { bodyHeaders: undefined, body: undefined };
+      return { bodyHeaders: undefined, body: undefined, isStreamingBody: false };
     }
     const headers = buildHeaders([rawHeaders]);
+
+    const isReadableStream =
+      typeof (globalThis as any).ReadableStream !== 'undefined' &&
+      body instanceof (globalThis as any).ReadableStream;
+
+    const isRetryableBody =
+      !isReadableStream &&
+      (typeof body === 'string' ||
+        body instanceof ArrayBuffer ||
+        ArrayBuffer.isView(body) ||
+        (typeof (globalThis as any).Blob !== 'undefined' && body instanceof (globalThis as any).Blob) ||
+        body instanceof URLSearchParams ||
+        body instanceof FormData);
+
     if (
       // Pass raw type verbatim
       ArrayBuffer.isView(body) ||
@@ -986,17 +1170,30 @@ export class OpenAI {
       // `URLSearchParams` -> `application/x-www-form-urlencoded`
       body instanceof URLSearchParams ||
       // Send chunked stream (each chunk has own `length`)
-      ((globalThis as any).ReadableStream && body instanceof (globalThis as any).ReadableStream)
+      isReadableStream
     ) {
-      return { bodyHeaders: undefined, body: body as BodyInit };
+      return { bodyHeaders: undefined, body: body as BodyInit, isStreamingBody: !isRetryableBody };
     } else if (
       typeof body === 'object' &&
       (Symbol.asyncIterator in body ||
         (Symbol.iterator in body && 'next' in body && typeof body.next === 'function'))
     ) {
-      return { bodyHeaders: undefined, body: Shims.ReadableStreamFrom(body as AsyncIterable<Uint8Array>) };
+      return {
+        bodyHeaders: undefined,
+        body: Shims.ReadableStreamFrom(body as AsyncIterable<Uint8Array>),
+        isStreamingBody: true,
+      };
+    } else if (
+      typeof body === 'object' &&
+      headers.values.get('content-type') === 'application/x-www-form-urlencoded'
+    ) {
+      return {
+        bodyHeaders: { 'content-type': 'application/x-www-form-urlencoded' },
+        body: this.stringifyQuery(body),
+        isStreamingBody: false,
+      };
     } else {
-      return this.#encoder({ body, headers });
+      return { ...this.#encoder({ body, headers }), isStreamingBody: false };
     }
   }
 
@@ -1020,24 +1217,55 @@ export class OpenAI {
 
   static toFile = Uploads.toFile;
 
+  /**
+   * Given a prompt, the model will return one or more predicted completions, and can also return the probabilities of alternative tokens at each position.
+   */
   completions: API.Completions = new API.Completions(this);
   chat: API.Chat = new API.Chat(this);
+  /**
+   * Get a vector representation of a given input that can be easily consumed by machine learning models and algorithms.
+   */
   embeddings: API.Embeddings = new API.Embeddings(this);
+  /**
+   * Files are used to upload documents that can be used with features like Assistants and Fine-tuning.
+   */
   files: API.Files = new API.Files(this);
+  /**
+   * Given a prompt and/or an input image, the model will generate a new image.
+   */
   images: API.Images = new API.Images(this);
   audio: API.Audio = new API.Audio(this);
+  /**
+   * Given text and/or image inputs, classifies if those inputs are potentially harmful.
+   */
   moderations: API.Moderations = new API.Moderations(this);
+  /**
+   * List and describe the various models available in the API.
+   */
   models: API.Models = new API.Models(this);
   fineTuning: API.FineTuning = new API.FineTuning(this);
   graders: API.Graders = new API.Graders(this);
   vectorStores: API.VectorStores = new API.VectorStores(this);
   webhooks: API.Webhooks = new API.Webhooks(this);
   beta: API.Beta = new API.Beta(this);
+  /**
+   * Create large batches of API requests to run asynchronously.
+   */
   batches: API.Batches = new API.Batches(this);
+  /**
+   * Use Uploads to upload large files in multiple parts.
+   */
   uploads: API.Uploads = new API.Uploads(this);
+  admin: API.Admin = new API.Admin(this);
   responses: API.Responses = new API.Responses(this);
   realtime: API.Realtime = new API.Realtime(this);
+  /**
+   * Manage conversations and conversation items.
+   */
   conversations: API.Conversations = new API.Conversations(this);
+  /**
+   * Manage and run evals in the OpenAI platform.
+   */
   evals: API.Evals = new API.Evals(this);
   containers: API.Containers = new API.Containers(this);
   skills: API.Skills = new API.Skills(this);
@@ -1059,6 +1287,7 @@ OpenAI.Webhooks = Webhooks;
 OpenAI.Beta = Beta;
 OpenAI.Batches = Batches;
 OpenAI.Uploads = UploadsAPIUploads;
+OpenAI.Admin = Admin;
 OpenAI.Responses = Responses;
 OpenAI.Realtime = Realtime;
 OpenAI.Conversations = Conversations;
@@ -1067,6 +1296,39 @@ OpenAI.Containers = Containers;
 OpenAI.Skills = Skills;
 OpenAI.Videos = Videos;
 
+function getConnectionErrorMessage(error: Error): string | undefined {
+  if (isUndiciDispatcherVersionMismatchError(error)) {
+    return `Connection error. This may be caused by passing an undici dispatcher, such as ProxyAgent, that is incompatible with the fetch implementation. If you are using undici's ProxyAgent, pass the fetch implementation from the same undici package: import { fetch, ProxyAgent } from 'undici'; new OpenAI({ fetch, fetchOptions: { dispatcher: new ProxyAgent(...) } });`;
+  }
+
+  return undefined;
+}
+
+type ErrorLikeWithCause = {
+  code?: unknown;
+  message?: unknown;
+  cause?: unknown;
+};
+
+function isUndiciDispatcherVersionMismatchError(error: unknown): boolean {
+  let current = error;
+
+  for (let i = 0; i < 8 && current && typeof current === 'object'; i++) {
+    const err = current as ErrorLikeWithCause;
+    if (
+      err.code === 'UND_ERR_INVALID_ARG' &&
+      typeof err.message === 'string' &&
+      err.message.includes('invalid onRequestStart method')
+    ) {
+      return true;
+    }
+
+    current = err.cause;
+  }
+
+  return false;
+}
+
 export declare namespace OpenAI {
   export type RequestOptions = Opts.RequestOptions;
 
@@ -1082,6 +1344,12 @@ export declare namespace OpenAI {
     type ConversationCursorPageResponse as ConversationCursorPageResponse,
   };
 
+  export import NextCursorPage = Pagination.NextCursorPage;
+  export {
+    type NextCursorPageParams as NextCursorPageParams,
+    type NextCursorPageResponse as NextCursorPageResponse,
+  };
+
   export {
     Completions as Completions,
     type Completion as Completion,
@@ -1244,6 +1512,8 @@ export declare namespace OpenAI {
     type UploadCompleteParams as UploadCompleteParams,
   };
 
+  export { Admin as Admin };
+
   export { Responses as Responses };
 
   export { Realtime as Realtime };
@@ -1288,16 +1558,22 @@ export declare namespace OpenAI {
 
   export {
     Videos as Videos,
+    type ImageInputReferenceParam as ImageInputReferenceParam,
     type Video as Video,
     type VideoCreateError as VideoCreateError,
     type VideoModel as VideoModel,
     type VideoSeconds as VideoSeconds,
     type VideoSize as VideoSize,
     type VideoDeleteResponse as VideoDeleteResponse,
+    type VideoCreateCharacterResponse as VideoCreateCharacterResponse,
+    type VideoGetCharacterResponse as VideoGetCharacterResponse,
     type VideosPage as VideosPage,
     type VideoCreateParams as VideoCreateParams,
     type VideoListParams as VideoListParams,
+    type VideoCreateCharacterParams as VideoCreateCharacterParams,
     type VideoDownloadContentParams as VideoDownloadContentParams,
+    type VideoEditParams as VideoEditParams,
+    type VideoExtendParams as VideoExtendParams,
     type VideoRemixParams as VideoRemixParams,
   };
 
@@ -1310,6 +1586,7 @@ export declare namespace OpenAI {
   export type FunctionDefinition = API.FunctionDefinition;
   export type FunctionParameters = API.FunctionParameters;
   export type Metadata = API.Metadata;
+  export type OAuthErrorCode = API.OAuthErrorCode;
   export type Reasoning = API.Reasoning;
   export type ReasoningEffort = API.ReasoningEffort;
   export type ResponseFormatJSONObject = API.ResponseFormatJSONObject;