@nocobase/plugin-ai 2.2.0-alpha.1 → 2.2.0-alpha.10

package/dist/node_modules/openai/client.js

@@ -11,10 +11,12 @@ const errors_1 = require("./internal/errors.js");
 const detect_platform_1 = require("./internal/detect-platform.js");
 const Shims = tslib_1.__importStar(require("./internal/shims.js"));
 const Opts = tslib_1.__importStar(require("./internal/request-options.js"));
-const qs = tslib_1.__importStar(require("./internal/qs/index.js"));
+const query_1 = require("./internal/utils/query.js");
 const version_1 = require("./version.js");
 const Errors = tslib_1.__importStar(require("./core/error.js"));
 const Pagination = tslib_1.__importStar(require("./core/pagination.js"));
+const workload_identity_auth_1 = require("./auth/workload-identity-auth.js");
+const error_1 = require("./core/error.js");
 const Uploads = tslib_1.__importStar(require("./core/uploads.js"));
 const API = tslib_1.__importStar(require("./resources/index.js"));
 const api_promise_1 = require("./core/api-promise.js");
@@ -26,6 +28,7 @@ const images_1 = require("./resources/images.js");
 const models_1 = require("./resources/models.js");
 const moderations_1 = require("./resources/moderations.js");
 const videos_1 = require("./resources/videos.js");
+const admin_1 = require("./resources/admin/admin.js");
 const audio_1 = require("./resources/audio/audio.js");
 const beta_1 = require("./resources/beta/beta.js");
 const chat_1 = require("./resources/chat/chat.js");
@@ -45,6 +48,7 @@ const headers_1 = require("./internal/headers.js");
 const env_1 = require("./internal/utils/env.js");
 const log_1 = require("./internal/utils/log.js");
 const values_2 = require("./internal/utils/values.js");
+const WORKLOAD_IDENTITY_API_KEY_PLACEHOLDER = 'workload-identity-auth';
 /**
  * API Client for interfacing with the OpenAI API.
  */
