@inductiv/node-red-openai-api
Version:
Enhance your Node-RED projects with advanced AI capabilities.
1,311 lines (1,295 loc) • 706 kB
JavaScript
"use strict";
var __getOwnPropNames = Object.getOwnPropertyNames;
var __commonJS = (cb, mod) => function __require() {
try {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
} catch (e) {
throw mod = 0, e;
}
};
// node_modules/openai/internal/tslib.js
var require_tslib = __commonJS({
"node_modules/openai/internal/tslib.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.__setModuleDefault = exports2.__createBinding = void 0;
exports2.__classPrivateFieldSet = __classPrivateFieldSet;
exports2.__classPrivateFieldGet = __classPrivateFieldGet;
exports2.__exportStar = __exportStar;
exports2.__importStar = __importStar;
function __classPrivateFieldSet(receiver, state, value, kind, f) {
if (kind === "m")
throw new TypeError("Private method is not writable");
if (kind === "a" && !f)
throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
throw new TypeError("Cannot write private member to an object whose class did not declare it");
return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
}
function __classPrivateFieldGet(receiver, state, kind, f) {
if (kind === "a" && !f)
throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
}
var __createBinding = Object.create ? function(o, m, k, k2) {
if (k2 === void 0)
k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = {
enumerable: true,
get: function() {
return m[k];
}
};
}
Object.defineProperty(o, k2, desc);
} : function(o, m, k, k2) {
if (k2 === void 0)
k2 = k;
o[k2] = m[k];
};
exports2.__createBinding = __createBinding;
function __exportStar(m, o) {
for (var p in m)
if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
__createBinding(o, m, p);
}
var __setModuleDefault = Object.create ? function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
} : function(o, v) {
o["default"] = v;
};
exports2.__setModuleDefault = __setModuleDefault;
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function(o2) {
var ar = [];
for (var k in o2)
if (Object.prototype.hasOwnProperty.call(o2, k))
ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
function __importStar(mod) {
if (mod && mod.__esModule)
return mod;
var result = {};
if (mod != null) {
for (var k = ownKeys(mod), i = 0; i < k.length; i++)
if (k[i] !== "default")
__createBinding(result, mod, k[i]);
}
__setModuleDefault(result, mod);
return result;
}
}
});
// node_modules/openai/internal/utils/uuid.js
var require_uuid = __commonJS({
"node_modules/openai/internal/utils/uuid.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.uuid4 = void 0;
var uuid4 = function() {
const { crypto: crypto2 } = globalThis;
if (crypto2?.randomUUID) {
exports2.uuid4 = crypto2.randomUUID.bind(crypto2);
return crypto2.randomUUID();
}
const u8 = new Uint8Array(1);
const randomByte = crypto2 ? () => crypto2.getRandomValues(u8)[0] : () => Math.random() * 255 & 255;
return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c) => (+c ^ randomByte() & 15 >> +c / 4).toString(16));
};
exports2.uuid4 = uuid4;
}
});
// node_modules/openai/internal/errors.js
var require_errors = __commonJS({
"node_modules/openai/internal/errors.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.castToError = void 0;
exports2.isAbortError = isAbortError;
function isAbortError(err) {
return typeof err === "object" && err !== null && // Spec-compliant fetch implementations
("name" in err && err.name === "AbortError" || // Expo fetch
"message" in err && String(err.message).includes("FetchRequestCanceledException"));
}
var castToError = (err) => {
if (err instanceof Error)
return err;
if (typeof err === "object" && err !== null) {
try {
if (Object.prototype.toString.call(err) === "[object Error]") {
const error = new Error(err.message, err.cause ? { cause: err.cause } : {});
if (err.stack)
error.stack = err.stack;
if (err.cause && !error.cause)
error.cause = err.cause;
if (err.name)
error.name = err.name;
return error;
}
} catch {
}
try {
return new Error(JSON.stringify(err));
} catch {
}
}
return new Error(err);
};
exports2.castToError = castToError;
}
});
// node_modules/openai/core/error.js
var require_error = __commonJS({
"node_modules/openai/core/error.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.SubjectTokenProviderError = exports2.OAuthError = exports2.InvalidWebhookSignatureError = exports2.ContentFilterFinishReasonError = exports2.LengthFinishReasonError = exports2.InternalServerError = exports2.RateLimitError = exports2.UnprocessableEntityError = exports2.ConflictError = exports2.NotFoundError = exports2.PermissionDeniedError = exports2.AuthenticationError = exports2.BadRequestError = exports2.APIConnectionTimeoutError = exports2.APIConnectionError = exports2.APIUserAbortError = exports2.APIError = exports2.OpenAIError = void 0;
var errors_1 = require_errors();
var OpenAIError = class extends Error {
};
exports2.OpenAIError = OpenAIError;
var APIError = class _APIError extends OpenAIError {
constructor(status, error, message, headers) {
super(`${_APIError.makeMessage(status, error, message)}`);
this.status = status;
this.headers = headers;
this.requestID = headers?.get("x-request-id");
this.error = error;
const data = error;
this.code = data?.["code"];
this.param = data?.["param"];
this.type = data?.["type"];
}
static makeMessage(status, error, message) {
const msg = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : message;
if (status && msg) {
return `${status} ${msg}`;
}
if (status) {
return `${status} status code (no body)`;
}
if (msg) {
return msg;
}
return "(no status code or body)";
}
static generate(status, errorResponse, message, headers) {
if (!status || !headers) {
return new APIConnectionError({ message, cause: (0, errors_1.castToError)(errorResponse) });
}
const error = errorResponse?.["error"];
if (status === 400) {
return new BadRequestError(status, error, message, headers);
}
if (status === 401) {
return new AuthenticationError(status, error, message, headers);
}
if (status === 403) {
return new PermissionDeniedError(status, error, message, headers);
}
if (status === 404) {
return new NotFoundError(status, error, message, headers);
}
if (status === 409) {
return new ConflictError(status, error, message, headers);
}
if (status === 422) {
return new UnprocessableEntityError(status, error, message, headers);
}
if (status === 429) {
return new RateLimitError(status, error, message, headers);
}
if (status >= 500) {
return new InternalServerError(status, error, message, headers);
}
return new _APIError(status, error, message, headers);
}
};
exports2.APIError = APIError;
var APIUserAbortError = class extends APIError {
constructor({ message } = {}) {
super(void 0, void 0, message || "Request was aborted.", void 0);
}
};
exports2.APIUserAbortError = APIUserAbortError;
var APIConnectionError = class extends APIError {
constructor({ message, cause }) {
super(void 0, void 0, message || "Connection error.", void 0);
if (cause)
this.cause = cause;
}
};
exports2.APIConnectionError = APIConnectionError;
var APIConnectionTimeoutError = class extends APIConnectionError {
constructor({ message } = {}) {
super({ message: message ?? "Request timed out." });
}
};
exports2.APIConnectionTimeoutError = APIConnectionTimeoutError;
var BadRequestError = class extends APIError {
};
exports2.BadRequestError = BadRequestError;
var AuthenticationError = class extends APIError {
};
exports2.AuthenticationError = AuthenticationError;
var PermissionDeniedError = class extends APIError {
};
exports2.PermissionDeniedError = PermissionDeniedError;
var NotFoundError = class extends APIError {
};
exports2.NotFoundError = NotFoundError;
var ConflictError = class extends APIError {
};
exports2.ConflictError = ConflictError;
var UnprocessableEntityError = class extends APIError {
};
exports2.UnprocessableEntityError = UnprocessableEntityError;
var RateLimitError = class extends APIError {
};
exports2.RateLimitError = RateLimitError;
var InternalServerError = class extends APIError {
};
exports2.InternalServerError = InternalServerError;
var LengthFinishReasonError = class extends OpenAIError {
constructor() {
super(`Could not parse response content as the length limit was reached`);
}
};
exports2.LengthFinishReasonError = LengthFinishReasonError;
var ContentFilterFinishReasonError = class extends OpenAIError {
constructor() {
super(`Could not parse response content as the request was rejected by the content filter`);
}
};
exports2.ContentFilterFinishReasonError = ContentFilterFinishReasonError;
var InvalidWebhookSignatureError = class extends Error {
constructor(message) {
super(message);
}
};
exports2.InvalidWebhookSignatureError = InvalidWebhookSignatureError;
var OAuthError = class extends APIError {
constructor(status, error, headers) {
let finalMessage = "OAuth2 authentication error";
let error_code = void 0;
if (error && typeof error === "object") {
const errorData = error;
error_code = errorData["error"];
const description = errorData["error_description"];
if (description && typeof description === "string") {
finalMessage = description;
} else if (error_code) {
finalMessage = error_code;
}
}
super(status, error, finalMessage, headers);
this.error_code = error_code;
}
};
exports2.OAuthError = OAuthError;
var SubjectTokenProviderError = class extends OpenAIError {
constructor(message, provider, cause) {
super(message);
this.provider = provider;
this.cause = cause;
}
};
exports2.SubjectTokenProviderError = SubjectTokenProviderError;
}
});
// node_modules/openai/internal/utils/values.js
var require_values = __commonJS({
"node_modules/openai/internal/utils/values.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.safeJSON = exports2.maybeCoerceBoolean = exports2.maybeCoerceFloat = exports2.maybeCoerceInteger = exports2.coerceBoolean = exports2.coerceFloat = exports2.coerceInteger = exports2.validatePositiveInteger = exports2.ensurePresent = exports2.isReadonlyArray = exports2.isArray = exports2.isAbsoluteURL = void 0;
exports2.maybeObj = maybeObj;
exports2.isEmptyObj = isEmptyObj;
exports2.hasOwn = hasOwn;
exports2.isObj = isObj;
var error_1 = require_error();
var startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i;
var isAbsoluteURL = (url) => {
return startsWithSchemeRegexp.test(url);
};
exports2.isAbsoluteURL = isAbsoluteURL;
var isArray = (val) => (exports2.isArray = Array.isArray, (0, exports2.isArray)(val));
exports2.isArray = isArray;
exports2.isReadonlyArray = exports2.isArray;
function maybeObj(x) {
if (typeof x !== "object") {
return {};
}
return x ?? {};
}
function isEmptyObj(obj) {
if (!obj)
return true;
for (const _k in obj)
return false;
return true;
}
function hasOwn(obj, key) {
return Object.prototype.hasOwnProperty.call(obj, key);
}
function isObj(obj) {
return obj != null && typeof obj === "object" && !Array.isArray(obj);
}
var ensurePresent = (value) => {
if (value == null) {
throw new error_1.OpenAIError(`Expected a value to be given but received ${value} instead.`);
}
return value;
};
exports2.ensurePresent = ensurePresent;
var validatePositiveInteger = (name, n) => {
if (typeof n !== "number" || !Number.isInteger(n)) {
throw new error_1.OpenAIError(`${name} must be an integer`);
}
if (n < 0) {
throw new error_1.OpenAIError(`${name} must be a positive integer`);
}
return n;
};
exports2.validatePositiveInteger = validatePositiveInteger;
var coerceInteger = (value) => {
if (typeof value === "number")
return Math.round(value);
if (typeof value === "string")
return parseInt(value, 10);
throw new error_1.OpenAIError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
};
exports2.coerceInteger = coerceInteger;
var coerceFloat = (value) => {
if (typeof value === "number")
return value;
if (typeof value === "string")
return parseFloat(value);
throw new error_1.OpenAIError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
};
exports2.coerceFloat = coerceFloat;
var coerceBoolean = (value) => {
if (typeof value === "boolean")
return value;
if (typeof value === "string")
return value === "true";
return Boolean(value);
};
exports2.coerceBoolean = coerceBoolean;
var maybeCoerceInteger = (value) => {
if (value == null) {
return void 0;
}
return (0, exports2.coerceInteger)(value);
};
exports2.maybeCoerceInteger = maybeCoerceInteger;
var maybeCoerceFloat = (value) => {
if (value == null) {
return void 0;
}
return (0, exports2.coerceFloat)(value);
};
exports2.maybeCoerceFloat = maybeCoerceFloat;
var maybeCoerceBoolean = (value) => {
if (value == null) {
return void 0;
}
return (0, exports2.coerceBoolean)(value);
};
exports2.maybeCoerceBoolean = maybeCoerceBoolean;
var safeJSON = (text) => {
try {
return JSON.parse(text);
} catch (err) {
return void 0;
}
};
exports2.safeJSON = safeJSON;
}
});
// node_modules/openai/internal/utils/sleep.js
var require_sleep = __commonJS({
"node_modules/openai/internal/utils/sleep.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.sleep = void 0;
var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
exports2.sleep = sleep;
}
});
// node_modules/openai/version.js
var require_version = __commonJS({
"node_modules/openai/version.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.VERSION = void 0;
exports2.VERSION = "6.40.0";
}
});
// node_modules/openai/internal/detect-platform.js
var require_detect_platform = __commonJS({
"node_modules/openai/internal/detect-platform.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.getPlatformHeaders = exports2.isRunningInBrowser = void 0;
var version_1 = require_version();
var isRunningInBrowser = () => {
return (
// @ts-ignore
typeof window !== "undefined" && // @ts-ignore
typeof window.document !== "undefined" && // @ts-ignore
typeof navigator !== "undefined"
);
};
exports2.isRunningInBrowser = isRunningInBrowser;
function getDetectedPlatform() {
if (typeof Deno !== "undefined" && Deno.build != null) {
return "deno";
}
if (typeof EdgeRuntime !== "undefined") {
return "edge";
}
if (Object.prototype.toString.call(typeof globalThis.process !== "undefined" ? globalThis.process : 0) === "[object process]") {
return "node";
}
return "unknown";
}
var getPlatformProperties = () => {
const detectedPlatform = getDetectedPlatform();
if (detectedPlatform === "deno") {
return {
"X-Stainless-Lang": "js",
"X-Stainless-Package-Version": version_1.VERSION,
"X-Stainless-OS": normalizePlatform(Deno.build.os),
"X-Stainless-Arch": normalizeArch(Deno.build.arch),
"X-Stainless-Runtime": "deno",
"X-Stainless-Runtime-Version": typeof Deno.version === "string" ? Deno.version : Deno.version?.deno ?? "unknown"
};
}
if (typeof EdgeRuntime !== "undefined") {
return {
"X-Stainless-Lang": "js",
"X-Stainless-Package-Version": version_1.VERSION,
"X-Stainless-OS": "Unknown",
"X-Stainless-Arch": `other:${EdgeRuntime}`,
"X-Stainless-Runtime": "edge",
"X-Stainless-Runtime-Version": globalThis.process.version
};
}
if (detectedPlatform === "node") {
return {
"X-Stainless-Lang": "js",
"X-Stainless-Package-Version": version_1.VERSION,
"X-Stainless-OS": normalizePlatform(globalThis.process.platform ?? "unknown"),
"X-Stainless-Arch": normalizeArch(globalThis.process.arch ?? "unknown"),
"X-Stainless-Runtime": "node",
"X-Stainless-Runtime-Version": globalThis.process.version ?? "unknown"
};
}
const browserInfo = getBrowserInfo();
if (browserInfo) {
return {
"X-Stainless-Lang": "js",
"X-Stainless-Package-Version": version_1.VERSION,
"X-Stainless-OS": "Unknown",
"X-Stainless-Arch": "unknown",
"X-Stainless-Runtime": `browser:${browserInfo.browser}`,
"X-Stainless-Runtime-Version": browserInfo.version
};
}
return {
"X-Stainless-Lang": "js",
"X-Stainless-Package-Version": version_1.VERSION,
"X-Stainless-OS": "Unknown",
"X-Stainless-Arch": "unknown",
"X-Stainless-Runtime": "unknown",
"X-Stainless-Runtime-Version": "unknown"
};
};
function getBrowserInfo() {
if (typeof navigator === "undefined" || !navigator) {
return null;
}
const browserPatterns = [
{ key: "edge", pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
{ key: "ie", pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
{ key: "ie", pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ },
{ key: "chrome", pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
{ key: "firefox", pattern: /Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
{ key: "safari", pattern: /(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/ }
];
for (const { key, pattern } of browserPatterns) {
const match = pattern.exec(navigator.userAgent);
if (match) {
const major = match[1] || 0;
const minor = match[2] || 0;
const patch = match[3] || 0;
return { browser: key, version: `${major}.${minor}.${patch}` };
}
}
return null;
}
var normalizeArch = (arch) => {
if (arch === "x32")
return "x32";
if (arch === "x86_64" || arch === "x64")
return "x64";
if (arch === "arm")
return "arm";
if (arch === "aarch64" || arch === "arm64")
return "arm64";
if (arch)
return `other:${arch}`;
return "unknown";
};
var normalizePlatform = (platform) => {
platform = platform.toLowerCase();
if (platform.includes("ios"))
return "iOS";
if (platform === "android")
return "Android";
if (platform === "darwin")
return "MacOS";
if (platform === "win32")
return "Windows";
if (platform === "freebsd")
return "FreeBSD";
if (platform === "openbsd")
return "OpenBSD";
if (platform === "linux")
return "Linux";
if (platform)
return `Other:${platform}`;
return "Unknown";
};
var _platformHeaders;
var getPlatformHeaders = () => {
return _platformHeaders ?? (_platformHeaders = getPlatformProperties());
};
exports2.getPlatformHeaders = getPlatformHeaders;
}
});
// node_modules/openai/internal/shims.js
var require_shims = __commonJS({
"node_modules/openai/internal/shims.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.getDefaultFetch = getDefaultFetch;
exports2.makeReadableStream = makeReadableStream;
exports2.ReadableStreamFrom = ReadableStreamFrom;
exports2.ReadableStreamToAsyncIterable = ReadableStreamToAsyncIterable;
exports2.CancelReadableStream = CancelReadableStream;
function getDefaultFetch() {
if (typeof fetch !== "undefined") {
return fetch;
}
throw new Error("`fetch` is not defined as a global; Either pass `fetch` to the client, `new OpenAI({ fetch })` or polyfill the global, `globalThis.fetch = fetch`");
}
function makeReadableStream(...args) {
const ReadableStream = globalThis.ReadableStream;
if (typeof ReadableStream === "undefined") {
throw new Error("`ReadableStream` is not defined as a global; You will need to polyfill it, `globalThis.ReadableStream = ReadableStream`");
}
return new ReadableStream(...args);
}
function ReadableStreamFrom(iterable) {
let iter = Symbol.asyncIterator in iterable ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
return makeReadableStream({
start() {
},
async pull(controller) {
const { done, value } = await iter.next();
if (done) {
controller.close();
} else {
controller.enqueue(value);
}
},
async cancel() {
await iter.return?.();
}
});
}
function ReadableStreamToAsyncIterable(stream) {
if (stream[Symbol.asyncIterator])
return stream;
const reader = stream.getReader();
return {
async next() {
try {
const result = await reader.read();
if (result?.done)
reader.releaseLock();
return result;
} catch (e) {
reader.releaseLock();
throw e;
}
},
async return() {
const cancelPromise = reader.cancel();
reader.releaseLock();
await cancelPromise;
return { done: true, value: void 0 };
},
[Symbol.asyncIterator]() {
return this;
}
};
}
async function CancelReadableStream(stream) {
if (stream === null || typeof stream !== "object")
return;
if (stream[Symbol.asyncIterator]) {
await stream[Symbol.asyncIterator]().return?.();
return;
}
const reader = stream.getReader();
const cancelPromise = reader.cancel();
reader.releaseLock();
await cancelPromise;
}
}
});
// node_modules/openai/internal/request-options.js
var require_request_options = __commonJS({
"node_modules/openai/internal/request-options.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.FallbackEncoder = void 0;
var FallbackEncoder = ({ headers, body }) => {
return {
bodyHeaders: {
"content-type": "application/json"
},
body: JSON.stringify(body)
};
};
exports2.FallbackEncoder = FallbackEncoder;
}
});
// node_modules/openai/internal/qs/formats.js
var require_formats = __commonJS({
"node_modules/openai/internal/qs/formats.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.RFC3986 = exports2.RFC1738 = exports2.formatters = exports2.default_formatter = exports2.default_format = void 0;
exports2.default_format = "RFC3986";
var default_formatter = (v) => String(v);
exports2.default_formatter = default_formatter;
exports2.formatters = {
RFC1738: (v) => String(v).replace(/%20/g, "+"),
RFC3986: exports2.default_formatter
};
exports2.RFC1738 = "RFC1738";
exports2.RFC3986 = "RFC3986";
}
});
// node_modules/openai/internal/qs/utils.js
var require_utils = __commonJS({
"node_modules/openai/internal/qs/utils.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.encode = exports2.has = void 0;
exports2.merge = merge;
exports2.assign_single_source = assign_single_source;
exports2.decode = decode;
exports2.compact = compact;
exports2.is_regexp = is_regexp;
exports2.is_buffer = is_buffer;
exports2.combine = combine;
exports2.maybe_map = maybe_map;
var formats_1 = require_formats();
var values_1 = require_values();
var has = (obj, key) => (exports2.has = Object.hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty), (0, exports2.has)(obj, key));
exports2.has = has;
var hex_table = /* @__PURE__ */ (() => {
const array = [];
for (let i = 0; i < 256; ++i) {
array.push("%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase());
}
return array;
})();
function compact_queue(queue) {
while (queue.length > 1) {
const item = queue.pop();
if (!item)
continue;
const obj = item.obj[item.prop];
if ((0, values_1.isArray)(obj)) {
const compacted = [];
for (let j = 0; j < obj.length; ++j) {
if (typeof obj[j] !== "undefined") {
compacted.push(obj[j]);
}
}
item.obj[item.prop] = compacted;
}
}
}
function array_to_object(source, options) {
const obj = options && options.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
for (let i = 0; i < source.length; ++i) {
if (typeof source[i] !== "undefined") {
obj[i] = source[i];
}
}
return obj;
}
function merge(target, source, options = {}) {
if (!source) {
return target;
}
if (typeof source !== "object") {
if ((0, values_1.isArray)(target)) {
target.push(source);
} else if (target && typeof target === "object") {
if (options && (options.plainObjects || options.allowPrototypes) || !(0, exports2.has)(Object.prototype, source)) {
target[source] = true;
}
} else {
return [target, source];
}
return target;
}
if (!target || typeof target !== "object") {
return [target].concat(source);
}
let mergeTarget = target;
if ((0, values_1.isArray)(target) && !(0, values_1.isArray)(source)) {
mergeTarget = array_to_object(target, options);
}
if ((0, values_1.isArray)(target) && (0, values_1.isArray)(source)) {
source.forEach(function(item, i) {
if ((0, exports2.has)(target, i)) {
const targetItem = target[i];
if (targetItem && typeof targetItem === "object" && item && typeof item === "object") {
target[i] = merge(targetItem, item, options);
} else {
target.push(item);
}
} else {
target[i] = item;
}
});
return target;
}
return Object.keys(source).reduce(function(acc, key) {
const value = source[key];
if ((0, exports2.has)(acc, key)) {
acc[key] = merge(acc[key], value, options);
} else {
acc[key] = value;
}
return acc;
}, mergeTarget);
}
function assign_single_source(target, source) {
return Object.keys(source).reduce(function(acc, key) {
acc[key] = source[key];
return acc;
}, target);
}
function decode(str, _, charset) {
const strWithoutPlus = str.replace(/\+/g, " ");
if (charset === "iso-8859-1") {
return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
}
try {
return decodeURIComponent(strWithoutPlus);
} catch (e) {
return strWithoutPlus;
}
}
var limit = 1024;
var encode = (str, _defaultEncoder, charset, _kind, format) => {
if (str.length === 0) {
return str;
}
let string = str;
if (typeof str === "symbol") {
string = Symbol.prototype.toString.call(str);
} else if (typeof str !== "string") {
string = String(str);
}
if (charset === "iso-8859-1") {
return escape(string).replace(/%u[0-9a-f]{4}/gi, function($0) {
return "%26%23" + parseInt($0.slice(2), 16) + "%3B";
});
}
let out = "";
for (let j = 0; j < string.length; j += limit) {
const segment = string.length >= limit ? string.slice(j, j + limit) : string;
const arr = [];
for (let i = 0; i < segment.length; ++i) {
let c = segment.charCodeAt(i);
if (c === 45 || // -
c === 46 || // .
c === 95 || // _
c === 126 || // ~
c >= 48 && c <= 57 || // 0-9
c >= 65 && c <= 90 || // a-z
c >= 97 && c <= 122 || // A-Z
format === formats_1.RFC1738 && (c === 40 || c === 41)) {
arr[arr.length] = segment.charAt(i);
continue;
}
if (c < 128) {
arr[arr.length] = hex_table[c];
continue;
}
if (c < 2048) {
arr[arr.length] = hex_table[192 | c >> 6] + hex_table[128 | c & 63];
continue;
}
if (c < 55296 || c >= 57344) {
arr[arr.length] = hex_table[224 | c >> 12] + hex_table[128 | c >> 6 & 63] + hex_table[128 | c & 63];
continue;
}
i += 1;
c = 65536 + ((c & 1023) << 10 | segment.charCodeAt(i) & 1023);
arr[arr.length] = hex_table[240 | c >> 18] + hex_table[128 | c >> 12 & 63] + hex_table[128 | c >> 6 & 63] + hex_table[128 | c & 63];
}
out += arr.join("");
}
return out;
};
exports2.encode = encode;
function compact(value) {
const queue = [{ obj: { o: value }, prop: "o" }];
const refs = [];
for (let i = 0; i < queue.length; ++i) {
const item = queue[i];
const obj = item.obj[item.prop];
const keys = Object.keys(obj);
for (let j = 0; j < keys.length; ++j) {
const key = keys[j];
const val = obj[key];
if (typeof val === "object" && val !== null && refs.indexOf(val) === -1) {
queue.push({ obj, prop: key });
refs.push(val);
}
}
}
compact_queue(queue);
return value;
}
function is_regexp(obj) {
return Object.prototype.toString.call(obj) === "[object RegExp]";
}
function is_buffer(obj) {
if (!obj || typeof obj !== "object") {
return false;
}
return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
}
function combine(a, b) {
return [].concat(a, b);
}
function maybe_map(val, fn) {
if ((0, values_1.isArray)(val)) {
const mapped = [];
for (let i = 0; i < val.length; i += 1) {
mapped.push(fn(val[i]));
}
return mapped;
}
return fn(val);
}
}
});
// node_modules/openai/internal/qs/stringify.js
var require_stringify = __commonJS({
"node_modules/openai/internal/qs/stringify.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.stringify = stringify;
var utils_1 = require_utils();
var formats_1 = require_formats();
var values_1 = require_values();
var array_prefix_generators = {
brackets(prefix) {
return String(prefix) + "[]";
},
comma: "comma",
indices(prefix, key) {
return String(prefix) + "[" + key + "]";
},
repeat(prefix) {
return String(prefix);
}
};
var push_to_array = function(arr, value_or_array) {
Array.prototype.push.apply(arr, (0, values_1.isArray)(value_or_array) ? value_or_array : [value_or_array]);
};
var toISOString;
var defaults = {
addQueryPrefix: false,
allowDots: false,
allowEmptyArrays: false,
arrayFormat: "indices",
charset: "utf-8",
charsetSentinel: false,
delimiter: "&",
encode: true,
encodeDotInKeys: false,
encoder: utils_1.encode,
encodeValuesOnly: false,
format: formats_1.default_format,
formatter: formats_1.default_formatter,
/** @deprecated */
indices: false,
serializeDate(date) {
return (toISOString ?? (toISOString = Function.prototype.call.bind(Date.prototype.toISOString)))(date);
},
skipNulls: false,
strictNullHandling: false
};
function is_non_nullish_primitive(v) {
return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "symbol" || typeof v === "bigint";
}
var sentinel = {};
function inner_stringify(object, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel) {
let obj = object;
let tmp_sc = sideChannel;
let step = 0;
let find_flag = false;
while ((tmp_sc = tmp_sc.get(sentinel)) !== void 0 && !find_flag) {
const pos = tmp_sc.get(object);
step += 1;
if (typeof pos !== "undefined") {
if (pos === step) {
throw new RangeError("Cyclic object value");
} else {
find_flag = true;
}
}
if (typeof tmp_sc.get(sentinel) === "undefined") {
step = 0;
}
}
if (typeof filter === "function") {
obj = filter(prefix, obj);
} else if (obj instanceof Date) {
obj = serializeDate?.(obj);
} else if (generateArrayPrefix === "comma" && (0, values_1.isArray)(obj)) {
obj = (0, utils_1.maybe_map)(obj, function(value) {
if (value instanceof Date) {
return serializeDate?.(value);
}
return value;
});
}
if (obj === null) {
if (strictNullHandling) {
return encoder && !encodeValuesOnly ? (
// @ts-expect-error
encoder(prefix, defaults.encoder, charset, "key", format)
) : prefix;
}
obj = "";
}
if (is_non_nullish_primitive(obj) || (0, utils_1.is_buffer)(obj)) {
if (encoder) {
const key_value = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, "key", format);
return [
formatter?.(key_value) + "=" + // @ts-expect-error
formatter?.(encoder(obj, defaults.encoder, charset, "value", format))
];
}
return [formatter?.(prefix) + "=" + formatter?.(String(obj))];
}
const values = [];
if (typeof obj === "undefined") {
return values;
}
let obj_keys;
if (generateArrayPrefix === "comma" && (0, values_1.isArray)(obj)) {
if (encodeValuesOnly && encoder) {
obj = (0, utils_1.maybe_map)(obj, encoder);
}
obj_keys = [{ value: obj.length > 0 ? obj.join(",") || null : void 0 }];
} else if ((0, values_1.isArray)(filter)) {
obj_keys = filter;
} else {
const keys = Object.keys(obj);
obj_keys = sort ? keys.sort(sort) : keys;
}
const encoded_prefix = encodeDotInKeys ? String(prefix).replace(/\./g, "%2E") : String(prefix);
const adjusted_prefix = commaRoundTrip && (0, values_1.isArray)(obj) && obj.length === 1 ? encoded_prefix + "[]" : encoded_prefix;
if (allowEmptyArrays && (0, values_1.isArray)(obj) && obj.length === 0) {
return adjusted_prefix + "[]";
}
for (let j = 0; j < obj_keys.length; ++j) {
const key = obj_keys[j];
const value = (
// @ts-ignore
typeof key === "object" && typeof key.value !== "undefined" ? key.value : obj[key]
);
if (skipNulls && value === null) {
continue;
}
const encoded_key = allowDots && encodeDotInKeys ? key.replace(/\./g, "%2E") : key;
const key_prefix = (0, values_1.isArray)(obj) ? typeof generateArrayPrefix === "function" ? generateArrayPrefix(adjusted_prefix, encoded_key) : adjusted_prefix : adjusted_prefix + (allowDots ? "." + encoded_key : "[" + encoded_key + "]");
sideChannel.set(object, step);
const valueSideChannel = /* @__PURE__ */ new WeakMap();
valueSideChannel.set(sentinel, sideChannel);
push_to_array(values, inner_stringify(
value,
key_prefix,
generateArrayPrefix,
commaRoundTrip,
allowEmptyArrays,
strictNullHandling,
skipNulls,
encodeDotInKeys,
// @ts-ignore
generateArrayPrefix === "comma" && encodeValuesOnly && (0, values_1.isArray)(obj) ? null : encoder,
filter,
sort,
allowDots,
serializeDate,
format,
formatter,
encodeValuesOnly,
charset,
valueSideChannel
));
}
return values;
}
function normalize_stringify_options(opts = defaults) {
if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") {
throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");
}
if (typeof opts.encodeDotInKeys !== "undefined" && typeof opts.encodeDotInKeys !== "boolean") {
throw new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided");
}
if (opts.encoder !== null && typeof opts.encoder !== "undefined" && typeof opts.encoder !== "function") {
throw new TypeError("Encoder has to be a function.");
}
const charset = opts.charset || defaults.charset;
if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") {
throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
}
let format = formats_1.default_format;
if (typeof opts.format !== "undefined") {
if (!(0, utils_1.has)(formats_1.formatters, opts.format)) {
throw new TypeError("Unknown format option provided.");
}
format = opts.format;
}
const formatter = formats_1.formatters[format];
let filter = defaults.filter;
if (typeof opts.filter === "function" || (0, values_1.isArray)(opts.filter)) {
filter = opts.filter;
}
let arrayFormat;
if (opts.arrayFormat && opts.arrayFormat in array_prefix_generators) {
arrayFormat = opts.arrayFormat;
} else if ("indices" in opts) {
arrayFormat = opts.indices ? "indices" : "repeat";
} else {
arrayFormat = defaults.arrayFormat;
}
if ("commaRoundTrip" in opts && typeof opts.commaRoundTrip !== "boolean") {
throw new TypeError("`commaRoundTrip` must be a boolean, or absent");
}
const allowDots = typeof opts.allowDots === "undefined" ? !!opts.encodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots;
return {
addQueryPrefix: typeof opts.addQueryPrefix === "boolean" ? opts.addQueryPrefix : defaults.addQueryPrefix,
// @ts-ignore
allowDots,
allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,
arrayFormat,
charset,
charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults.charsetSentinel,
commaRoundTrip: !!opts.commaRoundTrip,
delimiter: typeof opts.delimiter === "undefined" ? defaults.delimiter : opts.delimiter,
encode: typeof opts.encode === "boolean" ? opts.encode : defaults.encode,
encodeDotInKeys: typeof opts.encodeDotInKeys === "boolean" ? opts.encodeDotInKeys : defaults.encodeDotInKeys,
encoder: typeof opts.encoder === "function" ? opts.encoder : defaults.encoder,
encodeValuesOnly: typeof opts.encodeValuesOnly === "boolean" ? opts.encodeValuesOnly : defaults.encodeValuesOnly,
filter,
format,
formatter,
serializeDate: typeof opts.serializeDate === "function" ? opts.serializeDate : defaults.serializeDate,
skipNulls: typeof opts.skipNulls === "boolean" ? opts.skipNulls : defaults.skipNulls,
// @ts-ignore
sort: typeof opts.sort === "function" ? opts.sort : null,
strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling
};
}
function stringify(object, opts = {}) {
let obj = object;
const options = normalize_stringify_options(opts);
let obj_keys;
let filter;
if (typeof options.filter === "function") {
filter = options.filter;
obj = filter("", obj);
} else if ((0, values_1.isArray)(options.filter)) {
filter = options.filter;
obj_keys = filter;
}
const keys = [];
if (typeof obj !== "object" || obj === null) {
return "";
}
const generateArrayPrefix = array_prefix_generators[options.arrayFormat];
const commaRoundTrip = generateArrayPrefix === "comma" && options.commaRoundTrip;
if (!obj_keys) {
obj_keys = Object.keys(obj);
}
if (options.sort) {
obj_keys.sort(options.sort);
}
const sideChannel = /* @__PURE__ */ new WeakMap();
for (let i = 0; i < obj_keys.length; ++i) {
const key = obj_keys[i];
if (options.skipNulls && obj[key] === null) {
continue;
}
push_to_array(keys, inner_stringify(
obj[key],
key,
// @ts-expect-error
generateArrayPrefix,
commaRoundTrip,
options.allowEmptyArrays,
options.strictNullHandling,
options.skipNulls,
options.encodeDotInKeys,
options.encode ? options.encoder : null,
options.filter,
options.sort,
options.allowDots,
options.serializeDate,
options.format,
options.formatter,
options.encodeValuesOnly,
options.charset,
sideChannel
));
}
const joined = keys.join(options.delimiter);
let prefix = options.addQueryPrefix === true ? "?" : "";
if (options.charsetSentinel) {
if (options.charset === "iso-8859-1") {
prefix += "utf8=%26%2310003%3B&";
} else {
prefix += "utf8=%E2%9C%93&";
}
}
return joined.length > 0 ? prefix + joined : "";
}
}
});
// node_modules/openai/internal/utils/query.js
var require_query = __commonJS({
"node_modules/openai/internal/utils/query.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.stringifyQuery = stringifyQuery;
var tslib_1 = require_tslib();
var qs = tslib_1.__importStar(require_stringify());
function stringifyQuery(query) {
return qs.stringify(query, { arrayFormat: "brackets" });
}
}
});
// node_modules/openai/internal/utils/bytes.js
var require_bytes = __commonJS({
"node_modules/openai/internal/utils/bytes.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.concatBytes = concatBytes;
exports2.encodeUTF8 = encodeUTF8;
exports2.decodeUTF8 = decodeUTF8;
function concatBytes(buffers) {
let length = 0;
for (const buffer of buffers) {
length += buffer.length;
}
const output = new Uint8Array(length);
let index = 0;
for (const buffer of buffers) {
output.set(buffer, index);
index += buffer.length;
}
return output;
}
var encodeUTF8_;
function encodeUTF8(str) {
let encoder;
return (encodeUTF8_ ?? (encoder = new globalThis.TextEncoder(), encodeUTF8_ = encoder.encode.bind(encoder)))(str);
}
var decodeUTF8_;
function decodeUTF8(bytes) {
let decoder;
return (decodeUTF8_ ?? (decoder = new globalThis.TextDecoder(), decodeUTF8_ = decoder.decode.bind(decoder)))(bytes);
}
}
});
// node_modules/openai/internal/decoders/line.js
var require_line = __commonJS({
"node_modules/openai/internal/decoders/line.js"(exports2) {
"use strict";
var _LineDecoder_buffer;
var _LineDecoder_carriageReturnIndex;
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.LineDecoder = void 0;
exports2.findDoubleNewlineIndex = findDoubleNewlineIndex;
var tslib_1 = require_tslib();
var bytes_1 = require_bytes();
var LineDecoder = class {
constructor() {
_LineDecoder_buffer.set(this, void 0);
_LineDecoder_carriageReturnIndex.set(this, void 0);
tslib_1.__classPrivateFieldSet(this, _LineDecoder_buffer, new Uint8Array(), "f");
tslib_1.__classPrivateFieldSet(this, _LineDecoder_carriageReturnIndex, null, "f");
}
decode(chunk) {
if (chunk == null) {
return [];
}
const binaryChunk = chunk instanceof ArrayBuffer ? new Uint8Array(chunk) : typeof chunk === "string" ? (0, bytes_1.encodeUTF8)(chunk) : chunk;
tslib_1.__classPrivateFieldSet(this, _LineDecoder_buffer, (0, bytes_1.concatBytes)([tslib_1.__classPrivateFieldGet(this, _LineDecoder_buffer, "f"), binaryChunk]), "f");
const lines = [];
let patternIndex;
while ((patternIndex = findNewlineIndex(tslib_1.__classPrivateFieldGet(this, _LineDecoder_buffer, "f"), tslib_1.__classPrivateFieldGet(this, _LineDecoder_carriageReturnIndex, "f"))) != null) {
if (patternIndex.carriage && tslib_1.__classPrivateFieldGet(this, _LineDecoder_carriageReturnIndex, "f") == null) {
tslib_1.__classPrivateFieldSet(this, _LineDecoder_carriageReturnIndex, patternIndex.index, "f");
continue;
}
if (tslib_1.__classPrivateFieldGet(this, _LineDecoder_carriageReturnIndex, "f") != null && (patternIndex.index !== tslib_1.__classPrivateFieldGet(this, _LineDecoder_carriageReturnIndex, "f") + 1 || patternIndex.carriage)) {
lines.push((0, bytes_1.decodeUTF8)(tslib_1.__classPrivateFieldGet(this, _LineDecoder_buffer, "f").subarray(0, tslib_1.__classPrivateFieldGet(this, _LineDecoder_carriageReturnIndex, "f") - 1)));
tslib_1.__classPrivateFieldSet(this, _LineDecoder_buffer, tslib_1.__classPrivateFieldGet(this, _LineDecoder_buffer, "f").subarray(tslib_1.__classPrivateFieldGet(this, _LineDecoder_carriageReturnIndex, "f")), "f");
tslib_1.__classPrivateFieldSet(this, _LineDecoder_carriageReturnIndex, null, "f");
continue;
}
const endIndex = tslib_1.__classPrivateFieldGet(this, _LineDecoder_carriageReturnIndex, "f") !== null ? patternIndex.preceding - 1 : patternIndex.preceding;
const line = (0, bytes_1.decodeUTF8)(tslib_1.__classPrivateFieldGet(this, _LineDecoder_buffer, "f").subarray(0, endIndex));
lines.push(line);
tslib_1.__classPrivateFieldSet(this, _LineDecoder_buffer, tslib_1.__classPrivateFieldGet(this, _LineDecoder_buffer, "f").subarray(patternIndex.index), "f");
tslib_1.__classPrivateFieldSet(this, _LineDecoder_carriageReturnIndex, null, "f");
}
return lines;
}
flush() {
if (!tslib_1.__classPrivateFieldGet(this, _LineDecoder_buffer, "f").length) {
return [];
}
return this.decode("\n");
}
};
exports2.LineDecoder = LineDecoder;
_LineDecoder_buffer = /* @__PURE__ */ new WeakMap(), _LineDecoder_carriageReturnIndex = /* @__PURE__ */ new WeakMap();
LineDecoder