@warlock.js/core 4.4.0 → 4.6.0

package/esm/node_modules/openai/client.mjs

@@ -0,0 +1,638 @@
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "./internal/tslib.mjs";
+import { uuid4 } from "./internal/utils/uuid.mjs";
+import { castToError, isAbortError } from "./internal/errors.mjs";
+import { APIConnectionError, APIConnectionTimeoutError, APIError, APIUserAbortError, AuthenticationError, BadRequestError, ConflictError, InternalServerError, InvalidWebhookSignatureError, NotFoundError, OAuthError, OpenAIError, PermissionDeniedError, RateLimitError, SubjectTokenProviderError, UnprocessableEntityError } from "./core/error.mjs";
+import { isAbsoluteURL, isEmptyObj, safeJSON, validatePositiveInteger } from "./internal/utils/values.mjs";
+import { sleep } from "./internal/utils/sleep.mjs";
+import { VERSION } from "./version.mjs";
+import { getPlatformHeaders, isRunningInBrowser } from "./internal/detect-platform.mjs";
+import { CancelReadableStream, ReadableStreamFrom, getDefaultFetch } from "./internal/shims.mjs";
+import { FallbackEncoder } from "./internal/request-options.mjs";
+import { stringifyQuery } from "./internal/utils/query.mjs";
+import { formatRequestDetails, loggerFor, parseLogLevel } from "./internal/utils/log.mjs";
+import { APIPromise } from "./core/api-promise.mjs";
+import { PagePromise } from "./core/pagination.mjs";
+import { WorkloadIdentityAuth } from "./auth/workload-identity-auth.mjs";
+import { toFile } from "./internal/to-file.mjs";
+import { Chat } from "./resources/chat/chat.mjs";
+import { Admin } from "./resources/admin/admin.mjs";
+import { buildHeaders } from "./internal/headers.mjs";
+import { Audio } from "./resources/audio/audio.mjs";
+import { Batches } from "./resources/batches.mjs";
+import { readEnv } from "./internal/utils/env.mjs";
+import { Beta } from "./resources/beta/beta.mjs";
+import { Completions } from "./resources/completions.mjs";
+import { Containers } from "./resources/containers/containers.mjs";
+import { Conversations } from "./resources/conversations/conversations.mjs";
+import { Embeddings } from "./resources/embeddings.mjs";
+import { Evals } from "./resources/evals/evals.mjs";
+import { Files } from "./resources/files.mjs";
+import { FineTuning } from "./resources/fine-tuning/fine-tuning.mjs";
+import { Graders } from "./resources/graders/graders.mjs";
+import { Images } from "./resources/images.mjs";
+import { Models } from "./resources/models.mjs";
+import { Moderations } from "./resources/moderations.mjs";
+import { Realtime } from "./resources/realtime/realtime.mjs";
+import { Responses } from "./resources/responses/responses.mjs";
+import { Skills } from "./resources/skills/skills.mjs";
+import { Uploads } from "./resources/uploads/uploads.mjs";
+import { VectorStores } from "./resources/vector-stores/vector-stores.mjs";
+import { Videos } from "./resources/videos.mjs";
+import { Webhooks } from "./resources/webhooks/webhooks.mjs";
+import "./resources/index.mjs";
+
+//#region ../@warlock.js/node_modules/openai/client.mjs
+var _OpenAI_instances, _a, _OpenAI_encoder, _OpenAI_baseURLOverridden;
+const WORKLOAD_IDENTITY_API_KEY_PLACEHOLDER = "workload-identity-auth";
+/**
+* API Client for interfacing with the OpenAI API.
+*/
+var OpenAI = class {
+	/**
+	* API Client for interfacing with the OpenAI API.
+	*
+	* @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]
+	* @param {string} [opts.baseURL=process.env['OPENAI_BASE_URL'] ?? https://api.openai.com/v1] - Override the default base URL for the API.
+	* @param {number} [opts.timeout=10 minutes] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
+	* @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls.
+	* @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
+	* @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
+	* @param {HeadersLike} opts.defaultHeaders - Default headers to include with every request to the API.
+	* @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 = readEnv("OPENAI_BASE_URL"), 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 } = {}) {
+		_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 Completions(this);
+		this.chat = new Chat(this);
+		/**
+		* Get a vector representation of a given input that can be easily consumed by machine learning models and algorithms.
+		*/
+		this.embeddings = new Embeddings(this);
+		/**
+		* Files are used to upload documents that can be used with features like Assistants and Fine-tuning.
+		*/
+		this.files = new Files(this);
+		/**
+		* Given a prompt and/or an input image, the model will generate a new image.
+		*/
+		this.images = new Images(this);
+		this.audio = new Audio(this);
+		/**
+		* Given text and/or image inputs, classifies if those inputs are potentially harmful.
+		*/
+		this.moderations = new Moderations(this);
+		/**
+		* List and describe the various models available in the API.
+		*/
+		this.models = new Models(this);
+		this.fineTuning = new FineTuning(this);
+		this.graders = new Graders(this);
+		this.vectorStores = new VectorStores(this);
+		this.webhooks = new Webhooks(this);
+		this.beta = new Beta(this);
+		/**
+		* Create large batches of API requests to run asynchronously.
+		*/
+		this.batches = new Batches(this);
+		/**
+		* Use Uploads to upload large files in multiple parts.
+		*/
+		this.uploads = new Uploads(this);
+		this.admin = new Admin(this);
+		this.responses = new Responses(this);
+		this.realtime = new Realtime(this);
+		/**
+		* Manage conversations and conversation items.
+		*/
+		this.conversations = new Conversations(this);
+		/**
+		* Manage and run evals in the OpenAI platform.
+		*/
+		this.evals = new Evals(this);
+		this.containers = new Containers(this);
+		this.skills = new Skills(this);
+		this.videos = new Videos(this);
+		const options = {
+			apiKey,
+			adminAPIKey,
+			organization,
+			project,
+			webhookSecret,
+			workloadIdentity,
+			...opts,
+			baseURL: baseURL || `https://api.openai.com/v1`
+		};
+		if (apiKey && workloadIdentity) throw new OpenAIError("The `apiKey` and `workloadIdentity` options are mutually exclusive");
+		if (!apiKey && !adminAPIKey && !workloadIdentity) throw new 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 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");
+		this.baseURL = options.baseURL;
+		this.timeout = options.timeout ?? _a.DEFAULT_TIMEOUT;
+		this.logger = options.logger ?? console;
+		const defaultLogLevel = "warn";
+		this.logLevel = defaultLogLevel;
+		this.logLevel = parseLogLevel(options.logLevel, "ClientOptions.logLevel", this) ?? parseLogLevel(readEnv("OPENAI_LOG"), "process.env['OPENAI_LOG']", this) ?? defaultLogLevel;
+		this.fetchOptions = options.fetchOptions;
+		this.maxRetries = options.maxRetries ?? 2;
+		this.fetch = options.fetch ?? getDefaultFetch();
+		__classPrivateFieldSet(this, _OpenAI_encoder, FallbackEncoder, "f");
+		const customHeadersEnv = 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 = buildHeaders([parsed, options.defaultHeaders]);
+		}
+		this._options = options;
+		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;
+	}
+	/**
+	* Create a new client instance re-using the same options given to the current client with optional overriding.
+	*/
+	withOptions(options) {
+		return new this.constructor({
+			...this._options,
+			baseURL: this.baseURL,
+			maxRetries: this.maxRetries,
+			timeout: this.timeout,
+			logger: this.logger,
+			logLevel: this.logLevel,
+			fetch: this.fetch,
+			fetchOptions: this.fetchOptions,
+			apiKey: this._options.apiKey,
+			adminAPIKey: this.adminAPIKey,
+			workloadIdentity: this._options.workloadIdentity,
+			organization: this.organization,
+			project: this.project,
+			webhookSecret: this.webhookSecret,
+			...options
+		});
+	}
+	defaultQuery() {
+		return this._options.defaultQuery;
+	}
+	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 buildHeaders([schemes.bearerAuth ? await this.bearerAuth(opts) : null, schemes.adminAPIKeyAuth ? await this.adminAPIKeyAuth(opts) : null]);
+	}
+	async bearerAuth(opts) {
+		if (this._workloadIdentityAuth) return buildHeaders([{ Authorization: `Bearer ${await this._workloadIdentityAuth.getToken()}` }]);
+		if (this.apiKey == null) return;
+		return buildHeaders([{ Authorization: `Bearer ${this.apiKey}` }]);
+	}
+	async adminAPIKeyAuth(opts) {
+		if (this.adminAPIKey == null) return;
+		return buildHeaders([{ Authorization: `Bearer ${this.adminAPIKey}` }]);
+	}
+	stringifyQuery(query) {
+		return stringifyQuery(query);
+	}
+	getUserAgent() {
+		return `${this.constructor.name}/JS ${VERSION}`;
+	}
+	defaultIdempotencyKey() {
+		return `stainless-node-retry-${uuid4()}`;
+	}
+	makeStatusError(status, error, message, headers) {
+		return APIError.generate(status, error, message, headers);
+	}
+	async _callApiKey() {
+		const apiKey = this._options.apiKey;
+		if (typeof apiKey !== "function") return false;
+		let token;
+		try {
+			token = await apiKey();
+		} catch (err) {
+			if (err instanceof OpenAIError) throw err;
+			throw new OpenAIError(`Failed to get token from 'apiKey' function: ${err.message}`, { cause: err });
+		}
+		if (typeof token !== "string" || !token) throw new OpenAIError(`Expected 'apiKey' function argument to return a string but it returned ${token}`);
+		this.apiKey = token;
+		return true;
+	}
+	buildURL(path, query, defaultBaseURL) {
+		const baseURL = !__classPrivateFieldGet(this, _OpenAI_instances, "m", _OpenAI_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL;
+		const url = isAbsoluteURL(path) ? new URL(path) : new URL(baseURL + (baseURL.endsWith("/") && path.startsWith("/") ? path.slice(1) : path));
+		const defaultQuery = this.defaultQuery();
+		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);
+		return url.toString();
+	}
+	/**
+	* Used as a callback for mutating the given `FinalRequestOptions` object.
+	*/
+	async prepareOptions(options) {
+		if ((options.__security ?? { bearerAuth: true }).bearerAuth) await this._callApiKey();
+	}
+	/**
+	* Used as a callback for mutating the given `RequestInit` object.
+	*
+	* This is useful for cases where you want to add certain headers based off of
+	* the request properties, e.g. `method` or `url`.
+	*/
+	async prepareRequest(request, { url, options }) {}
+	get(path, opts) {
+		return this.methodRequest("get", path, opts);
+	}
+	post(path, opts) {
+		return this.methodRequest("post", path, opts);
+	}
+	patch(path, opts) {
+		return this.methodRequest("patch", path, opts);
+	}
+	put(path, opts) {
+		return this.methodRequest("put", path, opts);
+	}
+	delete(path, opts) {
+		return this.methodRequest("delete", path, opts);
+	}
+	methodRequest(method, path, opts) {
+		return this.request(Promise.resolve(opts).then((opts) => {
+			return {
+				method,
+				path,
+				...opts
+			};
+		}));
+	}
+	request(options, remainingRetries = null) {
+		return new APIPromise(this, this.makeRequest(options, remainingRetries, void 0));
+	}
+	async makeRequest(optionsInput, retriesRemaining, retryOfRequestLogID) {
+		const options = await optionsInput;
+		const maxRetries = options.maxRetries ?? this.maxRetries;
+		if (retriesRemaining == null) retriesRemaining = maxRetries;
+		await this.prepareOptions(options);
+		const { req, url, timeout } = await this.buildRequest(options, { retryCount: maxRetries - retriesRemaining });
+		await this.prepareRequest(req, {
+			url,
+			options
+		});
+		/** Not an API request ID, just for correlating local log entries. */
+		const requestLogID = "log_" + (Math.random() * (1 << 24) | 0).toString(16).padStart(6, "0");
+		const retryLogStr = retryOfRequestLogID === void 0 ? "" : `, retryOf: ${retryOfRequestLogID}`;
+		const startTime = Date.now();
+		loggerFor(this).debug(`[${requestLogID}] sending request`, formatRequestDetails({
+			retryOfRequestLogID,
+			method: options.method,
+			url,
+			options,
+			headers: req.headers
+		}));
+		if (options.signal?.aborted) throw new APIUserAbortError();
+		const security = options.__security ?? { bearerAuth: true };
+		const controller = new AbortController();
+		const response = await this.fetchWithAuth(url, req, timeout, controller, security).catch(castToError);
+		const headersTime = Date.now();
+		if (response instanceof globalThis.Error) {
+			const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
+			if (options.signal?.aborted) throw new APIUserAbortError();
+			const isTimeout = isAbortError(response) || /timed? ?out/i.test(String(response) + ("cause" in response ? String(response.cause) : ""));
+			if (retriesRemaining) {
+				loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - ${retryMessage}`);
+				loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (${retryMessage})`, formatRequestDetails({
+					retryOfRequestLogID,
+					url,
+					durationMs: headersTime - startTime,
+					message: response.message
+				}));
+				return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID);
+			}
+			loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - error; no more retries left`);
+			loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (error; no more retries left)`, formatRequestDetails({
+				retryOfRequestLogID,
+				url,
+				durationMs: headersTime - startTime,
+				message: response.message
+			}));
+			if (response instanceof OAuthError || response instanceof SubjectTokenProviderError) throw response;
+			if (isTimeout) throw new APIConnectionTimeoutError();
+			throw new APIConnectionError({
+				message: getConnectionErrorMessage(response),
+				cause: response
+			});
+		}
+		const responseInfo = `[${requestLogID}${retryLogStr}${[...response.headers.entries()].filter(([name]) => name === "x-request-id").map(([name, value]) => ", " + name + ": " + JSON.stringify(value)).join("")}] ${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 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`;
+				await CancelReadableStream(response.body);
+				loggerFor(this).info(`${responseInfo} - ${retryMessage}`);
+				loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails({
+					retryOfRequestLogID,
+					url: response.url,
+					status: response.status,
+					headers: response.headers,
+					durationMs: headersTime - startTime
+				}));
+				return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID, response.headers);
+			}
+			const retryMessage = shouldRetry ? `error; no more retries left` : `error; not retryable`;
+			loggerFor(this).info(`${responseInfo} - ${retryMessage}`);
+			const errText = await response.text().catch((err) => castToError(err).message);
+			const errJSON = safeJSON(errText);
+			const errMessage = errJSON ? void 0 : errText;
+			loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails({
+				retryOfRequestLogID,
+				url: response.url,
+				status: response.status,
+				headers: response.headers,
+				message: errMessage,
+				durationMs: Date.now() - startTime
+			}));
+			throw this.makeStatusError(response.status, errJSON, errMessage, response.headers);
+		}
+		loggerFor(this).info(responseInfo);
+		loggerFor(this).debug(`[${requestLogID}] response start`, formatRequestDetails({
+			retryOfRequestLogID,
+			url: response.url,
+			status: response.status,
+			headers: response.headers,
+			durationMs: headersTime - startTime
+		}));
+		return {
+			response,
+			options,
+			controller,
+			requestLogID,
+			retryOfRequestLogID,
+			startTime
+		};
+	}
+	getAPIList(path, Page, opts) {
+		return this.requestAPIList(Page, opts && "then" in opts ? opts.then((opts) => ({
+			method: "get",
+			path,
+			...opts
+		})) : {
+			method: "get",
+			path,
+			...opts
+		});
+	}
+	requestAPIList(Page, options) {
+		const request = this.makeRequest(options, null, void 0);
+		return new 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}`);
+			}
+		}
+		return await this.fetchWithTimeout(url, init, timeout, controller);
+	}
+	async fetchWithTimeout(url, init, ms, controller) {
+		const { signal, method, ...options } = init || {};
+		const abort = this._makeAbort(controller);
+		if (signal) signal.addEventListener("abort", abort, { once: true });
+		const timeout = setTimeout(abort, ms);
+		const isReadableBody = globalThis.ReadableStream && options.body instanceof globalThis.ReadableStream || typeof options.body === "object" && options.body !== null && Symbol.asyncIterator in options.body;
+		const fetchOptions = {
+			signal: controller.signal,
+			...isReadableBody ? { duplex: "half" } : {},
+			method: "GET",
+			...options
+		};
+		if (method) fetchOptions.method = method.toUpperCase();
+		try {
+			return await this.fetch.call(void 0, url, fetchOptions);
+		} finally {
+			clearTimeout(timeout);
+		}
+	}
+	async shouldRetry(response) {
+		const shouldRetryHeader = response.headers.get("x-should-retry");
+		if (shouldRetryHeader === "true") return true;
+		if (shouldRetryHeader === "false") return false;
+		if (response.status === 408) return true;
+		if (response.status === 409) return true;
+		if (response.status === 429) return true;
+		if (response.status >= 500) return true;
+		return false;
+	}
+	async retryRequest(options, retriesRemaining, requestLogID, responseHeaders) {
+		let timeoutMillis;
+		const retryAfterMillisHeader = responseHeaders?.get("retry-after-ms");
+		if (retryAfterMillisHeader) {
+			const timeoutMs = parseFloat(retryAfterMillisHeader);
+			if (!Number.isNaN(timeoutMs)) timeoutMillis = timeoutMs;
+		}
+		const retryAfterHeader = responseHeaders?.get("retry-after");
+		if (retryAfterHeader && !timeoutMillis) {
+			const timeoutSeconds = parseFloat(retryAfterHeader);
+			if (!Number.isNaN(timeoutSeconds)) timeoutMillis = timeoutSeconds * 1e3;
+			else timeoutMillis = Date.parse(retryAfterHeader) - Date.now();
+		}
+		if (timeoutMillis === void 0) {
+			const maxRetries = options.maxRetries ?? this.maxRetries;
+			timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
+		}
+		await sleep(timeoutMillis);
+		return this.makeRequest(options, retriesRemaining - 1, requestLogID);
+	}
+	calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) {
+		const initialRetryDelay = .5;
+		const maxRetryDelay = 8;
+		const numRetries = maxRetries - retriesRemaining;
+		return Math.min(initialRetryDelay * Math.pow(2, numRetries), maxRetryDelay) * (1 - Math.random() * .25) * 1e3;
+	}
+	async buildRequest(inputOptions, { retryCount = 0 } = {}) {
+		const options = { ...inputOptions };
+		const { method, path, query, defaultBaseURL } = options;
+		const url = this.buildURL(path, query, defaultBaseURL);
+		if ("timeout" in options) validatePositiveInteger("timeout", options.timeout);
+		options.timeout = options.timeout ?? this.timeout;
+		const { bodyHeaders, body, isStreamingBody } = this.buildBody({ options });
+		if (isStreamingBody) inputOptions.__metadata = {
+			...inputOptions.__metadata,
+			hasStreamingBody: true
+		};
+		return {
+			req: {
+				method,
+				headers: await this.buildHeaders({
+					options: inputOptions,
+					method,
+					bodyHeaders,
+					retryCount
+				}),
+				...options.signal && { signal: options.signal },
+				...globalThis.ReadableStream && body instanceof globalThis.ReadableStream && { duplex: "half" },
+				...body && { body },
+				...this.fetchOptions ?? {},
+				...options.fetchOptions ?? {}
+			},
+			url,
+			timeout: options.timeout
+		};
+	}
+	async buildHeaders({ options, method, bodyHeaders, retryCount }) {
+		let idempotencyHeaders = {};
+		if (this.idempotencyHeader && method !== "get") {
+			if (!options.idempotencyKey) options.idempotencyKey = this.defaultIdempotencyKey();
+			idempotencyHeaders[this.idempotencyHeader] = options.idempotencyKey;
+		}
+		const headers = buildHeaders([
+			idempotencyHeaders,
+			{
+				Accept: "application/json",
+				"User-Agent": this.getUserAgent(),
+				"X-Stainless-Retry-Count": String(retryCount),
+				...options.timeout ? { "X-Stainless-Timeout": String(Math.trunc(options.timeout / 1e3)) } : {},
+				...getPlatformHeaders(),
+				"OpenAI-Organization": this.organization,
+				"OpenAI-Project": this.project
+			},
+			await this.authHeaders(options, options.__security ?? { bearerAuth: true }),
+			this._options.defaultHeaders,
+			bodyHeaders,
+			options.headers
+		]);
+		this.validateHeaders(headers, options.__security ?? { bearerAuth: true });
+		return headers.values;
+	}
+	_makeAbort(controller) {
+		return () => controller.abort();
+	}
+	buildBody({ options: { body, headers: rawHeaders } }) {
+		if (!body) return {
+			bodyHeaders: void 0,
+			body: void 0,
+			isStreamingBody: false
+		};
+		const headers = 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 (ArrayBuffer.isView(body) || body instanceof ArrayBuffer || body instanceof DataView || typeof body === "string" && headers.values.has("content-type") || globalThis.Blob && body instanceof globalThis.Blob || body instanceof FormData || body instanceof URLSearchParams || isReadableStream) return {
+			bodyHeaders: void 0,
+			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: void 0,
+			body: 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 {
+			...__classPrivateFieldGet(this, _OpenAI_encoder, "f").call(this, {
+				body,
+				headers
+			}),
+			isStreamingBody: false
+		};
+	}
+};
+_a = OpenAI, _OpenAI_encoder = /* @__PURE__ */ new WeakMap(), _OpenAI_instances = /* @__PURE__ */ new WeakSet(), _OpenAI_baseURLOverridden = function _OpenAI_baseURLOverridden() {
+	return this.baseURL !== "https://api.openai.com/v1";
+};
+OpenAI.OpenAI = _a;
+OpenAI.DEFAULT_TIMEOUT = 6e5;
+OpenAI.OpenAIError = OpenAIError;
+OpenAI.APIError = APIError;
+OpenAI.APIConnectionError = APIConnectionError;
+OpenAI.APIConnectionTimeoutError = APIConnectionTimeoutError;
+OpenAI.APIUserAbortError = APIUserAbortError;
+OpenAI.NotFoundError = NotFoundError;
+OpenAI.ConflictError = ConflictError;
+OpenAI.RateLimitError = RateLimitError;
+OpenAI.BadRequestError = BadRequestError;
+OpenAI.AuthenticationError = AuthenticationError;
+OpenAI.InternalServerError = InternalServerError;
+OpenAI.PermissionDeniedError = PermissionDeniedError;
+OpenAI.UnprocessableEntityError = UnprocessableEntityError;
+OpenAI.InvalidWebhookSignatureError = InvalidWebhookSignatureError;
+OpenAI.toFile = toFile;
+OpenAI.Completions = Completions;
+OpenAI.Chat = Chat;
+OpenAI.Embeddings = Embeddings;
+OpenAI.Files = Files;
+OpenAI.Images = Images;
+OpenAI.Audio = Audio;
+OpenAI.Moderations = Moderations;
+OpenAI.Models = Models;
+OpenAI.FineTuning = FineTuning;
+OpenAI.Graders = Graders;
+OpenAI.VectorStores = VectorStores;
+OpenAI.Webhooks = Webhooks;
+OpenAI.Beta = Beta;
+OpenAI.Batches = Batches;
+OpenAI.Uploads = Uploads;
+OpenAI.Admin = Admin;
+OpenAI.Responses = Responses;
+OpenAI.Realtime = Realtime;
+OpenAI.Conversations = Conversations;
+OpenAI.Evals = Evals;
+OpenAI.Containers = Containers;
+OpenAI.Skills = Skills;
+OpenAI.Videos = 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(...) } });`;
+}
+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;
+}
+
+//#endregion
+export { OpenAI };
+//# sourceMappingURL=client.mjs.map