@@ -52,7 +56,8 @@ class OpenAI {
     /**
      * 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]
@@ -65,42 +70,78 @@ class OpenAI {
      * @param {Record<string, string | undefined>} opts.defaultQuery - Default query parameters to include with every request to the API.
      * @param {boolean} [opts.dangerouslyAllowBrowser=false] - By default, client-side use of this library is not allowed, as it risks exposing your secret API credentials to attackers.
      */
-    constructor({ baseURL = (0, env_1.readEnv)('OPENAI_BASE_URL'), apiKey = (0, env_1.readEnv)('OPENAI_API_KEY'), organization = (0, env_1.readEnv)('OPENAI_ORG_ID') ?? null, project = (0, env_1.readEnv)('OPENAI_PROJECT_ID') ?? null, webhookSecret = (0, env_1.readEnv)('OPENAI_WEBHOOK_SECRET') ?? null, ...opts } = {}) {
+    constructor({ baseURL = (0, env_1.readEnv)('OPENAI_BASE_URL'), apiKey = (0, env_1.readEnv)('OPENAI_API_KEY') ?? null, adminAPIKey = (0, env_1.readEnv)('OPENAI_ADMIN_KEY') ?? null, organization = (0, env_1.readEnv)('OPENAI_ORG_ID') ?? null, project = (0, env_1.readEnv)('OPENAI_PROJECT_ID') ?? null, webhookSecret = (0, env_1.readEnv)('OPENAI_WEBHOOK_SECRET') ?? null, workloadIdentity, ...opts } = {}) {
         _OpenAI_instances.add(this);
         _OpenAI_encoder.set(this, void 0);
+        /**
+         * Given a prompt, the model will return one or more predicted completions, and can also return the probabilities of alternative tokens at each position.
+         */
         this.completions = new API.Completions(this);
         this.chat = new API.Chat(this);
+        /**
+         * Get a vector representation of a given input that can be easily consumed by machine learning models and algorithms.
+         */
         this.embeddings = new API.Embeddings(this);
+        /**
+         * Files are used to upload documents that can be used with features like Assistants and Fine-tuning.
+         */
         this.files = new API.Files(this);
+        /**
+         * Given a prompt and/or an input image, the model will generate a new image.
+         */
         this.images = new API.Images(this);
         this.audio = new API.Audio(this);
+        /**
+         * Given text and/or image inputs, classifies if those inputs are potentially harmful.
+         */
         this.moderations = new API.Moderations(this);
+        /**
+         * List and describe the various models available in the API.
+         */
         this.models = new API.Models(this);
         this.fineTuning = new API.FineTuning(this);
         this.graders = new API.Graders(this);
         this.vectorStores = new API.VectorStores(this);
         this.webhooks = new API.Webhooks(this);
         this.beta = new API.Beta(this);
+        /**
+         * Create large batches of API requests to run asynchronously.
+         */
         this.batches = new API.Batches(this);
+        /**
+         * Use Uploads to upload large files in multiple parts.
+         */
         this.uploads = new API.Uploads(this);
+        this.admin = new API.Admin(this);
         this.responses = new API.Responses(this);
         this.realtime = new API.Realtime(this);
+        /**
+         * Manage conversations and conversation items.
+         */
         this.conversations = new API.Conversations(this);
+        /**
+         * Manage and run evals in the OpenAI platform.
+         */
         this.evals = new API.Evals(this);
         this.containers = new API.Containers(this);
         this.skills = new API.Skills(this);
         this.videos = new API.Videos(this);
-        if (apiKey === undefined) {
-            throw new Errors.OpenAIError('Missing credentials. Please pass an `apiKey`, or set the `OPENAI_API_KEY` environment variable.');
-        }
         const options = {
             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 && (0, detect_platform_2.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");
         }
@@ -118,8 +159,23 @@ class OpenAI {
         this.maxRetries = options.maxRetries ?? 2;
         this.fetch = options.fetch ?? Shims.getDefaultFetch();
         tslib_1.__classPrivateFieldSet(this, _OpenAI_encoder, Opts.FallbackEncoder, "f");
+        const customHeadersEnv = (0, env_1.readEnv)('OPENAI_CUSTOM_HEADERS');
+        if (customHeadersEnv) {
+            const parsed = {};
+            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 = (0, headers_1.buildHeaders)([parsed, options.defaultHeaders]);
+        }
         this._options = options;
-        this.apiKey = typeof apiKey === 'string' ? apiKey : 'Missing Key';
+        if (workloadIdentity) {
+            this._workloadIdentityAuth = new workload_identity_auth_1.WorkloadIdentityAuth(workloadIdentity, this.fetch);
+        }
+        this.apiKey = typeof apiKey === 'string' ? apiKey : null;
+        this.adminAPIKey = adminAPIKey;
         this.organization = organization;
         this.project = project;
         this.webhookSecret = webhookSecret;
@@ -137,7 +193,9 @@ 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,
@@ -148,14 +206,47 @@ class OpenAI {
     defaultQuery() {
         return this._options.defaultQuery;
     }
-    validateHeaders({ values, nulls }) {
-        return;
+    validateHeaders({ values, nulls }, schemes = {
+        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');
+    }
+    async authHeaders(opts, schemes = {
+        bearerAuth: true,
+        adminAPIKeyAuth: true,
+    }) {
+        return (0, headers_1.buildHeaders)([
+            schemes.bearerAuth ? await this.bearerAuth(opts) : null,
+            schemes.adminAPIKeyAuth ? await this.adminAPIKeyAuth(opts) : null,
+        ]);
     }
-    async authHeaders(opts) {
+    async bearerAuth(opts) {
+        if (this._workloadIdentityAuth) {
+            return (0, headers_1.buildHeaders)([{ Authorization: `Bearer ${await this._workloadIdentityAuth.getToken()}` }]);
+        }
+        if (this.apiKey == null) {
+            return undefined;
+        }
         return (0, headers_1.buildHeaders)([{ Authorization: `Bearer ${this.apiKey}` }]);
     }
+    async adminAPIKeyAuth(opts) {
+        if (this.adminAPIKey == null) {
+            return undefined;
+        }
+        return (0, headers_1.buildHeaders)([{ Authorization: `Bearer ${this.adminAPIKey}` }]);
+    }
     stringifyQuery(query) {
-        return qs.stringify(query, { arrayFormat: 'brackets' });
+        return (0, query_1.stringifyQuery)(query);
     }
     getUserAgent() {
         return `${this.constructor.name}/JS ${version_1.VERSION}`;
@@ -193,8 +284,9 @@ class OpenAI {
             new URL(path)
             : new URL(baseURL + (baseURL.endsWith('/') && path.startsWith('/') ? path.slice(1) : path));
         const defaultQuery = this.defaultQuery();
-        if (!(0, values_2.isEmptyObj)(defaultQuery)) {
-            query = { ...defaultQuery, ...query };
+        const pathQuery = Object.fromEntries(url.searchParams);
+        if (!(0, values_2.isEmptyObj)(defaultQuery) || !(0, values_2.isEmptyObj)(pathQuery)) {
+            query = { ...pathQuery, ...defaultQuery, ...query };
         }
         if (typeof query === 'object' && query && !Array.isArray(query)) {
             url.search = this.stringifyQuery(query);
@@ -205,7 +297,10 @@ class OpenAI {
      * Used as a callback for mutating the given `FinalRequestOptions` object.
      */
     async prepareOptions(options) {
-        await this._callApiKey();
+        const security = options.__security ?? { bearerAuth: true };
+        if (security.bearerAuth) {
+            await this._callApiKey();
+        }
     }
     /**
      * Used as a callback for mutating the given `RequestInit` object.
@@ -262,8 +357,9 @@ class OpenAI {
         if (options.signal?.aborted) {
             throw new Errors.APIUserAbortError();
         }
+        const security = options.__security ?? { bearerAuth: true };
         const controller = new AbortController();
-        const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(errors_1.castToError);
+        const response = await this.fetchWithAuth(url, req, timeout, controller, security).catch(errors_1.castToError);
         const headersTime = Date.now();
         if (response instanceof globalThis.Error) {
             const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
@@ -293,10 +389,16 @@ class OpenAI {
                 durationMs: headersTime - startTime,
                 message: response.message,
             }));
+            if (response instanceof error_1.OAuthError || response instanceof error_1.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()]
             .filter(([name]) => name === 'x-request-id')
@@ -304,6 +406,21 @@ class OpenAI {
             .join('');
         const responseInfo = `[${requestLogID}${retryLogStr}${specialHeaders}] ${req.method} ${url} ${response.ok ? 'succeeded' : 'failed'} 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`;
@@ -354,6 +471,21 @@ class OpenAI {
         const request = this.makeRequest(options, null, undefined);
         return new Pagination.PagePromise(this, request, Page);
     }
+    async fetchWithAuth(url, init, timeout, controller, schemes = {
+        bearerAuth: true,
+        adminAPIKeyAuth: true,
+    }) {
+        if (this._workloadIdentityAuth && schemes.bearerAuth) {
+            const headers = init.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, init, ms, controller) {
         const { signal, method, ...options } = init || {};
         const abort = this._makeAbort(controller);
@@ -424,9 +556,9 @@ class OpenAI {
                 timeoutMillis = Date.parse(retryAfterHeader) - Date.now();
             }
         }
-        // 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);
         }
@@ -450,7 +582,13 @@ class OpenAI {
         if ('timeout' in options)
             (0, values_1.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 = {
             method,
@@ -482,12 +620,12 @@ 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;
     }
     _makeAbort(controller) {
@@ -497,9 +635,18 @@ class OpenAI {
     }
     buildBody({ options: { body, headers: rawHeaders } }) {
         if (!body) {
-            return { bodyHeaders: undefined, body: undefined };
+            return { bodyHeaders: undefined, body: undefined, isStreamingBody: false };
         }
         const headers = (0, headers_1.buildHeaders)([rawHeaders]);
+        const isReadableStream = typeof globalThis.ReadableStream !== 'undefined' &&
+            body instanceof globalThis.ReadableStream;
+        const isRetryableBody = !isReadableStream &&
+            (typeof body === 'string' ||
+                body instanceof ArrayBuffer ||
+                ArrayBuffer.isView(body) ||
+                (typeof globalThis.Blob !== 'undefined' && body instanceof globalThis.Blob) ||
+                body instanceof URLSearchParams ||
+                body instanceof FormData);
         if (
         // Pass raw type verbatim
         ArrayBuffer.isView(body) ||
@@ -515,16 +662,28 @@ class OpenAI {
             // `URLSearchParams` -> `application/x-www-form-urlencoded`
             body instanceof URLSearchParams ||
             // Send chunked stream (each chunk has own `length`)
-            (globalThis.ReadableStream && body instanceof globalThis.ReadableStream)) {
-            return { bodyHeaders: undefined, body: body };
+            isReadableStream) {
+            return { bodyHeaders: undefined, body: body, 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) };
+            return {
+                bodyHeaders: undefined,
+                body: Shims.ReadableStreamFrom(body),
+                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 tslib_1.__classPrivateFieldGet(this, _OpenAI_encoder, "f").call(this, { body, headers });
+            return { ...tslib_1.__classPrivateFieldGet(this, _OpenAI_encoder, "f").call(this, { body, headers }), isStreamingBody: false };
         }
     }
 }
@@ -564,6 +723,7 @@ OpenAI.Webhooks = webhooks_1.Webhooks;
 OpenAI.Beta = beta_1.Beta;
 OpenAI.Batches = batches_1.Batches;
 OpenAI.Uploads = uploads_1.Uploads;
+OpenAI.Admin = admin_1.Admin;
 OpenAI.Responses = responses_1.Responses;
 OpenAI.Realtime = realtime_1.Realtime;
 OpenAI.Conversations = conversations_1.Conversations;
@@ -571,4 +731,23 @@ OpenAI.Evals = evals_1.Evals;
 OpenAI.Containers = containers_1.Containers;
 OpenAI.Skills = skills_1.Skills;
 OpenAI.Videos = videos_1.Videos;
+function getConnectionErrorMessage(error) {
+    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;
+}
+function isUndiciDispatcherVersionMismatchError(error) {
+    let current = error;
+    for (let i = 0; i < 8 && current && typeof current === 'object'; i++) {
+        const err = current;
+        if (err.code === 'UND_ERR_INVALID_ARG' &&
+            typeof err.message === 'string' &&
+            err.message.includes('invalid onRequestStart method')) {
+            return true;
+        }
+        current = err.cause;
+    }
+    return false;
+}
 //# sourceMappingURL=client.js.map

package/dist/node_modules/openai/core/EventEmitter.d.mts

@@ -0,0 +1,56 @@
+type EventListener<Events, EventType extends keyof Events> = Events[EventType];
+export type EventParameters<Events, EventType extends keyof Events> = {
+    [Event in EventType]: EventListener<Events, EventType> extends (...args: infer P) => any ? P : never;
+}[EventType];
+export declare class EventEmitter<EventTypes extends Record<string, (...args: any) => any>> {
+    #private;
+    /**
+     * Adds the listener function to the end of the listeners array for the event.
+     * No checks are made to see if the listener has already been added. Multiple calls passing
+     * the same combination of event and listener will result in the listener being added, and
+     * called, multiple times.
+     * @returns this, so that calls can be chained
+     */
+    on<Event extends keyof EventTypes>(event: Event, listener: EventListener<EventTypes, Event>): this;
+    /**
+     * Removes the specified listener from the listener array for the event.
+     * off() will remove, at most, one instance of a listener from the listener array. If any single
+     * listener has been added multiple times to the listener array for the specified event, then
+     * off() must be called multiple times to remove each instance.
+     * @returns this, so that calls can be chained
+     */
+    off<Event extends keyof EventTypes>(event: Event, listener: EventListener<EventTypes, Event>): this;
+    /**
+     * Adds a one-time listener function for the event. The next time the event is triggered,
+     * this listener is removed and then invoked.
+     * @returns this, so that calls can be chained
+     */
+    once<Event extends keyof EventTypes>(event: Event, listener: EventListener<EventTypes, Event>): this;
+    /**
+     * This is similar to `.once()`, but returns a Promise that resolves the next time
+     * the event is triggered, instead of calling a listener callback.
+     * @returns a Promise that resolves the next time given event is triggered,
+     * or rejects if an error is emitted.  (If you request the 'error' event,
+     * returns a promise that resolves with the error).
+     *
+     * Example:
+     *
+     *   const message = await stream.emitted('message') // rejects if the stream errors
+     */
+    emitted<Event extends keyof EventTypes>(event: Event): Promise<EventParameters<EventTypes, Event> extends [infer Param] ? Param : EventParameters<EventTypes, Event> extends [] ? void : EventParameters<EventTypes, Event>>;
+    protected _emit<Event extends keyof EventTypes>(this: EventEmitter<EventTypes>, event: Event, ...args: EventParameters<EventTypes, Event>): void;
+    protected _hasListener(event: keyof EventTypes): boolean;
+}
+/**
+ * An EventEmitter variant that exposes `_emit()` publicly.
+ *
+ * The base {@link EventEmitter} keeps `_emit` protected so that consumers
+ * can only listen, not dispatch. When you need a separate emitter instance
+ * that your own code can emit on, without exposing emit on the
+ * consumer-facing emitter, use this class.
+ */
+export declare class InternalEventEmitter<EventTypes extends Record<string, (...args: any) => any>> extends EventEmitter<EventTypes> {
+    _emit<Event extends keyof EventTypes>(event: Event, ...args: EventParameters<EventTypes, Event>): void;
+}
+export {};
+//# sourceMappingURL=EventEmitter.d.mts.map

package/dist/node_modules/openai/core/EventEmitter.d.ts

@@ -0,0 +1,56 @@
+type EventListener<Events, EventType extends keyof Events> = Events[EventType];
+export type EventParameters<Events, EventType extends keyof Events> = {
+    [Event in EventType]: EventListener<Events, EventType> extends (...args: infer P) => any ? P : never;
+}[EventType];
+export declare class EventEmitter<EventTypes extends Record<string, (...args: any) => any>> {
+    #private;
+    /**
+     * Adds the listener function to the end of the listeners array for the event.
+     * No checks are made to see if the listener has already been added. Multiple calls passing
+     * the same combination of event and listener will result in the listener being added, and
+     * called, multiple times.
+     * @returns this, so that calls can be chained
+     */
+    on<Event extends keyof EventTypes>(event: Event, listener: EventListener<EventTypes, Event>): this;
+    /**
+     * Removes the specified listener from the listener array for the event.
+     * off() will remove, at most, one instance of a listener from the listener array. If any single
+     * listener has been added multiple times to the listener array for the specified event, then
+     * off() must be called multiple times to remove each instance.
+     * @returns this, so that calls can be chained
+     */
+    off<Event extends keyof EventTypes>(event: Event, listener: EventListener<EventTypes, Event>): this;
+    /**
+     * Adds a one-time listener function for the event. The next time the event is triggered,
+     * this listener is removed and then invoked.
+     * @returns this, so that calls can be chained
+     */
+    once<Event extends keyof EventTypes>(event: Event, listener: EventListener<EventTypes, Event>): this;
+    /**
+     * This is similar to `.once()`, but returns a Promise that resolves the next time
+     * the event is triggered, instead of calling a listener callback.
+     * @returns a Promise that resolves the next time given event is triggered,
+     * or rejects if an error is emitted.  (If you request the 'error' event,
+     * returns a promise that resolves with the error).
+     *
+     * Example:
+     *
+     *   const message = await stream.emitted('message') // rejects if the stream errors
+     */
+    emitted<Event extends keyof EventTypes>(event: Event): Promise<EventParameters<EventTypes, Event> extends [infer Param] ? Param : EventParameters<EventTypes, Event> extends [] ? void : EventParameters<EventTypes, Event>>;
+    protected _emit<Event extends keyof EventTypes>(this: EventEmitter<EventTypes>, event: Event, ...args: EventParameters<EventTypes, Event>): void;
+    protected _hasListener(event: keyof EventTypes): boolean;
+}
+/**
+ * An EventEmitter variant that exposes `_emit()` publicly.
+ *
+ * The base {@link EventEmitter} keeps `_emit` protected so that consumers
+ * can only listen, not dispatch. When you need a separate emitter instance
+ * that your own code can emit on, without exposing emit on the
+ * consumer-facing emitter, use this class.
+ */
+export declare class InternalEventEmitter<EventTypes extends Record<string, (...args: any) => any>> extends EventEmitter<EventTypes> {
+    _emit<Event extends keyof EventTypes>(event: Event, ...args: EventParameters<EventTypes, Event>): void;
+}
+export {};
+//# sourceMappingURL=EventEmitter.d.ts.map

package/dist/node_modules/openai/core/EventEmitter.js

@@ -0,0 +1,93 @@
+"use strict";
+var _EventEmitter_listeners;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalEventEmitter = exports.EventEmitter = void 0;
+const tslib_1 = require("../internal/tslib.js");
+class EventEmitter {
+    constructor() {
+        _EventEmitter_listeners.set(this, {});
+    }
+    /**
+     * Adds the listener function to the end of the listeners array for the event.
+     * No checks are made to see if the listener has already been added. Multiple calls passing
+     * the same combination of event and listener will result in the listener being added, and
+     * called, multiple times.
+     * @returns this, so that calls can be chained
+     */
+    on(event, listener) {
+        const listeners = tslib_1.__classPrivateFieldGet(this, _EventEmitter_listeners, "f")[event] || (tslib_1.__classPrivateFieldGet(this, _EventEmitter_listeners, "f")[event] = []);
+        listeners.push({ listener });
+        return this;
+    }
+    /**
+     * Removes the specified listener from the listener array for the event.
+     * off() will remove, at most, one instance of a listener from the listener array. If any single
+     * listener has been added multiple times to the listener array for the specified event, then
+     * off() must be called multiple times to remove each instance.
+     * @returns this, so that calls can be chained
+     */
+    off(event, listener) {
+        const listeners = tslib_1.__classPrivateFieldGet(this, _EventEmitter_listeners, "f")[event];
+        if (!listeners)
+            return this;
+        const index = listeners.findIndex((l) => l.listener === listener);
+        if (index >= 0)
+            listeners.splice(index, 1);
+        return this;
+    }
+    /**
+     * Adds a one-time listener function for the event. The next time the event is triggered,
+     * this listener is removed and then invoked.
+     * @returns this, so that calls can be chained
+     */
+    once(event, listener) {
+        const listeners = tslib_1.__classPrivateFieldGet(this, _EventEmitter_listeners, "f")[event] || (tslib_1.__classPrivateFieldGet(this, _EventEmitter_listeners, "f")[event] = []);
+        listeners.push({ listener, once: true });
+        return this;
+    }
+    /**
+     * This is similar to `.once()`, but returns a Promise that resolves the next time
+     * the event is triggered, instead of calling a listener callback.
+     * @returns a Promise that resolves the next time given event is triggered,
+     * or rejects if an error is emitted.  (If you request the 'error' event,
+     * returns a promise that resolves with the error).
+     *
+     * Example:
+     *
+     *   const message = await stream.emitted('message') // rejects if the stream errors
+     */
+    emitted(event) {
+        return new Promise((resolve, reject) => {
+            // TODO: handle errors
+            this.once(event, resolve);
+        });
+    }
+    _emit(event, ...args) {
+        const listeners = tslib_1.__classPrivateFieldGet(this, _EventEmitter_listeners, "f")[event];
+        if (listeners) {
+            tslib_1.__classPrivateFieldGet(this, _EventEmitter_listeners, "f")[event] = listeners.filter((l) => !l.once);
+            listeners.forEach(({ listener }) => listener(...args));
+        }
+    }
+    _hasListener(event) {
+        const listeners = tslib_1.__classPrivateFieldGet(this, _EventEmitter_listeners, "f")[event];
+        return listeners && listeners.length > 0;
+    }
+}
+exports.EventEmitter = EventEmitter;
+_EventEmitter_listeners = new WeakMap();
+/**
+ * An EventEmitter variant that exposes `_emit()` publicly.
+ *
+ * The base {@link EventEmitter} keeps `_emit` protected so that consumers
+ * can only listen, not dispatch. When you need a separate emitter instance
+ * that your own code can emit on, without exposing emit on the
+ * consumer-facing emitter, use this class.
+ */
+class InternalEventEmitter extends EventEmitter {
+    _emit(event, ...args) {
+        super._emit(event, ...args);
+    }
+}
+exports.InternalEventEmitter = InternalEventEmitter;
+//# sourceMappingURL=EventEmitter.js.map

package/dist/node_modules/openai/core/error.d.mts

@@ -1,3 +1,4 @@
+import type { OAuthErrorCode } from "../resources/shared.mjs";
 export declare class OpenAIError extends Error {
 }
 export declare class APIError<TStatus extends number | undefined = number | undefined, THeaders extends Headers | undefined = Headers | undefined, TError extends Object | undefined = Object | undefined> extends OpenAIError {
@@ -56,4 +57,18 @@ export declare class ContentFilterFinishReasonError extends OpenAIError {
 export declare class InvalidWebhookSignatureError extends Error {
     constructor(message: string);
 }
+/**
+ * Error thrown by the API server during OAuth token exchange.
+ * Can have status codes 400, 401, or 403.
+ * Other status codes from OAuth endpoints are raised as normal APIError types.
+ */
+export declare class OAuthError extends APIError<400 | 401 | 403, Headers> {
+    readonly error_code: OAuthErrorCode | undefined;
+    constructor(status: 400 | 401 | 403, error: Object | undefined, headers: Headers);
+}
+export declare class SubjectTokenProviderError extends OpenAIError {
+    readonly provider: string;
+    readonly cause: Error | undefined;
+    constructor(message: string, provider: string, cause?: Error);
+}
 //# sourceMappingURL=error.d.mts.map