From 1cd7e7545ff33a4212c8fb4f6ed4eb2325d64150 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=BB=8E=E4=BC=9F=E6=9D=B0?= <674416404@qq.com> Date: Fri, 16 Oct 2026 10:30:14 +0800 Subject: [PATCH] feat: add ai-translate action MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 调用 OpenAI 兼容 API 翻译文本，输出 translated-text - 支持自定义 prompt 模板（{targetLang}/{sourceText} 占位符） - 支持标题头 title（原样输出不翻译） - 提供 issue-number 时自动发评论并输出 comment-id --- README.md | 1 + actions/ai-translate/action.yml | 54 + actions/ai-translate/dist/index.mjs | 40975 ++++++++++++++++++++++++ actions/ai-translate/index.ts | 6 + actions/ai-translate/main.test.ts | 236 + actions/ai-translate/main.ts | 136 + actions/ai-translate/package.json | 17 + actions/ai-translate/tsdown.config.ts | 29 + pnpm-lock.yaml | 50 + pnpm-workspace.yaml | 1 + 10 files changed, 41505 insertions(+) create mode 100644 actions/ai-translate/action.yml create mode 100644 actions/ai-translate/dist/index.mjs create mode 100644 actions/ai-translate/index.ts create mode 100644 actions/ai-translate/main.test.ts create mode 100644 actions/ai-translate/main.ts create mode 100644 actions/ai-translate/package.json create mode 100644 actions/ai-translate/tsdown.config.ts diff --git a/README.md b/README.md index c908bed..b543981 100644 --- a/README.md +++ b/README.md @@ -14,6 +14,7 @@ TDesign 共享的 GitHub Actions 工作流。 | Action | 说明 | |--------|------| +| `ai-translate` | 调用 OpenAI 兼容 API 翻译文本，输出 `translated-text`，支持自定义 prompt 模板、标题头，提供 `issue-number` 时自动发评论并输出 `comment-id` | | `check-email` | 检查 commit 邮箱是否符合规范（不能是 @tencent.com） | | `close-release-issue` | 合并 release 分支时关闭带有特定标签的 issues | | `cnb-delete-branch` | 删除 CNB 分支前先关闭关联的 PR | diff --git a/actions/ai-translate/action.yml b/actions/ai-translate/action.yml new file mode 100644 index 0000000..d65ccf1 --- /dev/null +++ b/actions/ai-translate/action.yml @@ -0,0 +1,54 @@ +name: AI Translate +description: Translate text with an OpenAI-compatible LLM API and optionally post it as a comment + +branding: + icon: globe + color: blue + +inputs: + api-key: + description: API key for the LLM provider + required: true + base-url: + description: OpenAI-compatible API base URL + required: false + default: https://tokenhub.tencentmaas.com/v1 + model: + description: Model name used for translation + required: false + default: hy-mt2-plus + target-lang: + description: Target language, e.g. 英语 + required: true + source-text: + description: Text to translate + required: true + prompt: + description: Custom prompt template. Supports {targetLang} and {sourceText} placeholders; source text is appended when no placeholder is used + required: false + title: + description: Title heading prepended to the translated text, e.g. 会议确认. Output as-is without translation + required: false + issue-number: + description: Issue or pull request number to post the result as a comment. Skip commenting when not provided + required: false + token: + description: GitHub token used for commenting + required: false + default: ${{ github.token }} + owner: + description: Repository owner for commenting. Defaults to the current repository owner + required: false + repo: + description: Repository name for commenting. Defaults to the current repository name + required: false + +outputs: + translated-text: + description: Translated text, prefixed with the title heading when title is provided + comment-id: + description: Created comment ID. Empty when issue-number is not provided + +runs: + using: node24 + main: dist/index.mjs diff --git a/actions/ai-translate/dist/index.mjs b/actions/ai-translate/dist/index.mjs new file mode 100644 index 0000000..9fb0d79 --- /dev/null +++ b/actions/ai-translate/dist/index.mjs @@ -0,0 +1,40975 @@ +import { createRequire } from "node:module"; +import * as os$1 from "os"; +import os, { EOL } from "os"; +import * as crypto$1 from "crypto"; +import * as fs from "fs"; +import { constants, existsSync, promises, readFileSync } from "fs"; +import "path"; +import * as events from "events"; +import "child_process"; +import "timers"; +//#region \0rolldown/runtime.js +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports); +var __exportAll = (all, no_symbols) => { + let target = {}; + for (var name in all) __defProp(target, name, { + get: all[name], + enumerable: true + }); + if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" }); + return target; +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) { + key = keys[i]; + if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, { + get: ((k) => from[k]).bind(null, key), + enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable + }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { + value: mod, + enumerable: true +}) : target, mod)); +var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))(); +//#endregion +//#region ../../node_modules/.pnpm/@actions+core@3.0.1/node_modules/@actions/core/lib/utils.js +/** +* Sanitizes an input into a string so it can be passed into issueCommand safely +* @param input input to sanitize into a string +*/ +function toCommandValue(input) { + if (input === null || input === void 0) return ""; + else if (typeof input === "string" || input instanceof String) return input; + return JSON.stringify(input); +} +/** +* +* @param annotationProperties +* @returns The command properties to send with the actual annotation command +* See IssueCommandProperties: https://github.com/actions/runner/blob/main/src/Runner.Worker/ActionCommandManager.cs#L646 +*/ +function toCommandProperties(annotationProperties) { + if (!Object.keys(annotationProperties).length) return {}; + return { + title: annotationProperties.title, + file: annotationProperties.file, + line: annotationProperties.startLine, + endLine: annotationProperties.endLine, + col: annotationProperties.startColumn, + endColumn: annotationProperties.endColumn + }; +} +//#endregion +//#region ../../node_modules/.pnpm/@actions+core@3.0.1/node_modules/@actions/core/lib/command.js +/** +* Issues a command to the GitHub Actions runner +* +* @param command - The command name to issue +* @param properties - Additional properties for the command (key-value pairs) +* @param message - The message to include with the command +* @remarks +* This function outputs a specially formatted string to stdout that the Actions +* runner interprets as a command. These commands can control workflow behavior, +* set outputs, create annotations, mask values, and more. +* +* Command Format: +* ::name key=value,key=value::message +* +* @example +* ```typescript +* // Issue a warning annotation +* issueCommand('warning', {}, 'This is a warning message'); +* // Output: ::warning::This is a warning message +* +* // Set an environment variable +* issueCommand('set-env', { name: 'MY_VAR' }, 'some value'); +* // Output: ::set-env name=MY_VAR::some value +* +* // Add a secret mask +* issueCommand('add-mask', {}, 'secretValue123'); +* // Output: ::add-mask::secretValue123 +* ``` +* +* @internal +* This is an internal utility function that powers the public API functions +* such as setSecret, warning, error, and exportVariable. +*/ +function issueCommand(command, properties, message) { + const cmd = new Command(command, properties, message); + process.stdout.write(cmd.toString() + os$1.EOL); +} +function issue(name, message = "") { + issueCommand(name, {}, message); +} +const CMD_STRING = "::"; +var Command = class { + constructor(command, properties, message) { + if (!command) command = "missing.command"; + this.command = command; + this.properties = properties; + this.message = message; + } + toString() { + let cmdStr = CMD_STRING + this.command; + if (this.properties && Object.keys(this.properties).length > 0) { + cmdStr += " "; + let first = true; + for (const key in this.properties) if (this.properties.hasOwnProperty(key)) { + const val = this.properties[key]; + if (val) { + if (first) first = false; + else cmdStr += ","; + cmdStr += `${key}=${escapeProperty(val)}`; + } + } + } + cmdStr += `${CMD_STRING}${escapeData(this.message)}`; + return cmdStr; + } +}; +function escapeData(s) { + return toCommandValue(s).replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A"); +} +function escapeProperty(s) { + return toCommandValue(s).replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A").replace(/:/g, "%3A").replace(/,/g, "%2C"); +} +//#endregion +//#region ../../node_modules/.pnpm/@actions+core@3.0.1/node_modules/@actions/core/lib/file-command.js +function issueFileCommand(command, message) { + const filePath = process.env[`GITHUB_${command}`]; + if (!filePath) throw new Error(`Unable to find environment variable for file command ${command}`); + if (!fs.existsSync(filePath)) throw new Error(`Missing file at path: ${filePath}`); + fs.appendFileSync(filePath, `${toCommandValue(message)}${os$1.EOL}`, { encoding: "utf8" }); +} +function prepareKeyValueMessage(key, value) { + const delimiter = `ghadelimiter_${crypto$1.randomUUID()}`; + const convertedValue = toCommandValue(value); + if (key.includes(delimiter)) throw new Error(`Unexpected input: name should not contain the delimiter "${delimiter}"`); + if (convertedValue.includes(delimiter)) throw new Error(`Unexpected input: value should not contain the delimiter "${delimiter}"`); + return `${key}<<${delimiter}${os$1.EOL}${convertedValue}${os$1.EOL}${delimiter}`; +} +//#endregion +//#region ../../node_modules/.pnpm/tunnel@0.0.6/node_modules/tunnel/lib/tunnel.js +var require_tunnel$1 = /* @__PURE__ */ __commonJSMin(((exports) => { + __require("net"); + var tls = __require("tls"); + var http$2 = __require("http"); + var https$1 = __require("https"); + var events$1 = __require("events"); + __require("assert"); + var util$2 = __require("util"); + exports.httpOverHttp = httpOverHttp; + exports.httpsOverHttp = httpsOverHttp; + exports.httpOverHttps = httpOverHttps; + exports.httpsOverHttps = httpsOverHttps; + function httpOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http$2.request; + return agent; + } + function httpsOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http$2.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; + } + function httpOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https$1.request; + return agent; + } + function httpsOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https$1.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; + } + function TunnelingAgent(options) { + var self = this; + self.options = options || {}; + self.proxyOptions = self.options.proxy || {}; + self.maxSockets = self.options.maxSockets || http$2.Agent.defaultMaxSockets; + self.requests = []; + self.sockets = []; + self.on("free", function onFree(socket, host, port, localAddress) { + var options = toOptions(host, port, localAddress); + for (var i = 0, len = self.requests.length; i < len; ++i) { + var pending = self.requests[i]; + if (pending.host === options.host && pending.port === options.port) { + self.requests.splice(i, 1); + pending.request.onSocket(socket); + return; + } + } + socket.destroy(); + self.removeSocket(socket); + }); + } + util$2.inherits(TunnelingAgent, events$1.EventEmitter); + TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) { + var self = this; + var options = mergeOptions({ request: req }, self.options, toOptions(host, port, localAddress)); + if (self.sockets.length >= this.maxSockets) { + self.requests.push(options); + return; + } + self.createSocket(options, function(socket) { + socket.on("free", onFree); + socket.on("close", onCloseOrRemove); + socket.on("agentRemove", onCloseOrRemove); + req.onSocket(socket); + function onFree() { + self.emit("free", socket, options); + } + function onCloseOrRemove(err) { + self.removeSocket(socket); + socket.removeListener("free", onFree); + socket.removeListener("close", onCloseOrRemove); + socket.removeListener("agentRemove", onCloseOrRemove); + } + }); + }; + TunnelingAgent.prototype.createSocket = function createSocket(options, cb) { + var self = this; + var placeholder = {}; + self.sockets.push(placeholder); + var connectOptions = mergeOptions({}, self.proxyOptions, { + method: "CONNECT", + path: options.host + ":" + options.port, + agent: false, + headers: { host: options.host + ":" + options.port } + }); + if (options.localAddress) connectOptions.localAddress = options.localAddress; + if (connectOptions.proxyAuth) { + connectOptions.headers = connectOptions.headers || {}; + connectOptions.headers["Proxy-Authorization"] = "Basic " + new Buffer(connectOptions.proxyAuth).toString("base64"); + } + debug("making CONNECT request"); + var connectReq = self.request(connectOptions); + connectReq.useChunkedEncodingByDefault = false; + connectReq.once("response", onResponse); + connectReq.once("upgrade", onUpgrade); + connectReq.once("connect", onConnect); + connectReq.once("error", onError); + connectReq.end(); + function onResponse(res) { + res.upgrade = true; + } + function onUpgrade(res, socket, head) { + process.nextTick(function() { + onConnect(res, socket, head); + }); + } + function onConnect(res, socket, head) { + connectReq.removeAllListeners(); + socket.removeAllListeners(); + if (res.statusCode !== 200) { + debug("tunneling socket could not be established, statusCode=%d", res.statusCode); + socket.destroy(); + var error = /* @__PURE__ */ new Error("tunneling socket could not be established, statusCode=" + res.statusCode); + error.code = "ECONNRESET"; + options.request.emit("error", error); + self.removeSocket(placeholder); + return; + } + if (head.length > 0) { + debug("got illegal response body from proxy"); + socket.destroy(); + var error = /* @__PURE__ */ new Error("got illegal response body from proxy"); + error.code = "ECONNRESET"; + options.request.emit("error", error); + self.removeSocket(placeholder); + return; + } + debug("tunneling connection has established"); + self.sockets[self.sockets.indexOf(placeholder)] = socket; + return cb(socket); + } + function onError(cause) { + connectReq.removeAllListeners(); + debug("tunneling socket could not be established, cause=%s\n", cause.message, cause.stack); + var error = /* @__PURE__ */ new Error("tunneling socket could not be established, cause=" + cause.message); + error.code = "ECONNRESET"; + options.request.emit("error", error); + self.removeSocket(placeholder); + } + }; + TunnelingAgent.prototype.removeSocket = function removeSocket(socket) { + var pos = this.sockets.indexOf(socket); + if (pos === -1) return; + this.sockets.splice(pos, 1); + var pending = this.requests.shift(); + if (pending) this.createSocket(pending, function(socket) { + pending.request.onSocket(socket); + }); + }; + function createSecureSocket(options, cb) { + var self = this; + TunnelingAgent.prototype.createSocket.call(self, options, function(socket) { + var hostHeader = options.request.getHeader("host"); + var tlsOptions = mergeOptions({}, self.options, { + socket, + servername: hostHeader ? hostHeader.replace(/:.*$/, "") : options.host + }); + var secureSocket = tls.connect(0, tlsOptions); + self.sockets[self.sockets.indexOf(socket)] = secureSocket; + cb(secureSocket); + }); + } + function toOptions(host, port, localAddress) { + if (typeof host === "string") return { + host, + port, + localAddress + }; + return host; + } + function mergeOptions(target) { + for (var i = 1, len = arguments.length; i < len; ++i) { + var overrides = arguments[i]; + if (typeof overrides === "object") { + var keys = Object.keys(overrides); + for (var j = 0, keyLen = keys.length; j < keyLen; ++j) { + var k = keys[j]; + if (overrides[k] !== void 0) target[k] = overrides[k]; + } + } + } + return target; + } + var debug; + if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) debug = function() { + var args = Array.prototype.slice.call(arguments); + if (typeof args[0] === "string") args[0] = "TUNNEL: " + args[0]; + else args.unshift("TUNNEL:"); + console.error.apply(console, args); + }; + else debug = function() {}; + exports.debug = debug; +})); +//#endregion +//#region ../../node_modules/.pnpm/tunnel@0.0.6/node_modules/tunnel/index.js +var require_tunnel = /* @__PURE__ */ __commonJSMin(((exports, module) => { + module.exports = require_tunnel$1(); +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/core/symbols.js +var require_symbols$4 = /* @__PURE__ */ __commonJSMin(((exports, module) => { + module.exports = { + kClose: Symbol("close"), + kDestroy: Symbol("destroy"), + kDispatch: Symbol("dispatch"), + kUrl: Symbol("url"), + kWriting: Symbol("writing"), + kResuming: Symbol("resuming"), + kQueue: Symbol("queue"), + kConnect: Symbol("connect"), + kConnecting: Symbol("connecting"), + kKeepAliveDefaultTimeout: Symbol("default keep alive timeout"), + kKeepAliveMaxTimeout: Symbol("max keep alive timeout"), + kKeepAliveTimeoutThreshold: Symbol("keep alive timeout threshold"), + kKeepAliveTimeoutValue: Symbol("keep alive timeout"), + kKeepAlive: Symbol("keep alive"), + kHeadersTimeout: Symbol("headers timeout"), + kBodyTimeout: Symbol("body timeout"), + kServerName: Symbol("server name"), + kLocalAddress: Symbol("local address"), + kHost: Symbol("host"), + kNoRef: Symbol("no ref"), + kBodyUsed: Symbol("used"), + kBody: Symbol("abstracted request body"), + kRunning: Symbol("running"), + kBlocking: Symbol("blocking"), + kPending: Symbol("pending"), + kSize: Symbol("size"), + kBusy: Symbol("busy"), + kQueued: Symbol("queued"), + kFree: Symbol("free"), + kConnected: Symbol("connected"), + kClosed: Symbol("closed"), + kNeedDrain: Symbol("need drain"), + kReset: Symbol("reset"), + kDestroyed: Symbol.for("nodejs.stream.destroyed"), + kResume: Symbol("resume"), + kOnError: Symbol("on error"), + kMaxHeadersSize: Symbol("max headers size"), + kRunningIdx: Symbol("running index"), + kPendingIdx: Symbol("pending index"), + kError: Symbol("error"), + kClients: Symbol("clients"), + kClient: Symbol("client"), + kParser: Symbol("parser"), + kOnDestroyed: Symbol("destroy callbacks"), + kPipelining: Symbol("pipelining"), + kSocket: Symbol("socket"), + kHostHeader: Symbol("host header"), + kConnector: Symbol("connector"), + kStrictContentLength: Symbol("strict content length"), + kMaxRedirections: Symbol("maxRedirections"), + kMaxRequests: Symbol("maxRequestsPerClient"), + kProxy: Symbol("proxy agent options"), + kCounter: Symbol("socket request counter"), + kInterceptors: Symbol("dispatch interceptors"), + kMaxResponseSize: Symbol("max response size"), + kHTTP2Session: Symbol("http2Session"), + kHTTP2SessionState: Symbol("http2Session state"), + kRetryHandlerDefaultRetry: Symbol("retry agent default retry"), + kConstruct: Symbol("constructable"), + kListeners: Symbol("listeners"), + kHTTPContext: Symbol("http context"), + kMaxConcurrentStreams: Symbol("max concurrent streams"), + kNoProxyAgent: Symbol("no proxy agent"), + kHttpProxyAgent: Symbol("http proxy agent"), + kHttpsProxyAgent: Symbol("https proxy agent") + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/core/errors.js +var require_errors = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const kUndiciError = Symbol.for("undici.error.UND_ERR"); + var UndiciError = class extends Error { + constructor(message) { + super(message); + this.name = "UndiciError"; + this.code = "UND_ERR"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kUndiciError] === true; + } + [kUndiciError] = true; + }; + const kConnectTimeoutError = Symbol.for("undici.error.UND_ERR_CONNECT_TIMEOUT"); + var ConnectTimeoutError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "ConnectTimeoutError"; + this.message = message || "Connect Timeout Error"; + this.code = "UND_ERR_CONNECT_TIMEOUT"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kConnectTimeoutError] === true; + } + [kConnectTimeoutError] = true; + }; + const kHeadersTimeoutError = Symbol.for("undici.error.UND_ERR_HEADERS_TIMEOUT"); + var HeadersTimeoutError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "HeadersTimeoutError"; + this.message = message || "Headers Timeout Error"; + this.code = "UND_ERR_HEADERS_TIMEOUT"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kHeadersTimeoutError] === true; + } + [kHeadersTimeoutError] = true; + }; + const kHeadersOverflowError = Symbol.for("undici.error.UND_ERR_HEADERS_OVERFLOW"); + var HeadersOverflowError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "HeadersOverflowError"; + this.message = message || "Headers Overflow Error"; + this.code = "UND_ERR_HEADERS_OVERFLOW"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kHeadersOverflowError] === true; + } + [kHeadersOverflowError] = true; + }; + const kBodyTimeoutError = Symbol.for("undici.error.UND_ERR_BODY_TIMEOUT"); + var BodyTimeoutError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "BodyTimeoutError"; + this.message = message || "Body Timeout Error"; + this.code = "UND_ERR_BODY_TIMEOUT"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kBodyTimeoutError] === true; + } + [kBodyTimeoutError] = true; + }; + const kResponseStatusCodeError = Symbol.for("undici.error.UND_ERR_RESPONSE_STATUS_CODE"); + var ResponseStatusCodeError = class extends UndiciError { + constructor(message, statusCode, headers, body) { + super(message); + this.name = "ResponseStatusCodeError"; + this.message = message || "Response Status Code Error"; + this.code = "UND_ERR_RESPONSE_STATUS_CODE"; + this.body = body; + this.status = statusCode; + this.statusCode = statusCode; + this.headers = headers; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kResponseStatusCodeError] === true; + } + [kResponseStatusCodeError] = true; + }; + const kInvalidArgumentError = Symbol.for("undici.error.UND_ERR_INVALID_ARG"); + var InvalidArgumentError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "InvalidArgumentError"; + this.message = message || "Invalid Argument Error"; + this.code = "UND_ERR_INVALID_ARG"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kInvalidArgumentError] === true; + } + [kInvalidArgumentError] = true; + }; + const kInvalidReturnValueError = Symbol.for("undici.error.UND_ERR_INVALID_RETURN_VALUE"); + var InvalidReturnValueError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "InvalidReturnValueError"; + this.message = message || "Invalid Return Value Error"; + this.code = "UND_ERR_INVALID_RETURN_VALUE"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kInvalidReturnValueError] === true; + } + [kInvalidReturnValueError] = true; + }; + const kAbortError = Symbol.for("undici.error.UND_ERR_ABORT"); + var AbortError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "AbortError"; + this.message = message || "The operation was aborted"; + this.code = "UND_ERR_ABORT"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kAbortError] === true; + } + [kAbortError] = true; + }; + const kRequestAbortedError = Symbol.for("undici.error.UND_ERR_ABORTED"); + var RequestAbortedError = class extends AbortError { + constructor(message) { + super(message); + this.name = "AbortError"; + this.message = message || "Request aborted"; + this.code = "UND_ERR_ABORTED"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kRequestAbortedError] === true; + } + [kRequestAbortedError] = true; + }; + const kInformationalError = Symbol.for("undici.error.UND_ERR_INFO"); + var InformationalError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "InformationalError"; + this.message = message || "Request information"; + this.code = "UND_ERR_INFO"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kInformationalError] === true; + } + [kInformationalError] = true; + }; + const kRequestContentLengthMismatchError = Symbol.for("undici.error.UND_ERR_REQ_CONTENT_LENGTH_MISMATCH"); + var RequestContentLengthMismatchError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "RequestContentLengthMismatchError"; + this.message = message || "Request body length does not match content-length header"; + this.code = "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kRequestContentLengthMismatchError] === true; + } + [kRequestContentLengthMismatchError] = true; + }; + const kResponseContentLengthMismatchError = Symbol.for("undici.error.UND_ERR_RES_CONTENT_LENGTH_MISMATCH"); + var ResponseContentLengthMismatchError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "ResponseContentLengthMismatchError"; + this.message = message || "Response body length does not match content-length header"; + this.code = "UND_ERR_RES_CONTENT_LENGTH_MISMATCH"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kResponseContentLengthMismatchError] === true; + } + [kResponseContentLengthMismatchError] = true; + }; + const kClientDestroyedError = Symbol.for("undici.error.UND_ERR_DESTROYED"); + var ClientDestroyedError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "ClientDestroyedError"; + this.message = message || "The client is destroyed"; + this.code = "UND_ERR_DESTROYED"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kClientDestroyedError] === true; + } + [kClientDestroyedError] = true; + }; + const kClientClosedError = Symbol.for("undici.error.UND_ERR_CLOSED"); + var ClientClosedError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "ClientClosedError"; + this.message = message || "The client is closed"; + this.code = "UND_ERR_CLOSED"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kClientClosedError] === true; + } + [kClientClosedError] = true; + }; + const kSocketError = Symbol.for("undici.error.UND_ERR_SOCKET"); + var SocketError = class extends UndiciError { + constructor(message, socket) { + super(message); + this.name = "SocketError"; + this.message = message || "Socket error"; + this.code = "UND_ERR_SOCKET"; + this.socket = socket; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kSocketError] === true; + } + [kSocketError] = true; + }; + const kNotSupportedError = Symbol.for("undici.error.UND_ERR_NOT_SUPPORTED"); + var NotSupportedError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "NotSupportedError"; + this.message = message || "Not supported error"; + this.code = "UND_ERR_NOT_SUPPORTED"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kNotSupportedError] === true; + } + [kNotSupportedError] = true; + }; + const kBalancedPoolMissingUpstreamError = Symbol.for("undici.error.UND_ERR_BPL_MISSING_UPSTREAM"); + var BalancedPoolMissingUpstreamError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "MissingUpstreamError"; + this.message = message || "No upstream has been added to the BalancedPool"; + this.code = "UND_ERR_BPL_MISSING_UPSTREAM"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kBalancedPoolMissingUpstreamError] === true; + } + [kBalancedPoolMissingUpstreamError] = true; + }; + const kHTTPParserError = Symbol.for("undici.error.UND_ERR_HTTP_PARSER"); + var HTTPParserError = class extends Error { + constructor(message, code, data) { + super(message); + this.name = "HTTPParserError"; + this.code = code ? `HPE_${code}` : void 0; + this.data = data ? data.toString() : void 0; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kHTTPParserError] === true; + } + [kHTTPParserError] = true; + }; + const kResponseExceededMaxSizeError = Symbol.for("undici.error.UND_ERR_RES_EXCEEDED_MAX_SIZE"); + var ResponseExceededMaxSizeError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "ResponseExceededMaxSizeError"; + this.message = message || "Response content exceeded max size"; + this.code = "UND_ERR_RES_EXCEEDED_MAX_SIZE"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kResponseExceededMaxSizeError] === true; + } + [kResponseExceededMaxSizeError] = true; + }; + const kRequestRetryError = Symbol.for("undici.error.UND_ERR_REQ_RETRY"); + var RequestRetryError = class extends UndiciError { + constructor(message, code, { headers, data }) { + super(message); + this.name = "RequestRetryError"; + this.message = message || "Request retry error"; + this.code = "UND_ERR_REQ_RETRY"; + this.statusCode = code; + this.data = data; + this.headers = headers; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kRequestRetryError] === true; + } + [kRequestRetryError] = true; + }; + const kResponseError = Symbol.for("undici.error.UND_ERR_RESPONSE"); + var ResponseError = class extends UndiciError { + constructor(message, code, { headers, data }) { + super(message); + this.name = "ResponseError"; + this.message = message || "Response error"; + this.code = "UND_ERR_RESPONSE"; + this.statusCode = code; + this.data = data; + this.headers = headers; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kResponseError] === true; + } + [kResponseError] = true; + }; + const kSecureProxyConnectionError = Symbol.for("undici.error.UND_ERR_PRX_TLS"); + var SecureProxyConnectionError = class extends UndiciError { + constructor(cause, message, options) { + super(message, { + cause, + ...options ?? {} + }); + this.name = "SecureProxyConnectionError"; + this.message = message || "Secure Proxy Connection failed"; + this.code = "UND_ERR_PRX_TLS"; + this.cause = cause; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kSecureProxyConnectionError] === true; + } + [kSecureProxyConnectionError] = true; + }; + module.exports = { + AbortError, + HTTPParserError, + UndiciError, + HeadersTimeoutError, + HeadersOverflowError, + BodyTimeoutError, + RequestContentLengthMismatchError, + ConnectTimeoutError, + ResponseStatusCodeError, + InvalidArgumentError, + InvalidReturnValueError, + RequestAbortedError, + ClientDestroyedError, + ClientClosedError, + InformationalError, + SocketError, + NotSupportedError, + ResponseContentLengthMismatchError, + BalancedPoolMissingUpstreamError, + ResponseExceededMaxSizeError, + RequestRetryError, + ResponseError, + SecureProxyConnectionError + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/core/constants.js +var require_constants$4 = /* @__PURE__ */ __commonJSMin(((exports, module) => { + /** @type {Record} */ + const headerNameLowerCasedRecord = {}; + const wellknownHeaderNames = [ + "Accept", + "Accept-Encoding", + "Accept-Language", + "Accept-Ranges", + "Access-Control-Allow-Credentials", + "Access-Control-Allow-Headers", + "Access-Control-Allow-Methods", + "Access-Control-Allow-Origin", + "Access-Control-Expose-Headers", + "Access-Control-Max-Age", + "Access-Control-Request-Headers", + "Access-Control-Request-Method", + "Age", + "Allow", + "Alt-Svc", + "Alt-Used", + "Authorization", + "Cache-Control", + "Clear-Site-Data", + "Connection", + "Content-Disposition", + "Content-Encoding", + "Content-Language", + "Content-Length", + "Content-Location", + "Content-Range", + "Content-Security-Policy", + "Content-Security-Policy-Report-Only", + "Content-Type", + "Cookie", + "Cross-Origin-Embedder-Policy", + "Cross-Origin-Opener-Policy", + "Cross-Origin-Resource-Policy", + "Date", + "Device-Memory", + "Downlink", + "ECT", + "ETag", + "Expect", + "Expect-CT", + "Expires", + "Forwarded", + "From", + "Host", + "If-Match", + "If-Modified-Since", + "If-None-Match", + "If-Range", + "If-Unmodified-Since", + "Keep-Alive", + "Last-Modified", + "Link", + "Location", + "Max-Forwards", + "Origin", + "Permissions-Policy", + "Pragma", + "Proxy-Authenticate", + "Proxy-Authorization", + "RTT", + "Range", + "Referer", + "Referrer-Policy", + "Refresh", + "Retry-After", + "Sec-WebSocket-Accept", + "Sec-WebSocket-Extensions", + "Sec-WebSocket-Key", + "Sec-WebSocket-Protocol", + "Sec-WebSocket-Version", + "Server", + "Server-Timing", + "Service-Worker-Allowed", + "Service-Worker-Navigation-Preload", + "Set-Cookie", + "SourceMap", + "Strict-Transport-Security", + "Supports-Loading-Mode", + "TE", + "Timing-Allow-Origin", + "Trailer", + "Transfer-Encoding", + "Upgrade", + "Upgrade-Insecure-Requests", + "User-Agent", + "Vary", + "Via", + "WWW-Authenticate", + "X-Content-Type-Options", + "X-DNS-Prefetch-Control", + "X-Frame-Options", + "X-Permitted-Cross-Domain-Policies", + "X-Powered-By", + "X-Requested-With", + "X-XSS-Protection" + ]; + for (let i = 0; i < wellknownHeaderNames.length; ++i) { + const key = wellknownHeaderNames[i]; + const lowerCasedKey = key.toLowerCase(); + headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] = lowerCasedKey; + } + Object.setPrototypeOf(headerNameLowerCasedRecord, null); + module.exports = { + wellknownHeaderNames, + headerNameLowerCasedRecord + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/core/tree.js +var require_tree = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { wellknownHeaderNames, headerNameLowerCasedRecord } = require_constants$4(); + var TstNode = class TstNode { + /** @type {any} */ + value = null; + /** @type {null | TstNode} */ + left = null; + /** @type {null | TstNode} */ + middle = null; + /** @type {null | TstNode} */ + right = null; + /** @type {number} */ + code; + /** + * @param {string} key + * @param {any} value + * @param {number} index + */ + constructor(key, value, index) { + if (index === void 0 || index >= key.length) throw new TypeError("Unreachable"); + if ((this.code = key.charCodeAt(index)) > 127) throw new TypeError("key must be ascii string"); + if (key.length !== ++index) this.middle = new TstNode(key, value, index); + else this.value = value; + } + /** + * @param {string} key + * @param {any} value + */ + add(key, value) { + const length = key.length; + if (length === 0) throw new TypeError("Unreachable"); + let index = 0; + let node = this; + while (true) { + const code = key.charCodeAt(index); + if (code > 127) throw new TypeError("key must be ascii string"); + if (node.code === code) { + if (length === ++index) { + node.value = value; + break; + } else if (node.middle !== null) node = node.middle; + else { + node.middle = new TstNode(key, value, index); + break; + } + } else if (node.code < code) { + if (node.left !== null) node = node.left; + else { + node.left = new TstNode(key, value, index); + break; + } + } else if (node.right !== null) node = node.right; + else { + node.right = new TstNode(key, value, index); + break; + } + } + } + /** + * @param {Uint8Array} key + * @return {TstNode | null} + */ + search(key) { + const keylength = key.length; + let index = 0; + let node = this; + while (node !== null && index < keylength) { + let code = key[index]; + if (code <= 90 && code >= 65) code |= 32; + while (node !== null) { + if (code === node.code) { + if (keylength === ++index) return node; + node = node.middle; + break; + } + node = node.code < code ? node.left : node.right; + } + } + return null; + } + }; + var TernarySearchTree = class { + /** @type {TstNode | null} */ + node = null; + /** + * @param {string} key + * @param {any} value + * */ + insert(key, value) { + if (this.node === null) this.node = new TstNode(key, value, 0); + else this.node.add(key, value); + } + /** + * @param {Uint8Array} key + * @return {any} + */ + lookup(key) { + return this.node?.search(key)?.value ?? null; + } + }; + const tree = new TernarySearchTree(); + for (let i = 0; i < wellknownHeaderNames.length; ++i) { + const key = headerNameLowerCasedRecord[wellknownHeaderNames[i]]; + tree.insert(key, key); + } + module.exports = { + TernarySearchTree, + tree + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/core/util.js +var require_util$7 = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const assert$26 = __require("node:assert"); + const { kDestroyed, kBodyUsed, kListeners, kBody } = require_symbols$4(); + const { IncomingMessage } = __require("node:http"); + const stream = __require("node:stream"); + const net$2 = __require("node:net"); + const { Blob: Blob$3 } = __require("node:buffer"); + const nodeUtil$3 = __require("node:util"); + const { stringify: stringify$1 } = __require("node:querystring"); + const { EventEmitter: EE$2 } = __require("node:events"); + const { InvalidArgumentError } = require_errors(); + const { headerNameLowerCasedRecord } = require_constants$4(); + const { tree } = require_tree(); + const [nodeMajor, nodeMinor] = process.versions.node.split(".").map((v) => Number(v)); + var BodyAsyncIterable = class { + constructor(body) { + this[kBody] = body; + this[kBodyUsed] = false; + } + async *[Symbol.asyncIterator]() { + assert$26(!this[kBodyUsed], "disturbed"); + this[kBodyUsed] = true; + yield* this[kBody]; + } + }; + function wrapRequestBody(body) { + if (isStream(body)) { + if (bodyLength(body) === 0) body.on("data", function() { + assert$26(false); + }); + if (typeof body.readableDidRead !== "boolean") { + body[kBodyUsed] = false; + EE$2.prototype.on.call(body, "data", function() { + this[kBodyUsed] = true; + }); + } + return body; + } else if (body && typeof body.pipeTo === "function") return new BodyAsyncIterable(body); + else if (body && typeof body !== "string" && !ArrayBuffer.isView(body) && isIterable(body)) return new BodyAsyncIterable(body); + else return body; + } + function nop() {} + function isStream(obj) { + return obj && typeof obj === "object" && typeof obj.pipe === "function" && typeof obj.on === "function"; + } + function isBlobLike(object) { + if (object === null) return false; + else if (object instanceof Blob$3) return true; + else if (typeof object !== "object") return false; + else { + const sTag = object[Symbol.toStringTag]; + return (sTag === "Blob" || sTag === "File") && ("stream" in object && typeof object.stream === "function" || "arrayBuffer" in object && typeof object.arrayBuffer === "function"); + } + } + function buildURL(url, queryParams) { + if (url.includes("?") || url.includes("#")) throw new Error("Query params cannot be passed when url already contains \"?\" or \"#\"."); + const stringified = stringify$1(queryParams); + if (stringified) url += "?" + stringified; + return url; + } + function isValidPort(port) { + const value = parseInt(port, 10); + return value === Number(port) && value >= 0 && value <= 65535; + } + function isHttpOrHttpsPrefixed(value) { + return value != null && value[0] === "h" && value[1] === "t" && value[2] === "t" && value[3] === "p" && (value[4] === ":" || value[4] === "s" && value[5] === ":"); + } + function parseURL(url) { + if (typeof url === "string") { + url = new URL(url); + if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`."); + return url; + } + if (!url || typeof url !== "object") throw new InvalidArgumentError("Invalid URL: The URL argument must be a non-null object."); + if (!(url instanceof URL)) { + if (url.port != null && url.port !== "" && isValidPort(url.port) === false) throw new InvalidArgumentError("Invalid URL: port must be a valid integer or a string representation of an integer."); + if (url.path != null && typeof url.path !== "string") throw new InvalidArgumentError("Invalid URL path: the path must be a string or null/undefined."); + if (url.pathname != null && typeof url.pathname !== "string") throw new InvalidArgumentError("Invalid URL pathname: the pathname must be a string or null/undefined."); + if (url.hostname != null && typeof url.hostname !== "string") throw new InvalidArgumentError("Invalid URL hostname: the hostname must be a string or null/undefined."); + if (url.origin != null && typeof url.origin !== "string") throw new InvalidArgumentError("Invalid URL origin: the origin must be a string or null/undefined."); + if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`."); + const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80; + let origin = url.origin != null ? url.origin : `${url.protocol || ""}//${url.hostname || ""}:${port}`; + let path = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`; + if (origin[origin.length - 1] === "/") origin = origin.slice(0, origin.length - 1); + if (path && path[0] !== "/") path = `/${path}`; + return new URL(`${origin}${path}`); + } + if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`."); + return url; + } + function parseOrigin(url) { + url = parseURL(url); + if (url.pathname !== "/" || url.search || url.hash) throw new InvalidArgumentError("invalid url"); + return url; + } + function getHostname(host) { + if (host[0] === "[") { + const idx = host.indexOf("]"); + assert$26(idx !== -1); + return host.substring(1, idx); + } + const idx = host.indexOf(":"); + if (idx === -1) return host; + return host.substring(0, idx); + } + function getServerName(host) { + if (!host) return null; + assert$26(typeof host === "string"); + const servername = getHostname(host); + if (net$2.isIP(servername)) return ""; + return servername; + } + function deepClone(obj) { + return JSON.parse(JSON.stringify(obj)); + } + function isAsyncIterable(obj) { + return !!(obj != null && typeof obj[Symbol.asyncIterator] === "function"); + } + function isIterable(obj) { + return !!(obj != null && (typeof obj[Symbol.iterator] === "function" || typeof obj[Symbol.asyncIterator] === "function")); + } + function bodyLength(body) { + if (body == null) return 0; + else if (isStream(body)) { + const state = body._readableState; + return state && state.objectMode === false && state.ended === true && Number.isFinite(state.length) ? state.length : null; + } else if (isBlobLike(body)) return body.size != null ? body.size : null; + else if (isBuffer(body)) return body.byteLength; + return null; + } + function isDestroyed(body) { + return body && !!(body.destroyed || body[kDestroyed] || stream.isDestroyed?.(body)); + } + function destroy(stream, err) { + if (stream == null || !isStream(stream) || isDestroyed(stream)) return; + if (typeof stream.destroy === "function") { + if (Object.getPrototypeOf(stream).constructor === IncomingMessage) stream.socket = null; + stream.destroy(err); + } else if (err) queueMicrotask(() => { + stream.emit("error", err); + }); + if (stream.destroyed !== true) stream[kDestroyed] = true; + } + const KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/; + function parseKeepAliveTimeout(val) { + const m = val.toString().match(KEEPALIVE_TIMEOUT_EXPR); + return m ? parseInt(m[1], 10) * 1e3 : null; + } + /** + * Retrieves a header name and returns its lowercase value. + * @param {string | Buffer} value Header name + * @returns {string} + */ + function headerNameToString(value) { + return typeof value === "string" ? headerNameLowerCasedRecord[value] ?? value.toLowerCase() : tree.lookup(value) ?? value.toString("latin1").toLowerCase(); + } + /** + * Receive the buffer as a string and return its lowercase value. + * @param {Buffer} value Header name + * @returns {string} + */ + function bufferToLowerCasedHeaderName(value) { + return tree.lookup(value) ?? value.toString("latin1").toLowerCase(); + } + /** + * @param {Record | (Buffer | string | (Buffer | string)[])[]} headers + * @param {Record} [obj] + * @returns {Record} + */ + function parseHeaders(headers, obj) { + if (obj === void 0) obj = {}; + for (let i = 0; i < headers.length; i += 2) { + const key = headerNameToString(headers[i]); + let val = obj[key]; + if (val) { + if (typeof val === "string") { + val = [val]; + obj[key] = val; + } + val.push(headers[i + 1].toString("utf8")); + } else { + const headersValue = headers[i + 1]; + if (typeof headersValue === "string") obj[key] = headersValue; + else obj[key] = Array.isArray(headersValue) ? headersValue.map((x) => x.toString("utf8")) : headersValue.toString("utf8"); + } + } + if ("content-length" in obj && "content-disposition" in obj) obj["content-disposition"] = Buffer.from(obj["content-disposition"]).toString("latin1"); + return obj; + } + function parseRawHeaders(headers) { + const len = headers.length; + const ret = new Array(len); + let hasContentLength = false; + let contentDispositionIdx = -1; + let key; + let val; + let kLen = 0; + for (let n = 0; n < headers.length; n += 2) { + key = headers[n]; + val = headers[n + 1]; + typeof key !== "string" && (key = key.toString()); + typeof val !== "string" && (val = val.toString("utf8")); + kLen = key.length; + if (kLen === 14 && key[7] === "-" && (key === "content-length" || key.toLowerCase() === "content-length")) hasContentLength = true; + else if (kLen === 19 && key[7] === "-" && (key === "content-disposition" || key.toLowerCase() === "content-disposition")) contentDispositionIdx = n + 1; + ret[n] = key; + ret[n + 1] = val; + } + if (hasContentLength && contentDispositionIdx !== -1) ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString("latin1"); + return ret; + } + function isBuffer(buffer) { + return buffer instanceof Uint8Array || Buffer.isBuffer(buffer); + } + function validateHandler(handler, method, upgrade) { + if (!handler || typeof handler !== "object") throw new InvalidArgumentError("handler must be an object"); + if (typeof handler.onConnect !== "function") throw new InvalidArgumentError("invalid onConnect method"); + if (typeof handler.onError !== "function") throw new InvalidArgumentError("invalid onError method"); + if (typeof handler.onBodySent !== "function" && handler.onBodySent !== void 0) throw new InvalidArgumentError("invalid onBodySent method"); + if (upgrade || method === "CONNECT") { + if (typeof handler.onUpgrade !== "function") throw new InvalidArgumentError("invalid onUpgrade method"); + } else { + if (typeof handler.onHeaders !== "function") throw new InvalidArgumentError("invalid onHeaders method"); + if (typeof handler.onData !== "function") throw new InvalidArgumentError("invalid onData method"); + if (typeof handler.onComplete !== "function") throw new InvalidArgumentError("invalid onComplete method"); + } + } + function isDisturbed(body) { + return !!(body && (stream.isDisturbed(body) || body[kBodyUsed])); + } + function isErrored(body) { + return !!(body && stream.isErrored(body)); + } + function isReadable(body) { + return !!(body && stream.isReadable(body)); + } + function getSocketInfo(socket) { + return { + localAddress: socket.localAddress, + localPort: socket.localPort, + remoteAddress: socket.remoteAddress, + remotePort: socket.remotePort, + remoteFamily: socket.remoteFamily, + timeout: socket.timeout, + bytesWritten: socket.bytesWritten, + bytesRead: socket.bytesRead + }; + } + /** @type {globalThis['ReadableStream']} */ + function ReadableStreamFrom(iterable) { + let iterator; + return new ReadableStream({ + async start() { + iterator = iterable[Symbol.asyncIterator](); + }, + async pull(controller) { + const { done, value } = await iterator.next(); + if (done) queueMicrotask(() => { + controller.close(); + controller.byobRequest?.respond(0); + }); + else { + const buf = Buffer.isBuffer(value) ? value : Buffer.from(value); + if (buf.byteLength) controller.enqueue(new Uint8Array(buf)); + } + return controller.desiredSize > 0; + }, + async cancel(reason) { + await iterator.return(); + }, + type: "bytes" + }); + } + function isFormDataLike(object) { + return object && typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && object[Symbol.toStringTag] === "FormData"; + } + function addAbortListener(signal, listener) { + if ("addEventListener" in signal) { + signal.addEventListener("abort", listener, { once: true }); + return () => signal.removeEventListener("abort", listener); + } + signal.addListener("abort", listener); + return () => signal.removeListener("abort", listener); + } + const hasToWellFormed = typeof String.prototype.toWellFormed === "function"; + const hasIsWellFormed = typeof String.prototype.isWellFormed === "function"; + /** + * @param {string} val + */ + function toUSVString(val) { + return hasToWellFormed ? `${val}`.toWellFormed() : nodeUtil$3.toUSVString(val); + } + /** + * @param {string} val + */ + function isUSVString(val) { + return hasIsWellFormed ? `${val}`.isWellFormed() : toUSVString(val) === `${val}`; + } + /** + * @see https://tools.ietf.org/html/rfc7230#section-3.2.6 + * @param {number} c + */ + function isTokenCharCode(c) { + switch (c) { + case 34: + case 40: + case 41: + case 44: + case 47: + case 58: + case 59: + case 60: + case 61: + case 62: + case 63: + case 64: + case 91: + case 92: + case 93: + case 123: + case 125: return false; + default: return c >= 33 && c <= 126; + } + } + /** + * @param {string} characters + */ + function isValidHTTPToken(characters) { + if (characters.length === 0) return false; + for (let i = 0; i < characters.length; ++i) if (!isTokenCharCode(characters.charCodeAt(i))) return false; + return true; + } + /** + * Matches if val contains an invalid field-vchar + * field-value = *( field-content / obs-fold ) + * field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ] + * field-vchar = VCHAR / obs-text + */ + const headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/; + /** + * @param {string} characters + */ + function isValidHeaderValue(characters) { + return !headerCharRegex.test(characters); + } + function parseRangeHeader(range) { + if (range == null || range === "") return { + start: 0, + end: null, + size: null + }; + const m = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null; + return m ? { + start: parseInt(m[1]), + end: m[2] ? parseInt(m[2]) : null, + size: m[3] ? parseInt(m[3]) : null + } : null; + } + function addListener(obj, name, listener) { + (obj[kListeners] ??= []).push([name, listener]); + obj.on(name, listener); + return obj; + } + function removeAllListeners(obj) { + for (const [name, listener] of obj[kListeners] ?? []) obj.removeListener(name, listener); + obj[kListeners] = null; + } + function errorRequest(client, request, err) { + try { + request.onError(err); + assert$26(request.aborted); + } catch (err) { + client.emit("error", err); + } + } + const kEnumerableProperty = Object.create(null); + kEnumerableProperty.enumerable = true; + const normalizedMethodRecordsBase = { + delete: "DELETE", + DELETE: "DELETE", + get: "GET", + GET: "GET", + head: "HEAD", + HEAD: "HEAD", + options: "OPTIONS", + OPTIONS: "OPTIONS", + post: "POST", + POST: "POST", + put: "PUT", + PUT: "PUT" + }; + const normalizedMethodRecords = { + ...normalizedMethodRecordsBase, + patch: "patch", + PATCH: "PATCH" + }; + Object.setPrototypeOf(normalizedMethodRecordsBase, null); + Object.setPrototypeOf(normalizedMethodRecords, null); + module.exports = { + kEnumerableProperty, + nop, + isDisturbed, + isErrored, + isReadable, + toUSVString, + isUSVString, + isBlobLike, + parseOrigin, + parseURL, + getServerName, + isStream, + isIterable, + isAsyncIterable, + isDestroyed, + headerNameToString, + bufferToLowerCasedHeaderName, + addListener, + removeAllListeners, + errorRequest, + parseRawHeaders, + parseHeaders, + parseKeepAliveTimeout, + destroy, + bodyLength, + deepClone, + ReadableStreamFrom, + isBuffer, + validateHandler, + getSocketInfo, + isFormDataLike, + buildURL, + addAbortListener, + isValidHTTPToken, + isValidHeaderValue, + isTokenCharCode, + parseRangeHeader, + normalizedMethodRecordsBase, + normalizedMethodRecords, + isValidPort, + isHttpOrHttpsPrefixed, + nodeMajor, + nodeMinor, + safeHTTPMethods: [ + "GET", + "HEAD", + "OPTIONS", + "TRACE" + ], + wrapRequestBody + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/core/diagnostics.js +var require_diagnostics = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const diagnosticsChannel = __require("node:diagnostics_channel"); + const util$1 = __require("node:util"); + const undiciDebugLog = util$1.debuglog("undici"); + const fetchDebuglog = util$1.debuglog("fetch"); + const websocketDebuglog = util$1.debuglog("websocket"); + let isClientSet = false; + const channels = { + beforeConnect: diagnosticsChannel.channel("undici:client:beforeConnect"), + connected: diagnosticsChannel.channel("undici:client:connected"), + connectError: diagnosticsChannel.channel("undici:client:connectError"), + sendHeaders: diagnosticsChannel.channel("undici:client:sendHeaders"), + create: diagnosticsChannel.channel("undici:request:create"), + bodySent: diagnosticsChannel.channel("undici:request:bodySent"), + headers: diagnosticsChannel.channel("undici:request:headers"), + trailers: diagnosticsChannel.channel("undici:request:trailers"), + error: diagnosticsChannel.channel("undici:request:error"), + open: diagnosticsChannel.channel("undici:websocket:open"), + close: diagnosticsChannel.channel("undici:websocket:close"), + socketError: diagnosticsChannel.channel("undici:websocket:socket_error"), + ping: diagnosticsChannel.channel("undici:websocket:ping"), + pong: diagnosticsChannel.channel("undici:websocket:pong") + }; + if (undiciDebugLog.enabled || fetchDebuglog.enabled) { + const debuglog = fetchDebuglog.enabled ? fetchDebuglog : undiciDebugLog; + diagnosticsChannel.channel("undici:client:beforeConnect").subscribe((evt) => { + const { connectParams: { version, protocol, port, host } } = evt; + debuglog("connecting to %s using %s%s", `${host}${port ? `:${port}` : ""}`, protocol, version); + }); + diagnosticsChannel.channel("undici:client:connected").subscribe((evt) => { + const { connectParams: { version, protocol, port, host } } = evt; + debuglog("connected to %s using %s%s", `${host}${port ? `:${port}` : ""}`, protocol, version); + }); + diagnosticsChannel.channel("undici:client:connectError").subscribe((evt) => { + const { connectParams: { version, protocol, port, host }, error } = evt; + debuglog("connection to %s using %s%s errored - %s", `${host}${port ? `:${port}` : ""}`, protocol, version, error.message); + }); + diagnosticsChannel.channel("undici:client:sendHeaders").subscribe((evt) => { + const { request: { method, path, origin } } = evt; + debuglog("sending request to %s %s/%s", method, origin, path); + }); + diagnosticsChannel.channel("undici:request:headers").subscribe((evt) => { + const { request: { method, path, origin }, response: { statusCode } } = evt; + debuglog("received response to %s %s/%s - HTTP %d", method, origin, path, statusCode); + }); + diagnosticsChannel.channel("undici:request:trailers").subscribe((evt) => { + const { request: { method, path, origin } } = evt; + debuglog("trailers received from %s %s/%s", method, origin, path); + }); + diagnosticsChannel.channel("undici:request:error").subscribe((evt) => { + const { request: { method, path, origin }, error } = evt; + debuglog("request to %s %s/%s errored - %s", method, origin, path, error.message); + }); + isClientSet = true; + } + if (websocketDebuglog.enabled) { + if (!isClientSet) { + const debuglog = undiciDebugLog.enabled ? undiciDebugLog : websocketDebuglog; + diagnosticsChannel.channel("undici:client:beforeConnect").subscribe((evt) => { + const { connectParams: { version, protocol, port, host } } = evt; + debuglog("connecting to %s%s using %s%s", host, port ? `:${port}` : "", protocol, version); + }); + diagnosticsChannel.channel("undici:client:connected").subscribe((evt) => { + const { connectParams: { version, protocol, port, host } } = evt; + debuglog("connected to %s%s using %s%s", host, port ? `:${port}` : "", protocol, version); + }); + diagnosticsChannel.channel("undici:client:connectError").subscribe((evt) => { + const { connectParams: { version, protocol, port, host }, error } = evt; + debuglog("connection to %s%s using %s%s errored - %s", host, port ? `:${port}` : "", protocol, version, error.message); + }); + diagnosticsChannel.channel("undici:client:sendHeaders").subscribe((evt) => { + const { request: { method, path, origin } } = evt; + debuglog("sending request to %s %s/%s", method, origin, path); + }); + } + diagnosticsChannel.channel("undici:websocket:open").subscribe((evt) => { + const { address: { address, port } } = evt; + websocketDebuglog("connection opened %s%s", address, port ? `:${port}` : ""); + }); + diagnosticsChannel.channel("undici:websocket:close").subscribe((evt) => { + const { websocket, code, reason } = evt; + websocketDebuglog("closed connection to %s - %s %s", websocket.url, code, reason); + }); + diagnosticsChannel.channel("undici:websocket:socket_error").subscribe((err) => { + websocketDebuglog("connection errored - %s", err.message); + }); + diagnosticsChannel.channel("undici:websocket:ping").subscribe((evt) => { + websocketDebuglog("ping received"); + }); + diagnosticsChannel.channel("undici:websocket:pong").subscribe((evt) => { + websocketDebuglog("pong received"); + }); + } + module.exports = { channels }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/core/request.js +var require_request$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { InvalidArgumentError, NotSupportedError } = require_errors(); + const assert$25 = __require("node:assert"); + const { isValidHTTPToken, isValidHeaderValue, isStream, destroy, isBuffer, isFormDataLike, isIterable, isBlobLike, buildURL, validateHandler, getServerName, normalizedMethodRecords } = require_util$7(); + const { channels } = require_diagnostics(); + const { headerNameLowerCasedRecord } = require_constants$4(); + const invalidPathRegex = /[^\u0021-\u00ff]/; + const kHandler = Symbol("handler"); + var Request = class { + constructor(origin, { path, method, body, headers, query, idempotent, blocking, upgrade, headersTimeout, bodyTimeout, reset, throwOnError, expectContinue, servername }, handler) { + if (typeof path !== "string") throw new InvalidArgumentError("path must be a string"); + else if (path[0] !== "/" && !(path.startsWith("http://") || path.startsWith("https://")) && method !== "CONNECT") throw new InvalidArgumentError("path must be an absolute URL or start with a slash"); + else if (invalidPathRegex.test(path)) throw new InvalidArgumentError("invalid request path"); + if (typeof method !== "string") throw new InvalidArgumentError("method must be a string"); + else if (normalizedMethodRecords[method] === void 0 && !isValidHTTPToken(method)) throw new InvalidArgumentError("invalid request method"); + if (upgrade && typeof upgrade !== "string") throw new InvalidArgumentError("upgrade must be a string"); + if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) throw new InvalidArgumentError("invalid headersTimeout"); + if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) throw new InvalidArgumentError("invalid bodyTimeout"); + if (reset != null && typeof reset !== "boolean") throw new InvalidArgumentError("invalid reset"); + if (expectContinue != null && typeof expectContinue !== "boolean") throw new InvalidArgumentError("invalid expectContinue"); + this.headersTimeout = headersTimeout; + this.bodyTimeout = bodyTimeout; + this.throwOnError = throwOnError === true; + this.method = method; + this.abort = null; + if (body == null) this.body = null; + else if (isStream(body)) { + this.body = body; + const rState = this.body._readableState; + if (!rState || !rState.autoDestroy) { + this.endHandler = function autoDestroy() { + destroy(this); + }; + this.body.on("end", this.endHandler); + } + this.errorHandler = (err) => { + if (this.abort) this.abort(err); + else this.error = err; + }; + this.body.on("error", this.errorHandler); + } else if (isBuffer(body)) this.body = body.byteLength ? body : null; + else if (ArrayBuffer.isView(body)) this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null; + else if (body instanceof ArrayBuffer) this.body = body.byteLength ? Buffer.from(body) : null; + else if (typeof body === "string") this.body = body.length ? Buffer.from(body) : null; + else if (isFormDataLike(body) || isIterable(body) || isBlobLike(body)) this.body = body; + else throw new InvalidArgumentError("body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable"); + this.completed = false; + this.aborted = false; + this.upgrade = upgrade || null; + this.path = query ? buildURL(path, query) : path; + this.origin = origin; + this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent; + this.blocking = blocking == null ? false : blocking; + this.reset = reset == null ? null : reset; + this.host = null; + this.contentLength = null; + this.contentType = null; + this.headers = []; + this.expectContinue = expectContinue != null ? expectContinue : false; + if (Array.isArray(headers)) { + if (headers.length % 2 !== 0) throw new InvalidArgumentError("headers array must be even"); + for (let i = 0; i < headers.length; i += 2) processHeader(this, headers[i], headers[i + 1]); + } else if (headers && typeof headers === "object") { + if (headers[Symbol.iterator]) for (const header of headers) { + if (!Array.isArray(header) || header.length !== 2) throw new InvalidArgumentError("headers must be in key-value pair format"); + processHeader(this, header[0], header[1]); + } + else { + const keys = Object.keys(headers); + for (let i = 0; i < keys.length; ++i) processHeader(this, keys[i], headers[keys[i]]); + } + } else if (headers != null) throw new InvalidArgumentError("headers must be an object or an array"); + validateHandler(handler, method, upgrade); + this.servername = servername || getServerName(this.host); + this[kHandler] = handler; + if (channels.create.hasSubscribers) channels.create.publish({ request: this }); + } + onBodySent(chunk) { + if (this[kHandler].onBodySent) try { + return this[kHandler].onBodySent(chunk); + } catch (err) { + this.abort(err); + } + } + onRequestSent() { + if (channels.bodySent.hasSubscribers) channels.bodySent.publish({ request: this }); + if (this[kHandler].onRequestSent) try { + return this[kHandler].onRequestSent(); + } catch (err) { + this.abort(err); + } + } + onConnect(abort) { + assert$25(!this.aborted); + assert$25(!this.completed); + if (this.error) abort(this.error); + else { + this.abort = abort; + return this[kHandler].onConnect(abort); + } + } + onResponseStarted() { + return this[kHandler].onResponseStarted?.(); + } + onHeaders(statusCode, headers, resume, statusText) { + assert$25(!this.aborted); + assert$25(!this.completed); + if (channels.headers.hasSubscribers) channels.headers.publish({ + request: this, + response: { + statusCode, + headers, + statusText + } + }); + try { + return this[kHandler].onHeaders(statusCode, headers, resume, statusText); + } catch (err) { + this.abort(err); + } + } + onData(chunk) { + assert$25(!this.aborted); + assert$25(!this.completed); + try { + return this[kHandler].onData(chunk); + } catch (err) { + this.abort(err); + return false; + } + } + onUpgrade(statusCode, headers, socket) { + assert$25(!this.aborted); + assert$25(!this.completed); + return this[kHandler].onUpgrade(statusCode, headers, socket); + } + onComplete(trailers) { + this.onFinally(); + assert$25(!this.aborted); + this.completed = true; + if (channels.trailers.hasSubscribers) channels.trailers.publish({ + request: this, + trailers + }); + try { + return this[kHandler].onComplete(trailers); + } catch (err) { + this.onError(err); + } + } + onError(error) { + this.onFinally(); + if (channels.error.hasSubscribers) channels.error.publish({ + request: this, + error + }); + if (this.aborted) return; + this.aborted = true; + return this[kHandler].onError(error); + } + onFinally() { + if (this.errorHandler) { + this.body.off("error", this.errorHandler); + this.errorHandler = null; + } + if (this.endHandler) { + this.body.off("end", this.endHandler); + this.endHandler = null; + } + } + addHeader(key, value) { + processHeader(this, key, value); + return this; + } + }; + function processHeader(request, key, val) { + if (val && typeof val === "object" && !Array.isArray(val)) throw new InvalidArgumentError(`invalid ${key} header`); + else if (val === void 0) return; + let headerName = headerNameLowerCasedRecord[key]; + if (headerName === void 0) { + headerName = key.toLowerCase(); + if (headerNameLowerCasedRecord[headerName] === void 0 && !isValidHTTPToken(headerName)) throw new InvalidArgumentError("invalid header key"); + } + if (Array.isArray(val)) { + const arr = []; + for (let i = 0; i < val.length; i++) if (typeof val[i] === "string") { + if (!isValidHeaderValue(val[i])) throw new InvalidArgumentError(`invalid ${key} header`); + arr.push(val[i]); + } else if (val[i] === null) arr.push(""); + else if (typeof val[i] === "object") throw new InvalidArgumentError(`invalid ${key} header`); + else arr.push(`${val[i]}`); + val = arr; + } else if (typeof val === "string") { + if (!isValidHeaderValue(val)) throw new InvalidArgumentError(`invalid ${key} header`); + } else if (val === null) val = ""; + else val = `${val}`; + if (request.host === null && headerName === "host") { + if (typeof val !== "string") throw new InvalidArgumentError("invalid host header"); + request.host = val; + } else if (request.contentLength === null && headerName === "content-length") { + request.contentLength = parseInt(val, 10); + if (!Number.isFinite(request.contentLength)) throw new InvalidArgumentError("invalid content-length header"); + } else if (request.contentType === null && headerName === "content-type") { + request.contentType = val; + request.headers.push(key, val); + } else if (headerName === "transfer-encoding" || headerName === "keep-alive" || headerName === "upgrade") throw new InvalidArgumentError(`invalid ${headerName} header`); + else if (headerName === "connection") { + const value = typeof val === "string" ? val.toLowerCase() : null; + if (value !== "close" && value !== "keep-alive") throw new InvalidArgumentError("invalid connection header"); + if (value === "close") request.reset = true; + } else if (headerName === "expect") throw new NotSupportedError("expect header not supported"); + else request.headers.push(key, val); + } + module.exports = Request; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/dispatcher/dispatcher.js +var require_dispatcher = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const EventEmitter = __require("node:events"); + var Dispatcher = class extends EventEmitter { + dispatch() { + throw new Error("not implemented"); + } + close() { + throw new Error("not implemented"); + } + destroy() { + throw new Error("not implemented"); + } + compose(...args) { + const interceptors = Array.isArray(args[0]) ? args[0] : args; + let dispatch = this.dispatch.bind(this); + for (const interceptor of interceptors) { + if (interceptor == null) continue; + if (typeof interceptor !== "function") throw new TypeError(`invalid interceptor, expected function received ${typeof interceptor}`); + dispatch = interceptor(dispatch); + if (dispatch == null || typeof dispatch !== "function" || dispatch.length !== 2) throw new TypeError("invalid interceptor"); + } + return new ComposedDispatcher(this, dispatch); + } + }; + var ComposedDispatcher = class extends Dispatcher { + #dispatcher = null; + #dispatch = null; + constructor(dispatcher, dispatch) { + super(); + this.#dispatcher = dispatcher; + this.#dispatch = dispatch; + } + dispatch(...args) { + this.#dispatch(...args); + } + close(...args) { + return this.#dispatcher.close(...args); + } + destroy(...args) { + return this.#dispatcher.destroy(...args); + } + }; + module.exports = Dispatcher; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/dispatcher/dispatcher-base.js +var require_dispatcher_base = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const Dispatcher = require_dispatcher(); + const { ClientDestroyedError, ClientClosedError, InvalidArgumentError } = require_errors(); + const { kDestroy, kClose, kClosed, kDestroyed, kDispatch, kInterceptors } = require_symbols$4(); + const kOnDestroyed = Symbol("onDestroyed"); + const kOnClosed = Symbol("onClosed"); + const kInterceptedDispatch = Symbol("Intercepted Dispatch"); + var DispatcherBase = class extends Dispatcher { + constructor() { + super(); + this[kDestroyed] = false; + this[kOnDestroyed] = null; + this[kClosed] = false; + this[kOnClosed] = []; + } + get destroyed() { + return this[kDestroyed]; + } + get closed() { + return this[kClosed]; + } + get interceptors() { + return this[kInterceptors]; + } + set interceptors(newInterceptors) { + if (newInterceptors) { + for (let i = newInterceptors.length - 1; i >= 0; i--) if (typeof this[kInterceptors][i] !== "function") throw new InvalidArgumentError("interceptor must be an function"); + } + this[kInterceptors] = newInterceptors; + } + close(callback) { + if (callback === void 0) return new Promise((resolve, reject) => { + this.close((err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + if (typeof callback !== "function") throw new InvalidArgumentError("invalid callback"); + if (this[kDestroyed]) { + queueMicrotask(() => callback(new ClientDestroyedError(), null)); + return; + } + if (this[kClosed]) { + if (this[kOnClosed]) this[kOnClosed].push(callback); + else queueMicrotask(() => callback(null, null)); + return; + } + this[kClosed] = true; + this[kOnClosed].push(callback); + const onClosed = () => { + const callbacks = this[kOnClosed]; + this[kOnClosed] = null; + for (let i = 0; i < callbacks.length; i++) callbacks[i](null, null); + }; + this[kClose]().then(() => this.destroy()).then(() => { + queueMicrotask(onClosed); + }); + } + destroy(err, callback) { + if (typeof err === "function") { + callback = err; + err = null; + } + if (callback === void 0) return new Promise((resolve, reject) => { + this.destroy(err, (err, data) => { + return err ? /* istanbul ignore next: should never error */ reject(err) : resolve(data); + }); + }); + if (typeof callback !== "function") throw new InvalidArgumentError("invalid callback"); + if (this[kDestroyed]) { + if (this[kOnDestroyed]) this[kOnDestroyed].push(callback); + else queueMicrotask(() => callback(null, null)); + return; + } + if (!err) err = new ClientDestroyedError(); + this[kDestroyed] = true; + this[kOnDestroyed] = this[kOnDestroyed] || []; + this[kOnDestroyed].push(callback); + const onDestroyed = () => { + const callbacks = this[kOnDestroyed]; + this[kOnDestroyed] = null; + for (let i = 0; i < callbacks.length; i++) callbacks[i](null, null); + }; + this[kDestroy](err).then(() => { + queueMicrotask(onDestroyed); + }); + } + [kInterceptedDispatch](opts, handler) { + if (!this[kInterceptors] || this[kInterceptors].length === 0) { + this[kInterceptedDispatch] = this[kDispatch]; + return this[kDispatch](opts, handler); + } + let dispatch = this[kDispatch].bind(this); + for (let i = this[kInterceptors].length - 1; i >= 0; i--) dispatch = this[kInterceptors][i](dispatch); + this[kInterceptedDispatch] = dispatch; + return dispatch(opts, handler); + } + dispatch(opts, handler) { + if (!handler || typeof handler !== "object") throw new InvalidArgumentError("handler must be an object"); + try { + if (!opts || typeof opts !== "object") throw new InvalidArgumentError("opts must be an object."); + if (this[kDestroyed] || this[kOnDestroyed]) throw new ClientDestroyedError(); + if (this[kClosed]) throw new ClientClosedError(); + return this[kInterceptedDispatch](opts, handler); + } catch (err) { + if (typeof handler.onError !== "function") throw new InvalidArgumentError("invalid onError method"); + handler.onError(err); + return false; + } + } + }; + module.exports = DispatcherBase; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/util/timers.js +var require_timers = /* @__PURE__ */ __commonJSMin(((exports, module) => { + /** + * This module offers an optimized timer implementation designed for scenarios + * where high precision is not critical. + * + * The timer achieves faster performance by using a low-resolution approach, + * with an accuracy target of within 500ms. This makes it particularly useful + * for timers with delays of 1 second or more, where exact timing is less + * crucial. + * + * It's important to note that Node.js timers are inherently imprecise, as + * delays can occur due to the event loop being blocked by other operations. + * Consequently, timers may trigger later than their scheduled time. + */ + /** + * The fastNow variable contains the internal fast timer clock value. + * + * @type {number} + */ + let fastNow = 0; + /** + * RESOLUTION_MS represents the target resolution time in milliseconds. + * + * @type {number} + * @default 1000 + */ + const RESOLUTION_MS = 1e3; + /** + * TICK_MS defines the desired interval in milliseconds between each tick. + * The target value is set to half the resolution time, minus 1 ms, to account + * for potential event loop overhead. + * + * @type {number} + * @default 499 + */ + const TICK_MS = 499; + /** + * fastNowTimeout is a Node.js timer used to manage and process + * the FastTimers stored in the `fastTimers` array. + * + * @type {NodeJS.Timeout} + */ + let fastNowTimeout; + /** + * The kFastTimer symbol is used to identify FastTimer instances. + * + * @type {Symbol} + */ + const kFastTimer = Symbol("kFastTimer"); + /** + * The fastTimers array contains all active FastTimers. + * + * @type {FastTimer[]} + */ + const fastTimers = []; + /** + * These constants represent the various states of a FastTimer. + */ + /** + * The `NOT_IN_LIST` constant indicates that the FastTimer is not included + * in the `fastTimers` array. Timers with this status will not be processed + * during the next tick by the `onTick` function. + * + * A FastTimer can be re-added to the `fastTimers` array by invoking the + * `refresh` method on the FastTimer instance. + * + * @type {-2} + */ + const NOT_IN_LIST = -2; + /** + * The `TO_BE_CLEARED` constant indicates that the FastTimer is scheduled + * for removal from the `fastTimers` array. A FastTimer in this state will + * be removed in the next tick by the `onTick` function and will no longer + * be processed. + * + * This status is also set when the `clear` method is called on the FastTimer instance. + * + * @type {-1} + */ + const TO_BE_CLEARED = -1; + /** + * The `PENDING` constant signifies that the FastTimer is awaiting processing + * in the next tick by the `onTick` function. Timers with this status will have + * their `_idleStart` value set and their status updated to `ACTIVE` in the next tick. + * + * @type {0} + */ + const PENDING = 0; + /** + * The `ACTIVE` constant indicates that the FastTimer is active and waiting + * for its timer to expire. During the next tick, the `onTick` function will + * check if the timer has expired, and if so, it will execute the associated callback. + * + * @type {1} + */ + const ACTIVE = 1; + /** + * The onTick function processes the fastTimers array. + * + * @returns {void} + */ + function onTick() { + /** + * Increment the fastNow value by the TICK_MS value, despite the actual time + * that has passed since the last tick. This approach ensures independence + * from the system clock and delays caused by a blocked event loop. + * + * @type {number} + */ + fastNow += TICK_MS; + /** + * The `idx` variable is used to iterate over the `fastTimers` array. + * Expired timers are removed by replacing them with the last element in the array. + * Consequently, `idx` is only incremented when the current element is not removed. + * + * @type {number} + */ + let idx = 0; + /** + * The len variable will contain the length of the fastTimers array + * and will be decremented when a FastTimer should be removed from the + * fastTimers array. + * + * @type {number} + */ + let len = fastTimers.length; + while (idx < len) { + /** + * @type {FastTimer} + */ + const timer = fastTimers[idx]; + if (timer._state === PENDING) { + timer._idleStart = fastNow - TICK_MS; + timer._state = ACTIVE; + } else if (timer._state === ACTIVE && fastNow >= timer._idleStart + timer._idleTimeout) { + timer._state = TO_BE_CLEARED; + timer._idleStart = -1; + timer._onTimeout(timer._timerArg); + } + if (timer._state === TO_BE_CLEARED) { + timer._state = NOT_IN_LIST; + if (--len !== 0) fastTimers[idx] = fastTimers[len]; + } else ++idx; + } + fastTimers.length = len; + if (fastTimers.length !== 0) refreshTimeout(); + } + function refreshTimeout() { + if (fastNowTimeout) fastNowTimeout.refresh(); + else { + clearTimeout(fastNowTimeout); + fastNowTimeout = setTimeout(onTick, TICK_MS); + if (fastNowTimeout.unref) fastNowTimeout.unref(); + } + } + /** + * The `FastTimer` class is a data structure designed to store and manage + * timer information. + */ + var FastTimer = class { + [kFastTimer] = true; + /** + * The state of the timer, which can be one of the following: + * - NOT_IN_LIST (-2) + * - TO_BE_CLEARED (-1) + * - PENDING (0) + * - ACTIVE (1) + * + * @type {-2|-1|0|1} + * @private + */ + _state = NOT_IN_LIST; + /** + * The number of milliseconds to wait before calling the callback. + * + * @type {number} + * @private + */ + _idleTimeout = -1; + /** + * The time in milliseconds when the timer was started. This value is used to + * calculate when the timer should expire. + * + * @type {number} + * @default -1 + * @private + */ + _idleStart = -1; + /** + * The function to be executed when the timer expires. + * @type {Function} + * @private + */ + _onTimeout; + /** + * The argument to be passed to the callback when the timer expires. + * + * @type {*} + * @private + */ + _timerArg; + /** + * @constructor + * @param {Function} callback A function to be executed after the timer + * expires. + * @param {number} delay The time, in milliseconds that the timer should wait + * before the specified function or code is executed. + * @param {*} arg + */ + constructor(callback, delay, arg) { + this._onTimeout = callback; + this._idleTimeout = delay; + this._timerArg = arg; + this.refresh(); + } + /** + * Sets the timer's start time to the current time, and reschedules the timer + * to call its callback at the previously specified duration adjusted to the + * current time. + * Using this on a timer that has already called its callback will reactivate + * the timer. + * + * @returns {void} + */ + refresh() { + if (this._state === NOT_IN_LIST) fastTimers.push(this); + if (!fastNowTimeout || fastTimers.length === 1) refreshTimeout(); + this._state = PENDING; + } + /** + * The `clear` method cancels the timer, preventing it from executing. + * + * @returns {void} + * @private + */ + clear() { + this._state = TO_BE_CLEARED; + this._idleStart = -1; + } + }; + /** + * This module exports a setTimeout and clearTimeout function that can be + * used as a drop-in replacement for the native functions. + */ + module.exports = { + /** + * The setTimeout() method sets a timer which executes a function once the + * timer expires. + * @param {Function} callback A function to be executed after the timer + * expires. + * @param {number} delay The time, in milliseconds that the timer should + * wait before the specified function or code is executed. + * @param {*} [arg] An optional argument to be passed to the callback function + * when the timer expires. + * @returns {NodeJS.Timeout|FastTimer} + */ + setTimeout(callback, delay, arg) { + return delay <= RESOLUTION_MS ? setTimeout(callback, delay, arg) : new FastTimer(callback, delay, arg); + }, + /** + * The clearTimeout method cancels an instantiated Timer previously created + * by calling setTimeout. + * + * @param {NodeJS.Timeout|FastTimer} timeout + */ + clearTimeout(timeout) { + if (timeout[kFastTimer]) + /** + * @type {FastTimer} + */ + timeout.clear(); + else clearTimeout(timeout); + }, + /** + * The setFastTimeout() method sets a fastTimer which executes a function once + * the timer expires. + * @param {Function} callback A function to be executed after the timer + * expires. + * @param {number} delay The time, in milliseconds that the timer should + * wait before the specified function or code is executed. + * @param {*} [arg] An optional argument to be passed to the callback function + * when the timer expires. + * @returns {FastTimer} + */ + setFastTimeout(callback, delay, arg) { + return new FastTimer(callback, delay, arg); + }, + /** + * The clearTimeout method cancels an instantiated FastTimer previously + * created by calling setFastTimeout. + * + * @param {FastTimer} timeout + */ + clearFastTimeout(timeout) { + timeout.clear(); + }, + /** + * The now method returns the value of the internal fast timer clock. + * + * @returns {number} + */ + now() { + return fastNow; + }, + /** + * Trigger the onTick function to process the fastTimers array. + * Exported for testing purposes only. + * Marking as deprecated to discourage any use outside of testing. + * @deprecated + * @param {number} [delay=0] The delay in milliseconds to add to the now value. + */ + tick(delay = 0) { + fastNow += delay - RESOLUTION_MS + 1; + onTick(); + onTick(); + }, + /** + * Reset FastTimers. + * Exported for testing purposes only. + * Marking as deprecated to discourage any use outside of testing. + * @deprecated + */ + reset() { + fastNow = 0; + fastTimers.length = 0; + clearTimeout(fastNowTimeout); + fastNowTimeout = null; + }, + /** + * Exporting for testing purposes only. + * Marking as deprecated to discourage any use outside of testing. + * @deprecated + */ + kFastTimer + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/core/connect.js +var require_connect = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const net$1 = __require("node:net"); + const assert$24 = __require("node:assert"); + const util = require_util$7(); + const { InvalidArgumentError, ConnectTimeoutError } = require_errors(); + const timers = require_timers(); + function noop() {} + let tls; + let SessionCache; + if (global.FinalizationRegistry && !(process.env.NODE_V8_COVERAGE || process.env.UNDICI_NO_FG)) SessionCache = class WeakSessionCache { + constructor(maxCachedSessions) { + this._maxCachedSessions = maxCachedSessions; + this._sessionCache = /* @__PURE__ */ new Map(); + this._sessionRegistry = new global.FinalizationRegistry((key) => { + if (this._sessionCache.size < this._maxCachedSessions) return; + const ref = this._sessionCache.get(key); + if (ref !== void 0 && ref.deref() === void 0) this._sessionCache.delete(key); + }); + } + get(sessionKey) { + const ref = this._sessionCache.get(sessionKey); + return ref ? ref.deref() : null; + } + set(sessionKey, session) { + if (this._maxCachedSessions === 0) return; + this._sessionCache.set(sessionKey, new WeakRef(session)); + this._sessionRegistry.register(session, sessionKey); + } + }; + else SessionCache = class SimpleSessionCache { + constructor(maxCachedSessions) { + this._maxCachedSessions = maxCachedSessions; + this._sessionCache = /* @__PURE__ */ new Map(); + } + get(sessionKey) { + return this._sessionCache.get(sessionKey); + } + set(sessionKey, session) { + if (this._maxCachedSessions === 0) return; + if (this._sessionCache.size >= this._maxCachedSessions) { + const { value: oldestKey } = this._sessionCache.keys().next(); + this._sessionCache.delete(oldestKey); + } + this._sessionCache.set(sessionKey, session); + } + }; + function buildConnector({ allowH2, maxCachedSessions, socketPath, timeout, session: customSession, ...opts }) { + if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) throw new InvalidArgumentError("maxCachedSessions must be a positive integer or zero"); + const options = { + path: socketPath, + ...opts + }; + const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions); + timeout = timeout == null ? 1e4 : timeout; + allowH2 = allowH2 != null ? allowH2 : false; + return function connect({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) { + let socket; + if (protocol === "https:") { + if (!tls) tls = __require("node:tls"); + servername = servername || options.servername || util.getServerName(host) || null; + const sessionKey = servername || hostname; + assert$24(sessionKey); + const session = customSession || sessionCache.get(sessionKey) || null; + port = port || 443; + socket = tls.connect({ + highWaterMark: 16384, + ...options, + servername, + session, + localAddress, + ALPNProtocols: allowH2 ? ["http/1.1", "h2"] : ["http/1.1"], + socket: httpSocket, + port, + host: hostname + }); + socket.on("session", function(session) { + sessionCache.set(sessionKey, session); + }); + } else { + assert$24(!httpSocket, "httpSocket can only be sent on TLS update"); + port = port || 80; + socket = net$1.connect({ + highWaterMark: 65536, + ...options, + localAddress, + port, + host: hostname + }); + } + if (options.keepAlive == null || options.keepAlive) { + const keepAliveInitialDelay = options.keepAliveInitialDelay === void 0 ? 6e4 : options.keepAliveInitialDelay; + socket.setKeepAlive(true, keepAliveInitialDelay); + } + const clearConnectTimeout = setupConnectTimeout(new WeakRef(socket), { + timeout, + hostname, + port + }); + socket.setNoDelay(true).once(protocol === "https:" ? "secureConnect" : "connect", function() { + queueMicrotask(clearConnectTimeout); + if (callback) { + const cb = callback; + callback = null; + cb(null, this); + } + }).on("error", function(err) { + queueMicrotask(clearConnectTimeout); + if (callback) { + const cb = callback; + callback = null; + cb(err); + } + }); + return socket; + }; + } + /** + * @param {WeakRef} socketWeakRef + * @param {object} opts + * @param {number} opts.timeout + * @param {string} opts.hostname + * @param {number} opts.port + * @returns {() => void} + */ + const setupConnectTimeout = process.platform === "win32" ? (socketWeakRef, opts) => { + if (!opts.timeout) return noop; + let s1 = null; + let s2 = null; + const fastTimer = timers.setFastTimeout(() => { + s1 = setImmediate(() => { + s2 = setImmediate(() => onConnectTimeout(socketWeakRef.deref(), opts)); + }); + }, opts.timeout); + return () => { + timers.clearFastTimeout(fastTimer); + clearImmediate(s1); + clearImmediate(s2); + }; + } : (socketWeakRef, opts) => { + if (!opts.timeout) return noop; + let s1 = null; + const fastTimer = timers.setFastTimeout(() => { + s1 = setImmediate(() => { + onConnectTimeout(socketWeakRef.deref(), opts); + }); + }, opts.timeout); + return () => { + timers.clearFastTimeout(fastTimer); + clearImmediate(s1); + }; + }; + /** + * @param {net.Socket} socket + * @param {object} opts + * @param {number} opts.timeout + * @param {string} opts.hostname + * @param {number} opts.port + */ + function onConnectTimeout(socket, opts) { + if (socket == null) return; + let message = "Connect Timeout Error"; + if (Array.isArray(socket.autoSelectFamilyAttemptedAddresses)) message += ` (attempted addresses: ${socket.autoSelectFamilyAttemptedAddresses.join(", ")},`; + else message += ` (attempted address: ${opts.hostname}:${opts.port},`; + message += ` timeout: ${opts.timeout}ms)`; + util.destroy(socket, new ConnectTimeoutError(message)); + } + module.exports = buildConnector; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/llhttp/utils.js +var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => { + Object.defineProperty(exports, "__esModule", { value: true }); + exports.enumToMap = void 0; + function enumToMap(obj) { + const res = {}; + Object.keys(obj).forEach((key) => { + const value = obj[key]; + if (typeof value === "number") res[key] = value; + }); + return res; + } + exports.enumToMap = enumToMap; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/llhttp/constants.js +var require_constants$3 = /* @__PURE__ */ __commonJSMin(((exports) => { + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SPECIAL_HEADERS = exports.HEADER_STATE = exports.MINOR = exports.MAJOR = exports.CONNECTION_TOKEN_CHARS = exports.HEADER_CHARS = exports.TOKEN = exports.STRICT_TOKEN = exports.HEX = exports.URL_CHAR = exports.STRICT_URL_CHAR = exports.USERINFO_CHARS = exports.MARK = exports.ALPHANUM = exports.NUM = exports.HEX_MAP = exports.NUM_MAP = exports.ALPHA = exports.FINISH = exports.H_METHOD_MAP = exports.METHOD_MAP = exports.METHODS_RTSP = exports.METHODS_ICE = exports.METHODS_HTTP = exports.METHODS = exports.LENIENT_FLAGS = exports.FLAGS = exports.TYPE = exports.ERROR = void 0; + const utils_1 = require_utils(); + (function(ERROR) { + ERROR[ERROR["OK"] = 0] = "OK"; + ERROR[ERROR["INTERNAL"] = 1] = "INTERNAL"; + ERROR[ERROR["STRICT"] = 2] = "STRICT"; + ERROR[ERROR["LF_EXPECTED"] = 3] = "LF_EXPECTED"; + ERROR[ERROR["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH"; + ERROR[ERROR["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION"; + ERROR[ERROR["INVALID_METHOD"] = 6] = "INVALID_METHOD"; + ERROR[ERROR["INVALID_URL"] = 7] = "INVALID_URL"; + ERROR[ERROR["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT"; + ERROR[ERROR["INVALID_VERSION"] = 9] = "INVALID_VERSION"; + ERROR[ERROR["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN"; + ERROR[ERROR["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH"; + ERROR[ERROR["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE"; + ERROR[ERROR["INVALID_STATUS"] = 13] = "INVALID_STATUS"; + ERROR[ERROR["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE"; + ERROR[ERROR["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING"; + ERROR[ERROR["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN"; + ERROR[ERROR["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE"; + ERROR[ERROR["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE"; + ERROR[ERROR["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER"; + ERROR[ERROR["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE"; + ERROR[ERROR["PAUSED"] = 21] = "PAUSED"; + ERROR[ERROR["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE"; + ERROR[ERROR["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE"; + ERROR[ERROR["USER"] = 24] = "USER"; + })(exports.ERROR || (exports.ERROR = {})); + (function(TYPE) { + TYPE[TYPE["BOTH"] = 0] = "BOTH"; + TYPE[TYPE["REQUEST"] = 1] = "REQUEST"; + TYPE[TYPE["RESPONSE"] = 2] = "RESPONSE"; + })(exports.TYPE || (exports.TYPE = {})); + (function(FLAGS) { + FLAGS[FLAGS["CONNECTION_KEEP_ALIVE"] = 1] = "CONNECTION_KEEP_ALIVE"; + FLAGS[FLAGS["CONNECTION_CLOSE"] = 2] = "CONNECTION_CLOSE"; + FLAGS[FLAGS["CONNECTION_UPGRADE"] = 4] = "CONNECTION_UPGRADE"; + FLAGS[FLAGS["CHUNKED"] = 8] = "CHUNKED"; + FLAGS[FLAGS["UPGRADE"] = 16] = "UPGRADE"; + FLAGS[FLAGS["CONTENT_LENGTH"] = 32] = "CONTENT_LENGTH"; + FLAGS[FLAGS["SKIPBODY"] = 64] = "SKIPBODY"; + FLAGS[FLAGS["TRAILING"] = 128] = "TRAILING"; + FLAGS[FLAGS["TRANSFER_ENCODING"] = 512] = "TRANSFER_ENCODING"; + })(exports.FLAGS || (exports.FLAGS = {})); + (function(LENIENT_FLAGS) { + LENIENT_FLAGS[LENIENT_FLAGS["HEADERS"] = 1] = "HEADERS"; + LENIENT_FLAGS[LENIENT_FLAGS["CHUNKED_LENGTH"] = 2] = "CHUNKED_LENGTH"; + LENIENT_FLAGS[LENIENT_FLAGS["KEEP_ALIVE"] = 4] = "KEEP_ALIVE"; + })(exports.LENIENT_FLAGS || (exports.LENIENT_FLAGS = {})); + var METHODS; + (function(METHODS) { + METHODS[METHODS["DELETE"] = 0] = "DELETE"; + METHODS[METHODS["GET"] = 1] = "GET"; + METHODS[METHODS["HEAD"] = 2] = "HEAD"; + METHODS[METHODS["POST"] = 3] = "POST"; + METHODS[METHODS["PUT"] = 4] = "PUT"; + METHODS[METHODS["CONNECT"] = 5] = "CONNECT"; + METHODS[METHODS["OPTIONS"] = 6] = "OPTIONS"; + METHODS[METHODS["TRACE"] = 7] = "TRACE"; + METHODS[METHODS["COPY"] = 8] = "COPY"; + METHODS[METHODS["LOCK"] = 9] = "LOCK"; + METHODS[METHODS["MKCOL"] = 10] = "MKCOL"; + METHODS[METHODS["MOVE"] = 11] = "MOVE"; + METHODS[METHODS["PROPFIND"] = 12] = "PROPFIND"; + METHODS[METHODS["PROPPATCH"] = 13] = "PROPPATCH"; + METHODS[METHODS["SEARCH"] = 14] = "SEARCH"; + METHODS[METHODS["UNLOCK"] = 15] = "UNLOCK"; + METHODS[METHODS["BIND"] = 16] = "BIND"; + METHODS[METHODS["REBIND"] = 17] = "REBIND"; + METHODS[METHODS["UNBIND"] = 18] = "UNBIND"; + METHODS[METHODS["ACL"] = 19] = "ACL"; + METHODS[METHODS["REPORT"] = 20] = "REPORT"; + METHODS[METHODS["MKACTIVITY"] = 21] = "MKACTIVITY"; + METHODS[METHODS["CHECKOUT"] = 22] = "CHECKOUT"; + METHODS[METHODS["MERGE"] = 23] = "MERGE"; + METHODS[METHODS["M-SEARCH"] = 24] = "M-SEARCH"; + METHODS[METHODS["NOTIFY"] = 25] = "NOTIFY"; + METHODS[METHODS["SUBSCRIBE"] = 26] = "SUBSCRIBE"; + METHODS[METHODS["UNSUBSCRIBE"] = 27] = "UNSUBSCRIBE"; + METHODS[METHODS["PATCH"] = 28] = "PATCH"; + METHODS[METHODS["PURGE"] = 29] = "PURGE"; + METHODS[METHODS["MKCALENDAR"] = 30] = "MKCALENDAR"; + METHODS[METHODS["LINK"] = 31] = "LINK"; + METHODS[METHODS["UNLINK"] = 32] = "UNLINK"; + METHODS[METHODS["SOURCE"] = 33] = "SOURCE"; + METHODS[METHODS["PRI"] = 34] = "PRI"; + METHODS[METHODS["DESCRIBE"] = 35] = "DESCRIBE"; + METHODS[METHODS["ANNOUNCE"] = 36] = "ANNOUNCE"; + METHODS[METHODS["SETUP"] = 37] = "SETUP"; + METHODS[METHODS["PLAY"] = 38] = "PLAY"; + METHODS[METHODS["PAUSE"] = 39] = "PAUSE"; + METHODS[METHODS["TEARDOWN"] = 40] = "TEARDOWN"; + METHODS[METHODS["GET_PARAMETER"] = 41] = "GET_PARAMETER"; + METHODS[METHODS["SET_PARAMETER"] = 42] = "SET_PARAMETER"; + METHODS[METHODS["REDIRECT"] = 43] = "REDIRECT"; + METHODS[METHODS["RECORD"] = 44] = "RECORD"; + METHODS[METHODS["FLUSH"] = 45] = "FLUSH"; + })(METHODS = exports.METHODS || (exports.METHODS = {})); + exports.METHODS_HTTP = [ + METHODS.DELETE, + METHODS.GET, + METHODS.HEAD, + METHODS.POST, + METHODS.PUT, + METHODS.CONNECT, + METHODS.OPTIONS, + METHODS.TRACE, + METHODS.COPY, + METHODS.LOCK, + METHODS.MKCOL, + METHODS.MOVE, + METHODS.PROPFIND, + METHODS.PROPPATCH, + METHODS.SEARCH, + METHODS.UNLOCK, + METHODS.BIND, + METHODS.REBIND, + METHODS.UNBIND, + METHODS.ACL, + METHODS.REPORT, + METHODS.MKACTIVITY, + METHODS.CHECKOUT, + METHODS.MERGE, + METHODS["M-SEARCH"], + METHODS.NOTIFY, + METHODS.SUBSCRIBE, + METHODS.UNSUBSCRIBE, + METHODS.PATCH, + METHODS.PURGE, + METHODS.MKCALENDAR, + METHODS.LINK, + METHODS.UNLINK, + METHODS.PRI, + METHODS.SOURCE + ]; + exports.METHODS_ICE = [METHODS.SOURCE]; + exports.METHODS_RTSP = [ + METHODS.OPTIONS, + METHODS.DESCRIBE, + METHODS.ANNOUNCE, + METHODS.SETUP, + METHODS.PLAY, + METHODS.PAUSE, + METHODS.TEARDOWN, + METHODS.GET_PARAMETER, + METHODS.SET_PARAMETER, + METHODS.REDIRECT, + METHODS.RECORD, + METHODS.FLUSH, + METHODS.GET, + METHODS.POST + ]; + exports.METHOD_MAP = utils_1.enumToMap(METHODS); + exports.H_METHOD_MAP = {}; + Object.keys(exports.METHOD_MAP).forEach((key) => { + if (/^H/.test(key)) exports.H_METHOD_MAP[key] = exports.METHOD_MAP[key]; + }); + (function(FINISH) { + FINISH[FINISH["SAFE"] = 0] = "SAFE"; + FINISH[FINISH["SAFE_WITH_CB"] = 1] = "SAFE_WITH_CB"; + FINISH[FINISH["UNSAFE"] = 2] = "UNSAFE"; + })(exports.FINISH || (exports.FINISH = {})); + exports.ALPHA = []; + for (let i = "A".charCodeAt(0); i <= "Z".charCodeAt(0); i++) { + exports.ALPHA.push(String.fromCharCode(i)); + exports.ALPHA.push(String.fromCharCode(i + 32)); + } + exports.NUM_MAP = { + 0: 0, + 1: 1, + 2: 2, + 3: 3, + 4: 4, + 5: 5, + 6: 6, + 7: 7, + 8: 8, + 9: 9 + }; + exports.HEX_MAP = { + 0: 0, + 1: 1, + 2: 2, + 3: 3, + 4: 4, + 5: 5, + 6: 6, + 7: 7, + 8: 8, + 9: 9, + A: 10, + B: 11, + C: 12, + D: 13, + E: 14, + F: 15, + a: 10, + b: 11, + c: 12, + d: 13, + e: 14, + f: 15 + }; + exports.NUM = [ + "0", + "1", + "2", + "3", + "4", + "5", + "6", + "7", + "8", + "9" + ]; + exports.ALPHANUM = exports.ALPHA.concat(exports.NUM); + exports.MARK = [ + "-", + "_", + ".", + "!", + "~", + "*", + "'", + "(", + ")" + ]; + exports.USERINFO_CHARS = exports.ALPHANUM.concat(exports.MARK).concat([ + "%", + ";", + ":", + "&", + "=", + "+", + "$", + "," + ]); + exports.STRICT_URL_CHAR = [ + "!", + "\"", + "$", + "%", + "&", + "'", + "(", + ")", + "*", + "+", + ",", + "-", + ".", + "/", + ":", + ";", + "<", + "=", + ">", + "@", + "[", + "\\", + "]", + "^", + "_", + "`", + "{", + "|", + "}", + "~" + ].concat(exports.ALPHANUM); + exports.URL_CHAR = exports.STRICT_URL_CHAR.concat([" ", "\f"]); + for (let i = 128; i <= 255; i++) exports.URL_CHAR.push(i); + exports.HEX = exports.NUM.concat([ + "a", + "b", + "c", + "d", + "e", + "f", + "A", + "B", + "C", + "D", + "E", + "F" + ]); + exports.STRICT_TOKEN = [ + "!", + "#", + "$", + "%", + "&", + "'", + "*", + "+", + "-", + ".", + "^", + "_", + "`", + "|", + "~" + ].concat(exports.ALPHANUM); + exports.TOKEN = exports.STRICT_TOKEN.concat([" "]); + exports.HEADER_CHARS = [" "]; + for (let i = 32; i <= 255; i++) if (i !== 127) exports.HEADER_CHARS.push(i); + exports.CONNECTION_TOKEN_CHARS = exports.HEADER_CHARS.filter((c) => c !== 44); + exports.MAJOR = exports.NUM_MAP; + exports.MINOR = exports.MAJOR; + var HEADER_STATE; + (function(HEADER_STATE) { + HEADER_STATE[HEADER_STATE["GENERAL"] = 0] = "GENERAL"; + HEADER_STATE[HEADER_STATE["CONNECTION"] = 1] = "CONNECTION"; + HEADER_STATE[HEADER_STATE["CONTENT_LENGTH"] = 2] = "CONTENT_LENGTH"; + HEADER_STATE[HEADER_STATE["TRANSFER_ENCODING"] = 3] = "TRANSFER_ENCODING"; + HEADER_STATE[HEADER_STATE["UPGRADE"] = 4] = "UPGRADE"; + HEADER_STATE[HEADER_STATE["CONNECTION_KEEP_ALIVE"] = 5] = "CONNECTION_KEEP_ALIVE"; + HEADER_STATE[HEADER_STATE["CONNECTION_CLOSE"] = 6] = "CONNECTION_CLOSE"; + HEADER_STATE[HEADER_STATE["CONNECTION_UPGRADE"] = 7] = "CONNECTION_UPGRADE"; + HEADER_STATE[HEADER_STATE["TRANSFER_ENCODING_CHUNKED"] = 8] = "TRANSFER_ENCODING_CHUNKED"; + })(HEADER_STATE = exports.HEADER_STATE || (exports.HEADER_STATE = {})); + exports.SPECIAL_HEADERS = { + "connection": HEADER_STATE.CONNECTION, + "content-length": HEADER_STATE.CONTENT_LENGTH, + "proxy-connection": HEADER_STATE.CONNECTION, + "transfer-encoding": HEADER_STATE.TRANSFER_ENCODING, + "upgrade": HEADER_STATE.UPGRADE + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/llhttp/llhttp-wasm.js +var require_llhttp_wasm = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { Buffer: Buffer$2 } = __require("node:buffer"); + module.exports = Buffer$2.from("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", "base64"); +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/llhttp/llhttp_simd-wasm.js +var require_llhttp_simd_wasm = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { Buffer: Buffer$1 } = __require("node:buffer"); + module.exports = Buffer$1.from("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", "base64"); +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fetch/constants.js +var require_constants$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const corsSafeListedMethods = [ + "GET", + "HEAD", + "POST" + ]; + const corsSafeListedMethodsSet = new Set(corsSafeListedMethods); + const nullBodyStatus = [ + 101, + 204, + 205, + 304 + ]; + const redirectStatus = [ + 301, + 302, + 303, + 307, + 308 + ]; + const redirectStatusSet = new Set(redirectStatus); + /** + * @see https://fetch.spec.whatwg.org/#block-bad-port + */ + const badPorts = [ + "1", + "7", + "9", + "11", + "13", + "15", + "17", + "19", + "20", + "21", + "22", + "23", + "25", + "37", + "42", + "43", + "53", + "69", + "77", + "79", + "87", + "95", + "101", + "102", + "103", + "104", + "109", + "110", + "111", + "113", + "115", + "117", + "119", + "123", + "135", + "137", + "139", + "143", + "161", + "179", + "389", + "427", + "465", + "512", + "513", + "514", + "515", + "526", + "530", + "531", + "532", + "540", + "548", + "554", + "556", + "563", + "587", + "601", + "636", + "989", + "990", + "993", + "995", + "1719", + "1720", + "1723", + "2049", + "3659", + "4045", + "4190", + "5060", + "5061", + "6000", + "6566", + "6665", + "6666", + "6667", + "6668", + "6669", + "6679", + "6697", + "10080" + ]; + const badPortsSet = new Set(badPorts); + /** + * @see https://w3c.github.io/webappsec-referrer-policy/#referrer-policies + */ + const referrerPolicy = [ + "", + "no-referrer", + "no-referrer-when-downgrade", + "same-origin", + "origin", + "strict-origin", + "origin-when-cross-origin", + "strict-origin-when-cross-origin", + "unsafe-url" + ]; + const referrerPolicySet = new Set(referrerPolicy); + const requestRedirect = [ + "follow", + "manual", + "error" + ]; + const safeMethods = [ + "GET", + "HEAD", + "OPTIONS", + "TRACE" + ]; + const safeMethodsSet = new Set(safeMethods); + const requestMode = [ + "navigate", + "same-origin", + "no-cors", + "cors" + ]; + const requestCredentials = [ + "omit", + "same-origin", + "include" + ]; + const requestCache = [ + "default", + "no-store", + "reload", + "no-cache", + "force-cache", + "only-if-cached" + ]; + /** + * @see https://fetch.spec.whatwg.org/#request-body-header-name + */ + const requestBodyHeader = [ + "content-encoding", + "content-language", + "content-location", + "content-type", + "content-length" + ]; + /** + * @see https://fetch.spec.whatwg.org/#enumdef-requestduplex + */ + const requestDuplex = ["half"]; + /** + * @see http://fetch.spec.whatwg.org/#forbidden-method + */ + const forbiddenMethods = [ + "CONNECT", + "TRACE", + "TRACK" + ]; + const forbiddenMethodsSet = new Set(forbiddenMethods); + const subresource = [ + "audio", + "audioworklet", + "font", + "image", + "manifest", + "paintworklet", + "script", + "style", + "track", + "video", + "xslt", + "" + ]; + module.exports = { + subresource, + forbiddenMethods, + requestBodyHeader, + referrerPolicy, + requestRedirect, + requestMode, + requestCredentials, + requestCache, + redirectStatus, + corsSafeListedMethods, + nullBodyStatus, + safeMethods, + badPorts, + requestDuplex, + subresourceSet: new Set(subresource), + badPortsSet, + redirectStatusSet, + corsSafeListedMethodsSet, + safeMethodsSet, + forbiddenMethodsSet, + referrerPolicySet + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fetch/global.js +var require_global$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const globalOrigin = Symbol.for("undici.globalOrigin.1"); + function getGlobalOrigin() { + return globalThis[globalOrigin]; + } + function setGlobalOrigin(newOrigin) { + if (newOrigin === void 0) { + Object.defineProperty(globalThis, globalOrigin, { + value: void 0, + writable: true, + enumerable: false, + configurable: false + }); + return; + } + const parsedURL = new URL(newOrigin); + if (parsedURL.protocol !== "http:" && parsedURL.protocol !== "https:") throw new TypeError(`Only http & https urls are allowed, received ${parsedURL.protocol}`); + Object.defineProperty(globalThis, globalOrigin, { + value: parsedURL, + writable: true, + enumerable: false, + configurable: false + }); + } + module.exports = { + getGlobalOrigin, + setGlobalOrigin + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fetch/data-url.js +var require_data_url = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const assert$23 = __require("node:assert"); + const encoder = new TextEncoder(); + /** + * @see https://mimesniff.spec.whatwg.org/#http-token-code-point + */ + const HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+\-.^_|~A-Za-z0-9]+$/; + const HTTP_WHITESPACE_REGEX = /[\u000A\u000D\u0009\u0020]/; + const ASCII_WHITESPACE_REPLACE_REGEX = /[\u0009\u000A\u000C\u000D\u0020]/g; + /** + * @see https://mimesniff.spec.whatwg.org/#http-quoted-string-token-code-point + */ + const HTTP_QUOTED_STRING_TOKENS = /^[\u0009\u0020-\u007E\u0080-\u00FF]+$/; + /** @param {URL} dataURL */ + function dataURLProcessor(dataURL) { + assert$23(dataURL.protocol === "data:"); + let input = URLSerializer(dataURL, true); + input = input.slice(5); + const position = { position: 0 }; + let mimeType = collectASequenceOfCodePointsFast(",", input, position); + const mimeTypeLength = mimeType.length; + mimeType = removeASCIIWhitespace(mimeType, true, true); + if (position.position >= input.length) return "failure"; + position.position++; + let body = stringPercentDecode(input.slice(mimeTypeLength + 1)); + if (/;(\u0020){0,}base64$/i.test(mimeType)) { + body = forgivingBase64(isomorphicDecode(body)); + if (body === "failure") return "failure"; + mimeType = mimeType.slice(0, -6); + mimeType = mimeType.replace(/(\u0020)+$/, ""); + mimeType = mimeType.slice(0, -1); + } + if (mimeType.startsWith(";")) mimeType = "text/plain" + mimeType; + let mimeTypeRecord = parseMIMEType(mimeType); + if (mimeTypeRecord === "failure") mimeTypeRecord = parseMIMEType("text/plain;charset=US-ASCII"); + return { + mimeType: mimeTypeRecord, + body + }; + } + /** + * @param {URL} url + * @param {boolean} excludeFragment + */ + function URLSerializer(url, excludeFragment = false) { + if (!excludeFragment) return url.href; + const href = url.href; + const hashLength = url.hash.length; + const serialized = hashLength === 0 ? href : href.substring(0, href.length - hashLength); + if (!hashLength && href.endsWith("#")) return serialized.slice(0, -1); + return serialized; + } + /** + * @param {(char: string) => boolean} condition + * @param {string} input + * @param {{ position: number }} position + */ + function collectASequenceOfCodePoints(condition, input, position) { + let result = ""; + while (position.position < input.length && condition(input[position.position])) { + result += input[position.position]; + position.position++; + } + return result; + } + /** + * A faster collectASequenceOfCodePoints that only works when comparing a single character. + * @param {string} char + * @param {string} input + * @param {{ position: number }} position + */ + function collectASequenceOfCodePointsFast(char, input, position) { + const idx = input.indexOf(char, position.position); + const start = position.position; + if (idx === -1) { + position.position = input.length; + return input.slice(start); + } + position.position = idx; + return input.slice(start, position.position); + } + /** @param {string} input */ + function stringPercentDecode(input) { + return percentDecode(encoder.encode(input)); + } + /** + * @param {number} byte + */ + function isHexCharByte(byte) { + return byte >= 48 && byte <= 57 || byte >= 65 && byte <= 70 || byte >= 97 && byte <= 102; + } + /** + * @param {number} byte + */ + function hexByteToNumber(byte) { + return byte >= 48 && byte <= 57 ? byte - 48 : (byte & 223) - 55; + } + /** @param {Uint8Array} input */ + function percentDecode(input) { + const length = input.length; + /** @type {Uint8Array} */ + const output = new Uint8Array(length); + let j = 0; + for (let i = 0; i < length; ++i) { + const byte = input[i]; + if (byte !== 37) output[j++] = byte; + else if (byte === 37 && !(isHexCharByte(input[i + 1]) && isHexCharByte(input[i + 2]))) output[j++] = 37; + else { + output[j++] = hexByteToNumber(input[i + 1]) << 4 | hexByteToNumber(input[i + 2]); + i += 2; + } + } + return length === j ? output : output.subarray(0, j); + } + /** @param {string} input */ + function parseMIMEType(input) { + input = removeHTTPWhitespace(input, true, true); + const position = { position: 0 }; + const type = collectASequenceOfCodePointsFast("/", input, position); + if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type)) return "failure"; + if (position.position > input.length) return "failure"; + position.position++; + let subtype = collectASequenceOfCodePointsFast(";", input, position); + subtype = removeHTTPWhitespace(subtype, false, true); + if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) return "failure"; + const typeLowercase = type.toLowerCase(); + const subtypeLowercase = subtype.toLowerCase(); + const mimeType = { + type: typeLowercase, + subtype: subtypeLowercase, + /** @type {Map} */ + parameters: /* @__PURE__ */ new Map(), + essence: `${typeLowercase}/${subtypeLowercase}` + }; + while (position.position < input.length) { + position.position++; + collectASequenceOfCodePoints((char) => HTTP_WHITESPACE_REGEX.test(char), input, position); + let parameterName = collectASequenceOfCodePoints((char) => char !== ";" && char !== "=", input, position); + parameterName = parameterName.toLowerCase(); + if (position.position < input.length) { + if (input[position.position] === ";") continue; + position.position++; + } + if (position.position > input.length) break; + let parameterValue = null; + if (input[position.position] === "\"") { + parameterValue = collectAnHTTPQuotedString(input, position, true); + collectASequenceOfCodePointsFast(";", input, position); + } else { + parameterValue = collectASequenceOfCodePointsFast(";", input, position); + parameterValue = removeHTTPWhitespace(parameterValue, false, true); + if (parameterValue.length === 0) continue; + } + if (parameterName.length !== 0 && HTTP_TOKEN_CODEPOINTS.test(parameterName) && (parameterValue.length === 0 || HTTP_QUOTED_STRING_TOKENS.test(parameterValue)) && !mimeType.parameters.has(parameterName)) mimeType.parameters.set(parameterName, parameterValue); + } + return mimeType; + } + /** @param {string} data */ + function forgivingBase64(data) { + data = data.replace(ASCII_WHITESPACE_REPLACE_REGEX, ""); + let dataLength = data.length; + if (dataLength % 4 === 0) { + if (data.charCodeAt(dataLength - 1) === 61) { + --dataLength; + if (data.charCodeAt(dataLength - 1) === 61) --dataLength; + } + } + if (dataLength % 4 === 1) return "failure"; + if (/[^+/0-9A-Za-z]/.test(data.length === dataLength ? data : data.substring(0, dataLength))) return "failure"; + const buffer = Buffer.from(data, "base64"); + return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength); + } + /** + * @param {string} input + * @param {{ position: number }} position + * @param {boolean?} extractValue + */ + function collectAnHTTPQuotedString(input, position, extractValue) { + const positionStart = position.position; + let value = ""; + assert$23(input[position.position] === "\""); + position.position++; + while (true) { + value += collectASequenceOfCodePoints((char) => char !== "\"" && char !== "\\", input, position); + if (position.position >= input.length) break; + const quoteOrBackslash = input[position.position]; + position.position++; + if (quoteOrBackslash === "\\") { + if (position.position >= input.length) { + value += "\\"; + break; + } + value += input[position.position]; + position.position++; + } else { + assert$23(quoteOrBackslash === "\""); + break; + } + } + if (extractValue) return value; + return input.slice(positionStart, position.position); + } + /** + * @see https://mimesniff.spec.whatwg.org/#serialize-a-mime-type + */ + function serializeAMimeType(mimeType) { + assert$23(mimeType !== "failure"); + const { parameters, essence } = mimeType; + let serialization = essence; + for (let [name, value] of parameters.entries()) { + serialization += ";"; + serialization += name; + serialization += "="; + if (!HTTP_TOKEN_CODEPOINTS.test(value)) { + value = value.replace(/(\\|")/g, "\\$1"); + value = "\"" + value; + value += "\""; + } + serialization += value; + } + return serialization; + } + /** + * @see https://fetch.spec.whatwg.org/#http-whitespace + * @param {number} char + */ + function isHTTPWhiteSpace(char) { + return char === 13 || char === 10 || char === 9 || char === 32; + } + /** + * @see https://fetch.spec.whatwg.org/#http-whitespace + * @param {string} str + * @param {boolean} [leading=true] + * @param {boolean} [trailing=true] + */ + function removeHTTPWhitespace(str, leading = true, trailing = true) { + return removeChars(str, leading, trailing, isHTTPWhiteSpace); + } + /** + * @see https://infra.spec.whatwg.org/#ascii-whitespace + * @param {number} char + */ + function isASCIIWhitespace(char) { + return char === 13 || char === 10 || char === 9 || char === 12 || char === 32; + } + /** + * @see https://infra.spec.whatwg.org/#strip-leading-and-trailing-ascii-whitespace + * @param {string} str + * @param {boolean} [leading=true] + * @param {boolean} [trailing=true] + */ + function removeASCIIWhitespace(str, leading = true, trailing = true) { + return removeChars(str, leading, trailing, isASCIIWhitespace); + } + /** + * @param {string} str + * @param {boolean} leading + * @param {boolean} trailing + * @param {(charCode: number) => boolean} predicate + * @returns + */ + function removeChars(str, leading, trailing, predicate) { + let lead = 0; + let trail = str.length - 1; + if (leading) while (lead < str.length && predicate(str.charCodeAt(lead))) lead++; + if (trailing) while (trail > 0 && predicate(str.charCodeAt(trail))) trail--; + return lead === 0 && trail === str.length - 1 ? str : str.slice(lead, trail + 1); + } + /** + * @see https://infra.spec.whatwg.org/#isomorphic-decode + * @param {Uint8Array} input + * @returns {string} + */ + function isomorphicDecode(input) { + const length = input.length; + if (65535 > length) return String.fromCharCode.apply(null, input); + let result = ""; + let i = 0; + let addition = 65535; + while (i < length) { + if (i + addition > length) addition = length - i; + result += String.fromCharCode.apply(null, input.subarray(i, i += addition)); + } + return result; + } + /** + * @see https://mimesniff.spec.whatwg.org/#minimize-a-supported-mime-type + * @param {Exclude, 'failure'>} mimeType + */ + function minimizeSupportedMimeType(mimeType) { + switch (mimeType.essence) { + case "application/ecmascript": + case "application/javascript": + case "application/x-ecmascript": + case "application/x-javascript": + case "text/ecmascript": + case "text/javascript": + case "text/javascript1.0": + case "text/javascript1.1": + case "text/javascript1.2": + case "text/javascript1.3": + case "text/javascript1.4": + case "text/javascript1.5": + case "text/jscript": + case "text/livescript": + case "text/x-ecmascript": + case "text/x-javascript": return "text/javascript"; + case "application/json": + case "text/json": return "application/json"; + case "image/svg+xml": return "image/svg+xml"; + case "text/xml": + case "application/xml": return "application/xml"; + } + if (mimeType.subtype.endsWith("+json")) return "application/json"; + if (mimeType.subtype.endsWith("+xml")) return "application/xml"; + return ""; + } + module.exports = { + dataURLProcessor, + URLSerializer, + collectASequenceOfCodePoints, + collectASequenceOfCodePointsFast, + stringPercentDecode, + parseMIMEType, + collectAnHTTPQuotedString, + serializeAMimeType, + removeChars, + removeHTTPWhitespace, + minimizeSupportedMimeType, + HTTP_TOKEN_CODEPOINTS, + isomorphicDecode + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fetch/webidl.js +var require_webidl = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { types: types$3, inspect } = __require("node:util"); + const { markAsUncloneable } = __require("node:worker_threads"); + const { toUSVString } = require_util$7(); + /** @type {import('../../../types/webidl').Webidl} */ + const webidl = {}; + webidl.converters = {}; + webidl.util = {}; + webidl.errors = {}; + webidl.errors.exception = function(message) { + return /* @__PURE__ */ new TypeError(`${message.header}: ${message.message}`); + }; + webidl.errors.conversionFailed = function(context) { + const plural = context.types.length === 1 ? "" : " one of"; + const message = `${context.argument} could not be converted to${plural}: ${context.types.join(", ")}.`; + return webidl.errors.exception({ + header: context.prefix, + message + }); + }; + webidl.errors.invalidArgument = function(context) { + return webidl.errors.exception({ + header: context.prefix, + message: `"${context.value}" is an invalid ${context.type}.` + }); + }; + webidl.brandCheck = function(V, I, opts) { + if (opts?.strict !== false) { + if (!(V instanceof I)) { + const err = /* @__PURE__ */ new TypeError("Illegal invocation"); + err.code = "ERR_INVALID_THIS"; + throw err; + } + } else if (V?.[Symbol.toStringTag] !== I.prototype[Symbol.toStringTag]) { + const err = /* @__PURE__ */ new TypeError("Illegal invocation"); + err.code = "ERR_INVALID_THIS"; + throw err; + } + }; + webidl.argumentLengthCheck = function({ length }, min, ctx) { + if (length < min) throw webidl.errors.exception({ + message: `${min} argument${min !== 1 ? "s" : ""} required, but${length ? " only" : ""} ${length} found.`, + header: ctx + }); + }; + webidl.illegalConstructor = function() { + throw webidl.errors.exception({ + header: "TypeError", + message: "Illegal constructor" + }); + }; + webidl.util.Type = function(V) { + switch (typeof V) { + case "undefined": return "Undefined"; + case "boolean": return "Boolean"; + case "string": return "String"; + case "symbol": return "Symbol"; + case "number": return "Number"; + case "bigint": return "BigInt"; + case "function": + case "object": + if (V === null) return "Null"; + return "Object"; + } + }; + webidl.util.markAsUncloneable = markAsUncloneable || (() => {}); + webidl.util.ConvertToInt = function(V, bitLength, signedness, opts) { + let upperBound; + let lowerBound; + if (bitLength === 64) { + upperBound = Math.pow(2, 53) - 1; + if (signedness === "unsigned") lowerBound = 0; + else lowerBound = Math.pow(-2, 53) + 1; + } else if (signedness === "unsigned") { + lowerBound = 0; + upperBound = Math.pow(2, bitLength) - 1; + } else { + lowerBound = Math.pow(-2, bitLength) - 1; + upperBound = Math.pow(2, bitLength - 1) - 1; + } + let x = Number(V); + if (x === 0) x = 0; + if (opts?.enforceRange === true) { + if (Number.isNaN(x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) throw webidl.errors.exception({ + header: "Integer conversion", + message: `Could not convert ${webidl.util.Stringify(V)} to an integer.` + }); + x = webidl.util.IntegerPart(x); + if (x < lowerBound || x > upperBound) throw webidl.errors.exception({ + header: "Integer conversion", + message: `Value must be between ${lowerBound}-${upperBound}, got ${x}.` + }); + return x; + } + if (!Number.isNaN(x) && opts?.clamp === true) { + x = Math.min(Math.max(x, lowerBound), upperBound); + if (Math.floor(x) % 2 === 0) x = Math.floor(x); + else x = Math.ceil(x); + return x; + } + if (Number.isNaN(x) || x === 0 && Object.is(0, x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) return 0; + x = webidl.util.IntegerPart(x); + x = x % Math.pow(2, bitLength); + if (signedness === "signed" && x >= Math.pow(2, bitLength) - 1) return x - Math.pow(2, bitLength); + return x; + }; + webidl.util.IntegerPart = function(n) { + const r = Math.floor(Math.abs(n)); + if (n < 0) return -1 * r; + return r; + }; + webidl.util.Stringify = function(V) { + switch (webidl.util.Type(V)) { + case "Symbol": return `Symbol(${V.description})`; + case "Object": return inspect(V); + case "String": return `"${V}"`; + default: return `${V}`; + } + }; + webidl.sequenceConverter = function(converter) { + return (V, prefix, argument, Iterable) => { + if (webidl.util.Type(V) !== "Object") throw webidl.errors.exception({ + header: prefix, + message: `${argument} (${webidl.util.Stringify(V)}) is not iterable.` + }); + /** @type {Generator} */ + const method = typeof Iterable === "function" ? Iterable() : V?.[Symbol.iterator]?.(); + const seq = []; + let index = 0; + if (method === void 0 || typeof method.next !== "function") throw webidl.errors.exception({ + header: prefix, + message: `${argument} is not iterable.` + }); + while (true) { + const { done, value } = method.next(); + if (done) break; + seq.push(converter(value, prefix, `${argument}[${index++}]`)); + } + return seq; + }; + }; + webidl.recordConverter = function(keyConverter, valueConverter) { + return (O, prefix, argument) => { + if (webidl.util.Type(O) !== "Object") throw webidl.errors.exception({ + header: prefix, + message: `${argument} ("${webidl.util.Type(O)}") is not an Object.` + }); + const result = {}; + if (!types$3.isProxy(O)) { + const keys = [...Object.getOwnPropertyNames(O), ...Object.getOwnPropertySymbols(O)]; + for (const key of keys) { + const typedKey = keyConverter(key, prefix, argument); + result[typedKey] = valueConverter(O[key], prefix, argument); + } + return result; + } + const keys = Reflect.ownKeys(O); + for (const key of keys) if (Reflect.getOwnPropertyDescriptor(O, key)?.enumerable) { + const typedKey = keyConverter(key, prefix, argument); + result[typedKey] = valueConverter(O[key], prefix, argument); + } + return result; + }; + }; + webidl.interfaceConverter = function(i) { + return (V, prefix, argument, opts) => { + if (opts?.strict !== false && !(V instanceof i)) throw webidl.errors.exception({ + header: prefix, + message: `Expected ${argument} ("${webidl.util.Stringify(V)}") to be an instance of ${i.name}.` + }); + return V; + }; + }; + webidl.dictionaryConverter = function(converters) { + return (dictionary, prefix, argument) => { + const type = webidl.util.Type(dictionary); + const dict = {}; + if (type === "Null" || type === "Undefined") return dict; + else if (type !== "Object") throw webidl.errors.exception({ + header: prefix, + message: `Expected ${dictionary} to be one of: Null, Undefined, Object.` + }); + for (const options of converters) { + const { key, defaultValue, required, converter } = options; + if (required === true) { + if (!Object.hasOwn(dictionary, key)) throw webidl.errors.exception({ + header: prefix, + message: `Missing required key "${key}".` + }); + } + let value = dictionary[key]; + const hasDefault = Object.hasOwn(options, "defaultValue"); + if (hasDefault && value !== null) value ??= defaultValue(); + if (required || hasDefault || value !== void 0) { + value = converter(value, prefix, `${argument}.${key}`); + if (options.allowedValues && !options.allowedValues.includes(value)) throw webidl.errors.exception({ + header: prefix, + message: `${value} is not an accepted type. Expected one of ${options.allowedValues.join(", ")}.` + }); + dict[key] = value; + } + } + return dict; + }; + }; + webidl.nullableConverter = function(converter) { + return (V, prefix, argument) => { + if (V === null) return V; + return converter(V, prefix, argument); + }; + }; + webidl.converters.DOMString = function(V, prefix, argument, opts) { + if (V === null && opts?.legacyNullToEmptyString) return ""; + if (typeof V === "symbol") throw webidl.errors.exception({ + header: prefix, + message: `${argument} is a symbol, which cannot be converted to a DOMString.` + }); + return String(V); + }; + webidl.converters.ByteString = function(V, prefix, argument) { + const x = webidl.converters.DOMString(V, prefix, argument); + for (let index = 0; index < x.length; index++) if (x.charCodeAt(index) > 255) throw new TypeError(`Cannot convert argument to a ByteString because the character at index ${index} has a value of ${x.charCodeAt(index)} which is greater than 255.`); + return x; + }; + webidl.converters.USVString = toUSVString; + webidl.converters.boolean = function(V) { + return Boolean(V); + }; + webidl.converters.any = function(V) { + return V; + }; + webidl.converters["long long"] = function(V, prefix, argument) { + return webidl.util.ConvertToInt(V, 64, "signed", void 0, prefix, argument); + }; + webidl.converters["unsigned long long"] = function(V, prefix, argument) { + return webidl.util.ConvertToInt(V, 64, "unsigned", void 0, prefix, argument); + }; + webidl.converters["unsigned long"] = function(V, prefix, argument) { + return webidl.util.ConvertToInt(V, 32, "unsigned", void 0, prefix, argument); + }; + webidl.converters["unsigned short"] = function(V, prefix, argument, opts) { + return webidl.util.ConvertToInt(V, 16, "unsigned", opts, prefix, argument); + }; + webidl.converters.ArrayBuffer = function(V, prefix, argument, opts) { + if (webidl.util.Type(V) !== "Object" || !types$3.isAnyArrayBuffer(V)) throw webidl.errors.conversionFailed({ + prefix, + argument: `${argument} ("${webidl.util.Stringify(V)}")`, + types: ["ArrayBuffer"] + }); + if (opts?.allowShared === false && types$3.isSharedArrayBuffer(V)) throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "SharedArrayBuffer is not allowed." + }); + if (V.resizable || V.growable) throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "Received a resizable ArrayBuffer." + }); + return V; + }; + webidl.converters.TypedArray = function(V, T, prefix, name, opts) { + if (webidl.util.Type(V) !== "Object" || !types$3.isTypedArray(V) || V.constructor.name !== T.name) throw webidl.errors.conversionFailed({ + prefix, + argument: `${name} ("${webidl.util.Stringify(V)}")`, + types: [T.name] + }); + if (opts?.allowShared === false && types$3.isSharedArrayBuffer(V.buffer)) throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "SharedArrayBuffer is not allowed." + }); + if (V.buffer.resizable || V.buffer.growable) throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "Received a resizable ArrayBuffer." + }); + return V; + }; + webidl.converters.DataView = function(V, prefix, name, opts) { + if (webidl.util.Type(V) !== "Object" || !types$3.isDataView(V)) throw webidl.errors.exception({ + header: prefix, + message: `${name} is not a DataView.` + }); + if (opts?.allowShared === false && types$3.isSharedArrayBuffer(V.buffer)) throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "SharedArrayBuffer is not allowed." + }); + if (V.buffer.resizable || V.buffer.growable) throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "Received a resizable ArrayBuffer." + }); + return V; + }; + webidl.converters.BufferSource = function(V, prefix, name, opts) { + if (types$3.isAnyArrayBuffer(V)) return webidl.converters.ArrayBuffer(V, prefix, name, { + ...opts, + allowShared: false + }); + if (types$3.isTypedArray(V)) return webidl.converters.TypedArray(V, V.constructor, prefix, name, { + ...opts, + allowShared: false + }); + if (types$3.isDataView(V)) return webidl.converters.DataView(V, prefix, name, { + ...opts, + allowShared: false + }); + throw webidl.errors.conversionFailed({ + prefix, + argument: `${name} ("${webidl.util.Stringify(V)}")`, + types: ["BufferSource"] + }); + }; + webidl.converters["sequence"] = webidl.sequenceConverter(webidl.converters.ByteString); + webidl.converters["sequence>"] = webidl.sequenceConverter(webidl.converters["sequence"]); + webidl.converters["record"] = webidl.recordConverter(webidl.converters.ByteString, webidl.converters.ByteString); + module.exports = { webidl }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fetch/util.js +var require_util$6 = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { Transform: Transform$2 } = __require("node:stream"); + const zlib$1 = __require("node:zlib"); + const { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = require_constants$2(); + const { getGlobalOrigin } = require_global$1(); + const { collectASequenceOfCodePoints, collectAnHTTPQuotedString, removeChars, parseMIMEType } = require_data_url(); + const { performance: performance$1 } = __require("node:perf_hooks"); + const { isBlobLike, ReadableStreamFrom, isValidHTTPToken, normalizedMethodRecordsBase } = require_util$7(); + const assert$22 = __require("node:assert"); + const { isUint8Array } = __require("node:util/types"); + const { webidl } = require_webidl(); + let supportedHashes = []; + /** @type {import('crypto')} */ + let crypto; + try { + crypto = __require("node:crypto"); + const possibleRelevantHashes = [ + "sha256", + "sha384", + "sha512" + ]; + supportedHashes = crypto.getHashes().filter((hash) => possibleRelevantHashes.includes(hash)); + } catch {} + function responseURL(response) { + const urlList = response.urlList; + const length = urlList.length; + return length === 0 ? null : urlList[length - 1].toString(); + } + function responseLocationURL(response, requestFragment) { + if (!redirectStatusSet.has(response.status)) return null; + let location = response.headersList.get("location", true); + if (location !== null && isValidHeaderValue(location)) { + if (!isValidEncodedURL(location)) location = normalizeBinaryStringToUtf8(location); + location = new URL(location, responseURL(response)); + } + if (location && !location.hash) location.hash = requestFragment; + return location; + } + /** + * @see https://www.rfc-editor.org/rfc/rfc1738#section-2.2 + * @param {string} url + * @returns {boolean} + */ + function isValidEncodedURL(url) { + for (let i = 0; i < url.length; ++i) { + const code = url.charCodeAt(i); + if (code > 126 || code < 32) return false; + } + return true; + } + /** + * If string contains non-ASCII characters, assumes it's UTF-8 encoded and decodes it. + * Since UTF-8 is a superset of ASCII, this will work for ASCII strings as well. + * @param {string} value + * @returns {string} + */ + function normalizeBinaryStringToUtf8(value) { + return Buffer.from(value, "binary").toString("utf8"); + } + /** @returns {URL} */ + function requestCurrentURL(request) { + return request.urlList[request.urlList.length - 1]; + } + function requestBadPort(request) { + const url = requestCurrentURL(request); + if (urlIsHttpHttpsScheme(url) && badPortsSet.has(url.port)) return "blocked"; + return "allowed"; + } + function isErrorLike(object) { + return object instanceof Error || object?.constructor?.name === "Error" || object?.constructor?.name === "DOMException"; + } + function isValidReasonPhrase(statusText) { + for (let i = 0; i < statusText.length; ++i) { + const c = statusText.charCodeAt(i); + if (!(c === 9 || c >= 32 && c <= 126 || c >= 128 && c <= 255)) return false; + } + return true; + } + /** + * @see https://fetch.spec.whatwg.org/#header-name + * @param {string} potentialValue + */ + const isValidHeaderName = isValidHTTPToken; + /** + * @see https://fetch.spec.whatwg.org/#header-value + * @param {string} potentialValue + */ + function isValidHeaderValue(potentialValue) { + return (potentialValue[0] === " " || potentialValue[0] === " " || potentialValue[potentialValue.length - 1] === " " || potentialValue[potentialValue.length - 1] === " " || potentialValue.includes("\n") || potentialValue.includes("\r") || potentialValue.includes("\0")) === false; + } + function setRequestReferrerPolicyOnRedirect(request, actualResponse) { + const { headersList } = actualResponse; + const policyHeader = (headersList.get("referrer-policy", true) ?? "").split(","); + let policy = ""; + if (policyHeader.length > 0) for (let i = policyHeader.length; i !== 0; i--) { + const token = policyHeader[i - 1].trim(); + if (referrerPolicyTokens.has(token)) { + policy = token; + break; + } + } + if (policy !== "") request.referrerPolicy = policy; + } + function crossOriginResourcePolicyCheck() { + return "allowed"; + } + function corsCheck() { + return "success"; + } + function TAOCheck() { + return "success"; + } + function appendFetchMetadata(httpRequest) { + let header = null; + header = httpRequest.mode; + httpRequest.headersList.set("sec-fetch-mode", header, true); + } + function appendRequestOriginHeader(request) { + let serializedOrigin = request.origin; + if (serializedOrigin === "client" || serializedOrigin === void 0) return; + if (request.responseTainting === "cors" || request.mode === "websocket") request.headersList.append("origin", serializedOrigin, true); + else if (request.method !== "GET" && request.method !== "HEAD") { + switch (request.referrerPolicy) { + case "no-referrer": + serializedOrigin = null; + break; + case "no-referrer-when-downgrade": + case "strict-origin": + case "strict-origin-when-cross-origin": + if (request.origin && urlHasHttpsScheme(request.origin) && !urlHasHttpsScheme(requestCurrentURL(request))) serializedOrigin = null; + break; + case "same-origin": if (!sameOrigin(request, requestCurrentURL(request))) serializedOrigin = null; + } + request.headersList.append("origin", serializedOrigin, true); + } + } + function coarsenTime(timestamp, crossOriginIsolatedCapability) { + return timestamp; + } + function clampAndCoarsenConnectionTimingInfo(connectionTimingInfo, defaultStartTime, crossOriginIsolatedCapability) { + if (!connectionTimingInfo?.startTime || connectionTimingInfo.startTime < defaultStartTime) return { + domainLookupStartTime: defaultStartTime, + domainLookupEndTime: defaultStartTime, + connectionStartTime: defaultStartTime, + connectionEndTime: defaultStartTime, + secureConnectionStartTime: defaultStartTime, + ALPNNegotiatedProtocol: connectionTimingInfo?.ALPNNegotiatedProtocol + }; + return { + domainLookupStartTime: coarsenTime(connectionTimingInfo.domainLookupStartTime, crossOriginIsolatedCapability), + domainLookupEndTime: coarsenTime(connectionTimingInfo.domainLookupEndTime, crossOriginIsolatedCapability), + connectionStartTime: coarsenTime(connectionTimingInfo.connectionStartTime, crossOriginIsolatedCapability), + connectionEndTime: coarsenTime(connectionTimingInfo.connectionEndTime, crossOriginIsolatedCapability), + secureConnectionStartTime: coarsenTime(connectionTimingInfo.secureConnectionStartTime, crossOriginIsolatedCapability), + ALPNNegotiatedProtocol: connectionTimingInfo.ALPNNegotiatedProtocol + }; + } + function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) { + return coarsenTime(performance$1.now(), crossOriginIsolatedCapability); + } + function createOpaqueTimingInfo(timingInfo) { + return { + startTime: timingInfo.startTime ?? 0, + redirectStartTime: 0, + redirectEndTime: 0, + postRedirectStartTime: timingInfo.startTime ?? 0, + finalServiceWorkerStartTime: 0, + finalNetworkResponseStartTime: 0, + finalNetworkRequestStartTime: 0, + endTime: 0, + encodedBodySize: 0, + decodedBodySize: 0, + finalConnectionTimingInfo: null + }; + } + function makePolicyContainer() { + return { referrerPolicy: "strict-origin-when-cross-origin" }; + } + function clonePolicyContainer(policyContainer) { + return { referrerPolicy: policyContainer.referrerPolicy }; + } + function determineRequestsReferrer(request) { + const policy = request.referrerPolicy; + assert$22(policy); + let referrerSource = null; + if (request.referrer === "client") { + const globalOrigin = getGlobalOrigin(); + if (!globalOrigin || globalOrigin.origin === "null") return "no-referrer"; + referrerSource = new URL(globalOrigin); + } else if (request.referrer instanceof URL) referrerSource = request.referrer; + let referrerURL = stripURLForReferrer(referrerSource); + const referrerOrigin = stripURLForReferrer(referrerSource, true); + if (referrerURL.toString().length > 4096) referrerURL = referrerOrigin; + const areSameOrigin = sameOrigin(request, referrerURL); + const isNonPotentiallyTrustWorthy = isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(request.url); + switch (policy) { + case "origin": return referrerOrigin != null ? referrerOrigin : stripURLForReferrer(referrerSource, true); + case "unsafe-url": return referrerURL; + case "same-origin": return areSameOrigin ? referrerOrigin : "no-referrer"; + case "origin-when-cross-origin": return areSameOrigin ? referrerURL : referrerOrigin; + case "strict-origin-when-cross-origin": { + const currentURL = requestCurrentURL(request); + if (sameOrigin(referrerURL, currentURL)) return referrerURL; + if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) return "no-referrer"; + return referrerOrigin; + } + /** + * 1. If referrerURL is a potentially trustworthy URL and + * request’s current URL is not a potentially trustworthy URL, + * then return no referrer. + * 2. Return referrerOrigin + */ + default: return isNonPotentiallyTrustWorthy ? "no-referrer" : referrerOrigin; + } + } + /** + * @see https://w3c.github.io/webappsec-referrer-policy/#strip-url + * @param {URL} url + * @param {boolean|undefined} originOnly + */ + function stripURLForReferrer(url, originOnly) { + assert$22(url instanceof URL); + url = new URL(url); + if (url.protocol === "file:" || url.protocol === "about:" || url.protocol === "blank:") return "no-referrer"; + url.username = ""; + url.password = ""; + url.hash = ""; + if (originOnly) { + url.pathname = ""; + url.search = ""; + } + return url; + } + function isURLPotentiallyTrustworthy(url) { + if (!(url instanceof URL)) return false; + if (url.href === "about:blank" || url.href === "about:srcdoc") return true; + if (url.protocol === "data:") return true; + if (url.protocol === "file:") return true; + return isOriginPotentiallyTrustworthy(url.origin); + function isOriginPotentiallyTrustworthy(origin) { + if (origin == null || origin === "null") return false; + const originAsURL = new URL(origin); + if (originAsURL.protocol === "https:" || originAsURL.protocol === "wss:") return true; + if (/^127(?:\.[0-9]+){0,2}\.[0-9]+$|^\[(?:0*:)*?:?0*1\]$/.test(originAsURL.hostname) || originAsURL.hostname === "localhost" || originAsURL.hostname.includes("localhost.") || originAsURL.hostname.endsWith(".localhost")) return true; + return false; + } + } + /** + * @see https://w3c.github.io/webappsec-subresource-integrity/#does-response-match-metadatalist + * @param {Uint8Array} bytes + * @param {string} metadataList + */ + function bytesMatch(bytes, metadataList) { + /* istanbul ignore if: only if node is built with --without-ssl */ + if (crypto === void 0) return true; + const parsedMetadata = parseMetadata(metadataList); + if (parsedMetadata === "no metadata") return true; + if (parsedMetadata.length === 0) return true; + const metadata = filterMetadataListByAlgorithm(parsedMetadata, getStrongestMetadata(parsedMetadata)); + for (const item of metadata) { + const algorithm = item.algo; + const expectedValue = item.hash; + let actualValue = crypto.createHash(algorithm).update(bytes).digest("base64"); + if (actualValue[actualValue.length - 1] === "=") { + if (actualValue[actualValue.length - 2] === "=") actualValue = actualValue.slice(0, -2); + else actualValue = actualValue.slice(0, -1); + } + if (compareBase64Mixed(actualValue, expectedValue)) return true; + } + return false; + } + const parseHashWithOptions = /(?sha256|sha384|sha512)-((?[A-Za-z0-9+/]+|[A-Za-z0-9_-]+)={0,2}(?:\s|$)( +[!-~]*)?)?/i; + /** + * @see https://w3c.github.io/webappsec-subresource-integrity/#parse-metadata + * @param {string} metadata + */ + function parseMetadata(metadata) { + /** @type {{ algo: string, hash: string }[]} */ + const result = []; + let empty = true; + for (const token of metadata.split(" ")) { + empty = false; + const parsedToken = parseHashWithOptions.exec(token); + if (parsedToken === null || parsedToken.groups === void 0 || parsedToken.groups.algo === void 0) continue; + const algorithm = parsedToken.groups.algo.toLowerCase(); + if (supportedHashes.includes(algorithm)) result.push(parsedToken.groups); + } + if (empty === true) return "no metadata"; + return result; + } + /** + * @param {{ algo: 'sha256' | 'sha384' | 'sha512' }[]} metadataList + */ + function getStrongestMetadata(metadataList) { + let algorithm = metadataList[0].algo; + if (algorithm[3] === "5") return algorithm; + for (let i = 1; i < metadataList.length; ++i) { + const metadata = metadataList[i]; + if (metadata.algo[3] === "5") { + algorithm = "sha512"; + break; + } else if (algorithm[3] === "3") continue; + else if (metadata.algo[3] === "3") algorithm = "sha384"; + } + return algorithm; + } + function filterMetadataListByAlgorithm(metadataList, algorithm) { + if (metadataList.length === 1) return metadataList; + let pos = 0; + for (let i = 0; i < metadataList.length; ++i) if (metadataList[i].algo === algorithm) metadataList[pos++] = metadataList[i]; + metadataList.length = pos; + return metadataList; + } + /** + * Compares two base64 strings, allowing for base64url + * in the second string. + * + * @param {string} actualValue always base64 + * @param {string} expectedValue base64 or base64url + * @returns {boolean} + */ + function compareBase64Mixed(actualValue, expectedValue) { + if (actualValue.length !== expectedValue.length) return false; + for (let i = 0; i < actualValue.length; ++i) if (actualValue[i] !== expectedValue[i]) { + if (actualValue[i] === "+" && expectedValue[i] === "-" || actualValue[i] === "/" && expectedValue[i] === "_") continue; + return false; + } + return true; + } + function tryUpgradeRequestToAPotentiallyTrustworthyURL(request) {} + /** + * @link {https://html.spec.whatwg.org/multipage/origin.html#same-origin} + * @param {URL} A + * @param {URL} B + */ + function sameOrigin(A, B) { + if (A.origin === B.origin && A.origin === "null") return true; + if (A.protocol === B.protocol && A.hostname === B.hostname && A.port === B.port) return true; + return false; + } + function createDeferredPromise() { + let res; + let rej; + return { + promise: new Promise((resolve, reject) => { + res = resolve; + rej = reject; + }), + resolve: res, + reject: rej + }; + } + function isAborted(fetchParams) { + return fetchParams.controller.state === "aborted"; + } + function isCancelled(fetchParams) { + return fetchParams.controller.state === "aborted" || fetchParams.controller.state === "terminated"; + } + /** + * @see https://fetch.spec.whatwg.org/#concept-method-normalize + * @param {string} method + */ + function normalizeMethod(method) { + return normalizedMethodRecordsBase[method.toLowerCase()] ?? method; + } + function serializeJavascriptValueToJSONString(value) { + const result = JSON.stringify(value); + if (result === void 0) throw new TypeError("Value is not JSON serializable"); + assert$22(typeof result === "string"); + return result; + } + const esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())); + /** + * @see https://webidl.spec.whatwg.org/#dfn-iterator-prototype-object + * @param {string} name name of the instance + * @param {symbol} kInternalIterator + * @param {string | number} [keyIndex] + * @param {string | number} [valueIndex] + */ + function createIterator(name, kInternalIterator, keyIndex = 0, valueIndex = 1) { + class FastIterableIterator { + /** @type {any} */ + #target; + /** @type {'key' | 'value' | 'key+value'} */ + #kind; + /** @type {number} */ + #index; + /** + * @see https://webidl.spec.whatwg.org/#dfn-default-iterator-object + * @param {unknown} target + * @param {'key' | 'value' | 'key+value'} kind + */ + constructor(target, kind) { + this.#target = target; + this.#kind = kind; + this.#index = 0; + } + next() { + if (typeof this !== "object" || this === null || !(#target in this)) throw new TypeError(`'next' called on an object that does not implement interface ${name} Iterator.`); + const index = this.#index; + const values = this.#target[kInternalIterator]; + if (index >= values.length) return { + value: void 0, + done: true + }; + const { [keyIndex]: key, [valueIndex]: value } = values[index]; + this.#index = index + 1; + let result; + switch (this.#kind) { + case "key": + result = key; + break; + case "value": + result = value; + break; + case "key+value": result = [key, value]; + } + return { + value: result, + done: false + }; + } + } + delete FastIterableIterator.prototype.constructor; + Object.setPrototypeOf(FastIterableIterator.prototype, esIteratorPrototype); + Object.defineProperties(FastIterableIterator.prototype, { + [Symbol.toStringTag]: { + writable: false, + enumerable: false, + configurable: true, + value: `${name} Iterator` + }, + next: { + writable: true, + enumerable: true, + configurable: true + } + }); + /** + * @param {unknown} target + * @param {'key' | 'value' | 'key+value'} kind + * @returns {IterableIterator} + */ + return function(target, kind) { + return new FastIterableIterator(target, kind); + }; + } + /** + * @see https://webidl.spec.whatwg.org/#dfn-iterator-prototype-object + * @param {string} name name of the instance + * @param {any} object class + * @param {symbol} kInternalIterator + * @param {string | number} [keyIndex] + * @param {string | number} [valueIndex] + */ + function iteratorMixin(name, object, kInternalIterator, keyIndex = 0, valueIndex = 1) { + const makeIterator = createIterator(name, kInternalIterator, keyIndex, valueIndex); + const properties = { + keys: { + writable: true, + enumerable: true, + configurable: true, + value: function keys() { + webidl.brandCheck(this, object); + return makeIterator(this, "key"); + } + }, + values: { + writable: true, + enumerable: true, + configurable: true, + value: function values() { + webidl.brandCheck(this, object); + return makeIterator(this, "value"); + } + }, + entries: { + writable: true, + enumerable: true, + configurable: true, + value: function entries() { + webidl.brandCheck(this, object); + return makeIterator(this, "key+value"); + } + }, + forEach: { + writable: true, + enumerable: true, + configurable: true, + value: function forEach(callbackfn, thisArg = globalThis) { + webidl.brandCheck(this, object); + webidl.argumentLengthCheck(arguments, 1, `${name}.forEach`); + if (typeof callbackfn !== "function") throw new TypeError(`Failed to execute 'forEach' on '${name}': parameter 1 is not of type 'Function'.`); + for (const { 0: key, 1: value } of makeIterator(this, "key+value")) callbackfn.call(thisArg, value, key, this); + } + } + }; + return Object.defineProperties(object.prototype, { + ...properties, + [Symbol.iterator]: { + writable: true, + enumerable: false, + configurable: true, + value: properties.entries.value + } + }); + } + /** + * @see https://fetch.spec.whatwg.org/#body-fully-read + */ + async function fullyReadBody(body, processBody, processBodyError) { + const successSteps = processBody; + const errorSteps = processBodyError; + let reader; + try { + reader = body.stream.getReader(); + } catch (e) { + errorSteps(e); + return; + } + try { + successSteps(await readAllBytes(reader)); + } catch (e) { + errorSteps(e); + } + } + function isReadableStreamLike(stream) { + return stream instanceof ReadableStream || stream[Symbol.toStringTag] === "ReadableStream" && typeof stream.tee === "function"; + } + /** + * @param {ReadableStreamController} controller + */ + function readableStreamClose(controller) { + try { + controller.close(); + controller.byobRequest?.respond(0); + } catch (err) { + if (!err.message.includes("Controller is already closed") && !err.message.includes("ReadableStream is already closed")) throw err; + } + } + const invalidIsomorphicEncodeValueRegex = /[^\x00-\xFF]/; + /** + * @see https://infra.spec.whatwg.org/#isomorphic-encode + * @param {string} input + */ + function isomorphicEncode(input) { + assert$22(!invalidIsomorphicEncodeValueRegex.test(input)); + return input; + } + /** + * @see https://streams.spec.whatwg.org/#readablestreamdefaultreader-read-all-bytes + * @see https://streams.spec.whatwg.org/#read-loop + * @param {ReadableStreamDefaultReader} reader + */ + async function readAllBytes(reader) { + const bytes = []; + let byteLength = 0; + while (true) { + const { done, value: chunk } = await reader.read(); + if (done) return Buffer.concat(bytes, byteLength); + if (!isUint8Array(chunk)) throw new TypeError("Received non-Uint8Array chunk"); + bytes.push(chunk); + byteLength += chunk.length; + } + } + /** + * @see https://fetch.spec.whatwg.org/#is-local + * @param {URL} url + */ + function urlIsLocal(url) { + assert$22("protocol" in url); + const protocol = url.protocol; + return protocol === "about:" || protocol === "blob:" || protocol === "data:"; + } + /** + * @param {string|URL} url + * @returns {boolean} + */ + function urlHasHttpsScheme(url) { + return typeof url === "string" && url[5] === ":" && url[0] === "h" && url[1] === "t" && url[2] === "t" && url[3] === "p" && url[4] === "s" || url.protocol === "https:"; + } + /** + * @see https://fetch.spec.whatwg.org/#http-scheme + * @param {URL} url + */ + function urlIsHttpHttpsScheme(url) { + assert$22("protocol" in url); + const protocol = url.protocol; + return protocol === "http:" || protocol === "https:"; + } + /** + * @see https://fetch.spec.whatwg.org/#simple-range-header-value + * @param {string} value + * @param {boolean} allowWhitespace + */ + function simpleRangeHeaderValue(value, allowWhitespace) { + const data = value; + if (!data.startsWith("bytes")) return "failure"; + const position = { position: 5 }; + if (allowWhitespace) collectASequenceOfCodePoints((char) => char === " " || char === " ", data, position); + if (data.charCodeAt(position.position) !== 61) return "failure"; + position.position++; + if (allowWhitespace) collectASequenceOfCodePoints((char) => char === " " || char === " ", data, position); + const rangeStart = collectASequenceOfCodePoints((char) => { + const code = char.charCodeAt(0); + return code >= 48 && code <= 57; + }, data, position); + const rangeStartValue = rangeStart.length ? Number(rangeStart) : null; + if (allowWhitespace) collectASequenceOfCodePoints((char) => char === " " || char === " ", data, position); + if (data.charCodeAt(position.position) !== 45) return "failure"; + position.position++; + if (allowWhitespace) collectASequenceOfCodePoints((char) => char === " " || char === " ", data, position); + const rangeEnd = collectASequenceOfCodePoints((char) => { + const code = char.charCodeAt(0); + return code >= 48 && code <= 57; + }, data, position); + const rangeEndValue = rangeEnd.length ? Number(rangeEnd) : null; + if (position.position < data.length) return "failure"; + if (rangeEndValue === null && rangeStartValue === null) return "failure"; + if (rangeStartValue > rangeEndValue) return "failure"; + return { + rangeStartValue, + rangeEndValue + }; + } + /** + * @see https://fetch.spec.whatwg.org/#build-a-content-range + * @param {number} rangeStart + * @param {number} rangeEnd + * @param {number} fullLength + */ + function buildContentRange(rangeStart, rangeEnd, fullLength) { + let contentRange = "bytes "; + contentRange += isomorphicEncode(`${rangeStart}`); + contentRange += "-"; + contentRange += isomorphicEncode(`${rangeEnd}`); + contentRange += "/"; + contentRange += isomorphicEncode(`${fullLength}`); + return contentRange; + } + var InflateStream = class extends Transform$2 { + #zlibOptions; + /** @param {zlib.ZlibOptions} [zlibOptions] */ + constructor(zlibOptions) { + super(); + this.#zlibOptions = zlibOptions; + } + _transform(chunk, encoding, callback) { + if (!this._inflateStream) { + if (chunk.length === 0) { + callback(); + return; + } + this._inflateStream = (chunk[0] & 15) === 8 ? zlib$1.createInflate(this.#zlibOptions) : zlib$1.createInflateRaw(this.#zlibOptions); + this._inflateStream.on("data", this.push.bind(this)); + this._inflateStream.on("end", () => this.push(null)); + this._inflateStream.on("error", (err) => this.destroy(err)); + } + this._inflateStream.write(chunk, encoding, callback); + } + _final(callback) { + if (this._inflateStream) { + this._inflateStream.end(); + this._inflateStream = null; + } + callback(); + } + }; + /** + * @param {zlib.ZlibOptions} [zlibOptions] + * @returns {InflateStream} + */ + function createInflate(zlibOptions) { + return new InflateStream(zlibOptions); + } + /** + * @see https://fetch.spec.whatwg.org/#concept-header-extract-mime-type + * @param {import('./headers').HeadersList} headers + */ + function extractMimeType(headers) { + let charset = null; + let essence = null; + let mimeType = null; + const values = getDecodeSplit("content-type", headers); + if (values === null) return "failure"; + for (const value of values) { + const temporaryMimeType = parseMIMEType(value); + if (temporaryMimeType === "failure" || temporaryMimeType.essence === "*/*") continue; + mimeType = temporaryMimeType; + if (mimeType.essence !== essence) { + charset = null; + if (mimeType.parameters.has("charset")) charset = mimeType.parameters.get("charset"); + essence = mimeType.essence; + } else if (!mimeType.parameters.has("charset") && charset !== null) mimeType.parameters.set("charset", charset); + } + if (mimeType == null) return "failure"; + return mimeType; + } + /** + * @see https://fetch.spec.whatwg.org/#header-value-get-decode-and-split + * @param {string|null} value + */ + function gettingDecodingSplitting(value) { + const input = value; + const position = { position: 0 }; + const values = []; + let temporaryValue = ""; + while (position.position < input.length) { + temporaryValue += collectASequenceOfCodePoints((char) => char !== "\"" && char !== ",", input, position); + if (position.position < input.length) { + if (input.charCodeAt(position.position) === 34) { + temporaryValue += collectAnHTTPQuotedString(input, position); + if (position.position < input.length) continue; + } else { + assert$22(input.charCodeAt(position.position) === 44); + position.position++; + } + } + temporaryValue = removeChars(temporaryValue, true, true, (char) => char === 9 || char === 32); + values.push(temporaryValue); + temporaryValue = ""; + } + return values; + } + /** + * @see https://fetch.spec.whatwg.org/#concept-header-list-get-decode-split + * @param {string} name lowercase header name + * @param {import('./headers').HeadersList} list + */ + function getDecodeSplit(name, list) { + const value = list.get(name, true); + if (value === null) return null; + return gettingDecodingSplitting(value); + } + const textDecoder = new TextDecoder(); + /** + * @see https://encoding.spec.whatwg.org/#utf-8-decode + * @param {Buffer} buffer + */ + function utf8DecodeBytes(buffer) { + if (buffer.length === 0) return ""; + if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) buffer = buffer.subarray(3); + return textDecoder.decode(buffer); + } + var EnvironmentSettingsObjectBase = class { + get baseUrl() { + return getGlobalOrigin(); + } + get origin() { + return this.baseUrl?.origin; + } + policyContainer = makePolicyContainer(); + }; + var EnvironmentSettingsObject = class { + settingsObject = new EnvironmentSettingsObjectBase(); + }; + module.exports = { + isAborted, + isCancelled, + isValidEncodedURL, + createDeferredPromise, + ReadableStreamFrom, + tryUpgradeRequestToAPotentiallyTrustworthyURL, + clampAndCoarsenConnectionTimingInfo, + coarsenedSharedCurrentTime, + determineRequestsReferrer, + makePolicyContainer, + clonePolicyContainer, + appendFetchMetadata, + appendRequestOriginHeader, + TAOCheck, + corsCheck, + crossOriginResourcePolicyCheck, + createOpaqueTimingInfo, + setRequestReferrerPolicyOnRedirect, + isValidHTTPToken, + requestBadPort, + requestCurrentURL, + responseURL, + responseLocationURL, + isBlobLike, + isURLPotentiallyTrustworthy, + isValidReasonPhrase, + sameOrigin, + normalizeMethod, + serializeJavascriptValueToJSONString, + iteratorMixin, + createIterator, + isValidHeaderName, + isValidHeaderValue, + isErrorLike, + fullyReadBody, + bytesMatch, + isReadableStreamLike, + readableStreamClose, + isomorphicEncode, + urlIsLocal, + urlHasHttpsScheme, + urlIsHttpHttpsScheme, + readAllBytes, + simpleRangeHeaderValue, + buildContentRange, + parseMetadata, + createInflate, + extractMimeType, + getDecodeSplit, + utf8DecodeBytes, + environmentSettingsObject: new EnvironmentSettingsObject() + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fetch/symbols.js +var require_symbols$3 = /* @__PURE__ */ __commonJSMin(((exports, module) => { + module.exports = { + kUrl: Symbol("url"), + kHeaders: Symbol("headers"), + kSignal: Symbol("signal"), + kState: Symbol("state"), + kDispatcher: Symbol("dispatcher") + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fetch/file.js +var require_file = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { Blob: Blob$2, File: File$1 } = __require("node:buffer"); + const { kState } = require_symbols$3(); + const { webidl } = require_webidl(); + var FileLike = class FileLike { + constructor(blobLike, fileName, options = {}) { + const n = fileName; + const t = options.type; + const d = options.lastModified ?? Date.now(); + this[kState] = { + blobLike, + name: n, + type: t, + lastModified: d + }; + } + stream(...args) { + webidl.brandCheck(this, FileLike); + return this[kState].blobLike.stream(...args); + } + arrayBuffer(...args) { + webidl.brandCheck(this, FileLike); + return this[kState].blobLike.arrayBuffer(...args); + } + slice(...args) { + webidl.brandCheck(this, FileLike); + return this[kState].blobLike.slice(...args); + } + text(...args) { + webidl.brandCheck(this, FileLike); + return this[kState].blobLike.text(...args); + } + get size() { + webidl.brandCheck(this, FileLike); + return this[kState].blobLike.size; + } + get type() { + webidl.brandCheck(this, FileLike); + return this[kState].blobLike.type; + } + get name() { + webidl.brandCheck(this, FileLike); + return this[kState].name; + } + get lastModified() { + webidl.brandCheck(this, FileLike); + return this[kState].lastModified; + } + get [Symbol.toStringTag]() { + return "File"; + } + }; + webidl.converters.Blob = webidl.interfaceConverter(Blob$2); + function isFileLike(object) { + return object instanceof File$1 || object && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && object[Symbol.toStringTag] === "File"; + } + module.exports = { + FileLike, + isFileLike + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fetch/formdata.js +var require_formdata = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { isBlobLike, iteratorMixin } = require_util$6(); + const { kState } = require_symbols$3(); + const { kEnumerableProperty } = require_util$7(); + const { FileLike, isFileLike } = require_file(); + const { webidl } = require_webidl(); + const { File: NativeFile } = __require("node:buffer"); + const nodeUtil$2 = __require("node:util"); + /** @type {globalThis['File']} */ + const File = globalThis.File ?? NativeFile; + var FormData = class FormData { + constructor(form) { + webidl.util.markAsUncloneable(this); + if (form !== void 0) throw webidl.errors.conversionFailed({ + prefix: "FormData constructor", + argument: "Argument 1", + types: ["undefined"] + }); + this[kState] = []; + } + append(name, value, filename = void 0) { + webidl.brandCheck(this, FormData); + const prefix = "FormData.append"; + webidl.argumentLengthCheck(arguments, 2, prefix); + if (arguments.length === 3 && !isBlobLike(value)) throw new TypeError("Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'"); + name = webidl.converters.USVString(name, prefix, "name"); + value = isBlobLike(value) ? webidl.converters.Blob(value, prefix, "value", { strict: false }) : webidl.converters.USVString(value, prefix, "value"); + filename = arguments.length === 3 ? webidl.converters.USVString(filename, prefix, "filename") : void 0; + const entry = makeEntry(name, value, filename); + this[kState].push(entry); + } + delete(name) { + webidl.brandCheck(this, FormData); + const prefix = "FormData.delete"; + webidl.argumentLengthCheck(arguments, 1, prefix); + name = webidl.converters.USVString(name, prefix, "name"); + this[kState] = this[kState].filter((entry) => entry.name !== name); + } + get(name) { + webidl.brandCheck(this, FormData); + const prefix = "FormData.get"; + webidl.argumentLengthCheck(arguments, 1, prefix); + name = webidl.converters.USVString(name, prefix, "name"); + const idx = this[kState].findIndex((entry) => entry.name === name); + if (idx === -1) return null; + return this[kState][idx].value; + } + getAll(name) { + webidl.brandCheck(this, FormData); + const prefix = "FormData.getAll"; + webidl.argumentLengthCheck(arguments, 1, prefix); + name = webidl.converters.USVString(name, prefix, "name"); + return this[kState].filter((entry) => entry.name === name).map((entry) => entry.value); + } + has(name) { + webidl.brandCheck(this, FormData); + const prefix = "FormData.has"; + webidl.argumentLengthCheck(arguments, 1, prefix); + name = webidl.converters.USVString(name, prefix, "name"); + return this[kState].findIndex((entry) => entry.name === name) !== -1; + } + set(name, value, filename = void 0) { + webidl.brandCheck(this, FormData); + const prefix = "FormData.set"; + webidl.argumentLengthCheck(arguments, 2, prefix); + if (arguments.length === 3 && !isBlobLike(value)) throw new TypeError("Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'"); + name = webidl.converters.USVString(name, prefix, "name"); + value = isBlobLike(value) ? webidl.converters.Blob(value, prefix, "name", { strict: false }) : webidl.converters.USVString(value, prefix, "name"); + filename = arguments.length === 3 ? webidl.converters.USVString(filename, prefix, "name") : void 0; + const entry = makeEntry(name, value, filename); + const idx = this[kState].findIndex((entry) => entry.name === name); + if (idx !== -1) this[kState] = [ + ...this[kState].slice(0, idx), + entry, + ...this[kState].slice(idx + 1).filter((entry) => entry.name !== name) + ]; + else this[kState].push(entry); + } + [nodeUtil$2.inspect.custom](depth, options) { + const state = this[kState].reduce((a, b) => { + if (a[b.name]) { + if (Array.isArray(a[b.name])) a[b.name].push(b.value); + else a[b.name] = [a[b.name], b.value]; + } else a[b.name] = b.value; + return a; + }, { __proto__: null }); + options.depth ??= depth; + options.colors ??= true; + const output = nodeUtil$2.formatWithOptions(options, state); + return `FormData ${output.slice(output.indexOf("]") + 2)}`; + } + }; + iteratorMixin("FormData", FormData, kState, "name", "value"); + Object.defineProperties(FormData.prototype, { + append: kEnumerableProperty, + delete: kEnumerableProperty, + get: kEnumerableProperty, + getAll: kEnumerableProperty, + has: kEnumerableProperty, + set: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "FormData", + configurable: true + } + }); + /** + * @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#create-an-entry + * @param {string} name + * @param {string|Blob} value + * @param {?string} filename + * @returns + */ + function makeEntry(name, value, filename) { + if (typeof value === "string") {} else { + if (!isFileLike(value)) value = value instanceof Blob ? new File([value], "blob", { type: value.type }) : new FileLike(value, "blob", { type: value.type }); + if (filename !== void 0) { + /** @type {FilePropertyBag} */ + const options = { + type: value.type, + lastModified: value.lastModified + }; + value = value instanceof NativeFile ? new File([value], filename, options) : new FileLike(value, filename, options); + } + } + return { + name, + value + }; + } + module.exports = { + FormData, + makeEntry + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fetch/formdata-parser.js +var require_formdata_parser = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { isUSVString, bufferToLowerCasedHeaderName } = require_util$7(); + const { utf8DecodeBytes } = require_util$6(); + const { HTTP_TOKEN_CODEPOINTS, isomorphicDecode } = require_data_url(); + const { isFileLike } = require_file(); + const { makeEntry } = require_formdata(); + const assert$21 = __require("node:assert"); + const { File: NodeFile } = __require("node:buffer"); + const File = globalThis.File ?? NodeFile; + const formDataNameBuffer = Buffer.from("form-data; name=\""); + const filenameBuffer = Buffer.from("; filename"); + const dd = Buffer.from("--"); + const ddcrlf = Buffer.from("--\r\n"); + /** + * @param {string} chars + */ + function isAsciiString(chars) { + for (let i = 0; i < chars.length; ++i) if ((chars.charCodeAt(i) & -128) !== 0) return false; + return true; + } + /** + * @see https://andreubotella.github.io/multipart-form-data/#multipart-form-data-boundary + * @param {string} boundary + */ + function validateBoundary(boundary) { + const length = boundary.length; + if (length < 27 || length > 70) return false; + for (let i = 0; i < length; ++i) { + const cp = boundary.charCodeAt(i); + if (!(cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 39 || cp === 45 || cp === 95)) return false; + } + return true; + } + /** + * @see https://andreubotella.github.io/multipart-form-data/#multipart-form-data-parser + * @param {Buffer} input + * @param {ReturnType} mimeType + */ + function multipartFormDataParser(input, mimeType) { + assert$21(mimeType !== "failure" && mimeType.essence === "multipart/form-data"); + const boundaryString = mimeType.parameters.get("boundary"); + if (boundaryString === void 0) return "failure"; + const boundary = Buffer.from(`--${boundaryString}`, "utf8"); + const entryList = []; + const position = { position: 0 }; + while (input[position.position] === 13 && input[position.position + 1] === 10) position.position += 2; + let trailing = input.length; + while (input[trailing - 1] === 10 && input[trailing - 2] === 13) trailing -= 2; + if (trailing !== input.length) input = input.subarray(0, trailing); + while (true) { + if (input.subarray(position.position, position.position + boundary.length).equals(boundary)) position.position += boundary.length; + else return "failure"; + if (position.position === input.length - 2 && bufferStartsWith(input, dd, position) || position.position === input.length - 4 && bufferStartsWith(input, ddcrlf, position)) return entryList; + if (input[position.position] !== 13 || input[position.position + 1] !== 10) return "failure"; + position.position += 2; + const result = parseMultipartFormDataHeaders(input, position); + if (result === "failure") return "failure"; + let { name, filename, contentType, encoding } = result; + position.position += 2; + let body; + { + const boundaryIndex = input.indexOf(boundary.subarray(2), position.position); + if (boundaryIndex === -1) return "failure"; + body = input.subarray(position.position, boundaryIndex - 4); + position.position += body.length; + if (encoding === "base64") body = Buffer.from(body.toString(), "base64"); + } + if (input[position.position] !== 13 || input[position.position + 1] !== 10) return "failure"; + else position.position += 2; + let value; + if (filename !== null) { + contentType ??= "text/plain"; + if (!isAsciiString(contentType)) contentType = ""; + value = new File([body], filename, { type: contentType }); + } else value = utf8DecodeBytes(Buffer.from(body)); + assert$21(isUSVString(name)); + assert$21(typeof value === "string" && isUSVString(value) || isFileLike(value)); + entryList.push(makeEntry(name, value, filename)); + } + } + /** + * @see https://andreubotella.github.io/multipart-form-data/#parse-multipart-form-data-headers + * @param {Buffer} input + * @param {{ position: number }} position + */ + function parseMultipartFormDataHeaders(input, position) { + let name = null; + let filename = null; + let contentType = null; + let encoding = null; + while (true) { + if (input[position.position] === 13 && input[position.position + 1] === 10) { + if (name === null) return "failure"; + return { + name, + filename, + contentType, + encoding + }; + } + let headerName = collectASequenceOfBytes((char) => char !== 10 && char !== 13 && char !== 58, input, position); + headerName = removeChars(headerName, true, true, (char) => char === 9 || char === 32); + if (!HTTP_TOKEN_CODEPOINTS.test(headerName.toString())) return "failure"; + if (input[position.position] !== 58) return "failure"; + position.position++; + collectASequenceOfBytes((char) => char === 32 || char === 9, input, position); + switch (bufferToLowerCasedHeaderName(headerName)) { + case "content-disposition": + name = filename = null; + if (!bufferStartsWith(input, formDataNameBuffer, position)) return "failure"; + position.position += 17; + name = parseMultipartFormDataName(input, position); + if (name === null) return "failure"; + if (bufferStartsWith(input, filenameBuffer, position)) { + let check = position.position + filenameBuffer.length; + if (input[check] === 42) { + position.position += 1; + check += 1; + } + if (input[check] !== 61 || input[check + 1] !== 34) return "failure"; + position.position += 12; + filename = parseMultipartFormDataName(input, position); + if (filename === null) return "failure"; + } + break; + case "content-type": { + let headerValue = collectASequenceOfBytes((char) => char !== 10 && char !== 13, input, position); + headerValue = removeChars(headerValue, false, true, (char) => char === 9 || char === 32); + contentType = isomorphicDecode(headerValue); + break; + } + case "content-transfer-encoding": { + let headerValue = collectASequenceOfBytes((char) => char !== 10 && char !== 13, input, position); + headerValue = removeChars(headerValue, false, true, (char) => char === 9 || char === 32); + encoding = isomorphicDecode(headerValue); + break; + } + default: collectASequenceOfBytes((char) => char !== 10 && char !== 13, input, position); + } + if (input[position.position] !== 13 && input[position.position + 1] !== 10) return "failure"; + else position.position += 2; + } + } + /** + * @see https://andreubotella.github.io/multipart-form-data/#parse-a-multipart-form-data-name + * @param {Buffer} input + * @param {{ position: number }} position + */ + function parseMultipartFormDataName(input, position) { + assert$21(input[position.position - 1] === 34); + /** @type {string | Buffer} */ + let name = collectASequenceOfBytes((char) => char !== 10 && char !== 13 && char !== 34, input, position); + if (input[position.position] !== 34) return null; + else position.position++; + name = new TextDecoder().decode(name).replace(/%0A/gi, "\n").replace(/%0D/gi, "\r").replace(/%22/g, "\""); + return name; + } + /** + * @param {(char: number) => boolean} condition + * @param {Buffer} input + * @param {{ position: number }} position + */ + function collectASequenceOfBytes(condition, input, position) { + let start = position.position; + while (start < input.length && condition(input[start])) ++start; + return input.subarray(position.position, position.position = start); + } + /** + * @param {Buffer} buf + * @param {boolean} leading + * @param {boolean} trailing + * @param {(charCode: number) => boolean} predicate + * @returns {Buffer} + */ + function removeChars(buf, leading, trailing, predicate) { + let lead = 0; + let trail = buf.length - 1; + if (leading) while (lead < buf.length && predicate(buf[lead])) lead++; + if (trailing) while (trail > 0 && predicate(buf[trail])) trail--; + return lead === 0 && trail === buf.length - 1 ? buf : buf.subarray(lead, trail + 1); + } + /** + * Checks if {@param buffer} starts with {@param start} + * @param {Buffer} buffer + * @param {Buffer} start + * @param {{ position: number }} position + */ + function bufferStartsWith(buffer, start, position) { + if (buffer.length < start.length) return false; + for (let i = 0; i < start.length; i++) if (start[i] !== buffer[position.position + i]) return false; + return true; + } + module.exports = { + multipartFormDataParser, + validateBoundary + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fetch/body.js +var require_body = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const util = require_util$7(); + const { ReadableStreamFrom, isBlobLike, isReadableStreamLike, readableStreamClose, createDeferredPromise, fullyReadBody, extractMimeType, utf8DecodeBytes } = require_util$6(); + const { FormData } = require_formdata(); + const { kState } = require_symbols$3(); + const { webidl } = require_webidl(); + const { Blob: Blob$1 } = __require("node:buffer"); + const assert$20 = __require("node:assert"); + const { isErrored, isDisturbed } = __require("node:stream"); + const { isArrayBuffer: isArrayBuffer$1 } = __require("node:util/types"); + const { serializeAMimeType } = require_data_url(); + const { multipartFormDataParser } = require_formdata_parser(); + let random; + try { + const crypto = __require("node:crypto"); + random = (max) => crypto.randomInt(0, max); + } catch { + random = (max) => Math.floor(Math.random(max)); + } + const textEncoder = new TextEncoder(); + function noop() {} + const hasFinalizationRegistry = globalThis.FinalizationRegistry && process.version.indexOf("v18") !== 0; + let streamRegistry; + if (hasFinalizationRegistry) streamRegistry = new FinalizationRegistry((weakRef) => { + const stream = weakRef.deref(); + if (stream && !stream.locked && !isDisturbed(stream) && !isErrored(stream)) stream.cancel("Response object has been garbage collected").catch(noop); + }); + function extractBody(object, keepalive = false) { + let stream = null; + if (object instanceof ReadableStream) stream = object; + else if (isBlobLike(object)) stream = object.stream(); + else stream = new ReadableStream({ + async pull(controller) { + const buffer = typeof source === "string" ? textEncoder.encode(source) : source; + if (buffer.byteLength) controller.enqueue(buffer); + queueMicrotask(() => readableStreamClose(controller)); + }, + start() {}, + type: "bytes" + }); + assert$20(isReadableStreamLike(stream)); + let action = null; + let source = null; + let length = null; + let type = null; + if (typeof object === "string") { + source = object; + type = "text/plain;charset=UTF-8"; + } else if (object instanceof URLSearchParams) { + source = object.toString(); + type = "application/x-www-form-urlencoded;charset=UTF-8"; + } else if (isArrayBuffer$1(object)) source = new Uint8Array(object.slice()); + else if (ArrayBuffer.isView(object)) source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength)); + else if (util.isFormDataLike(object)) { + const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, "0")}`; + const prefix = `--${boundary}\r\nContent-Disposition: form-data`; + /*! formdata-polyfill. MIT License. Jimmy Wärting */ + const escape = (str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"); + const normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, "\r\n"); + const blobParts = []; + const rn = new Uint8Array([13, 10]); + length = 0; + let hasUnknownSizeValue = false; + for (const [name, value] of object) if (typeof value === "string") { + const chunk = textEncoder.encode(prefix + `; name="${escape(normalizeLinefeeds(name))}"\r\n\r\n${normalizeLinefeeds(value)}\r\n`); + blobParts.push(chunk); + length += chunk.byteLength; + } else { + const chunk = textEncoder.encode(`${prefix}; name="${escape(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape(value.name)}"` : "") + `\r +Content-Type: ${value.type || "application/octet-stream"}\r\n\r\n`); + blobParts.push(chunk, value, rn); + if (typeof value.size === "number") length += chunk.byteLength + value.size + rn.byteLength; + else hasUnknownSizeValue = true; + } + const chunk = textEncoder.encode(`--${boundary}--\r\n`); + blobParts.push(chunk); + length += chunk.byteLength; + if (hasUnknownSizeValue) length = null; + source = object; + action = async function* () { + for (const part of blobParts) if (part.stream) yield* part.stream(); + else yield part; + }; + type = `multipart/form-data; boundary=${boundary}`; + } else if (isBlobLike(object)) { + source = object; + length = object.size; + if (object.type) type = object.type; + } else if (typeof object[Symbol.asyncIterator] === "function") { + if (keepalive) throw new TypeError("keepalive"); + if (util.isDisturbed(object) || object.locked) throw new TypeError("Response body object should not be disturbed or locked"); + stream = object instanceof ReadableStream ? object : ReadableStreamFrom(object); + } + if (typeof source === "string" || util.isBuffer(source)) length = Buffer.byteLength(source); + if (action != null) { + let iterator; + stream = new ReadableStream({ + async start() { + iterator = action(object)[Symbol.asyncIterator](); + }, + async pull(controller) { + const { value, done } = await iterator.next(); + if (done) queueMicrotask(() => { + controller.close(); + controller.byobRequest?.respond(0); + }); + else if (!isErrored(stream)) { + const buffer = new Uint8Array(value); + if (buffer.byteLength) controller.enqueue(buffer); + } + return controller.desiredSize > 0; + }, + async cancel(reason) { + await iterator.return(); + }, + type: "bytes" + }); + } + return [{ + stream, + source, + length + }, type]; + } + function safelyExtractBody(object, keepalive = false) { + if (object instanceof ReadableStream) { + // istanbul ignore next + assert$20(!util.isDisturbed(object), "The body has already been consumed."); + // istanbul ignore next + assert$20(!object.locked, "The stream is locked."); + } + return extractBody(object, keepalive); + } + function cloneBody(instance, body) { + const [out1, out2] = body.stream.tee(); + body.stream = out1; + return { + stream: out2, + length: body.length, + source: body.source + }; + } + function throwIfAborted(state) { + if (state.aborted) throw new DOMException("The operation was aborted.", "AbortError"); + } + function bodyMixinMethods(instance) { + return { + blob() { + return consumeBody(this, (bytes) => { + let mimeType = bodyMimeType(this); + if (mimeType === null) mimeType = ""; + else if (mimeType) mimeType = serializeAMimeType(mimeType); + return new Blob$1([bytes], { type: mimeType }); + }, instance); + }, + arrayBuffer() { + return consumeBody(this, (bytes) => { + return new Uint8Array(bytes).buffer; + }, instance); + }, + text() { + return consumeBody(this, utf8DecodeBytes, instance); + }, + json() { + return consumeBody(this, parseJSONFromBytes, instance); + }, + formData() { + return consumeBody(this, (value) => { + const mimeType = bodyMimeType(this); + if (mimeType !== null) switch (mimeType.essence) { + case "multipart/form-data": { + const parsed = multipartFormDataParser(value, mimeType); + if (parsed === "failure") throw new TypeError("Failed to parse body as FormData."); + const fd = new FormData(); + fd[kState] = parsed; + return fd; + } + case "application/x-www-form-urlencoded": { + const entries = new URLSearchParams(value.toString()); + const fd = new FormData(); + for (const [name, value] of entries) fd.append(name, value); + return fd; + } + } + throw new TypeError("Content-Type was not one of \"multipart/form-data\" or \"application/x-www-form-urlencoded\"."); + }, instance); + }, + bytes() { + return consumeBody(this, (bytes) => { + return new Uint8Array(bytes); + }, instance); + } + }; + } + function mixinBody(prototype) { + Object.assign(prototype.prototype, bodyMixinMethods(prototype)); + } + /** + * @see https://fetch.spec.whatwg.org/#concept-body-consume-body + * @param {Response|Request} object + * @param {(value: unknown) => unknown} convertBytesToJSValue + * @param {Response|Request} instance + */ + async function consumeBody(object, convertBytesToJSValue, instance) { + webidl.brandCheck(object, instance); + if (bodyUnusable(object)) throw new TypeError("Body is unusable: Body has already been read"); + throwIfAborted(object[kState]); + const promise = createDeferredPromise(); + const errorSteps = (error) => promise.reject(error); + const successSteps = (data) => { + try { + promise.resolve(convertBytesToJSValue(data)); + } catch (e) { + errorSteps(e); + } + }; + if (object[kState].body == null) { + successSteps(Buffer.allocUnsafe(0)); + return promise.promise; + } + await fullyReadBody(object[kState].body, successSteps, errorSteps); + return promise.promise; + } + function bodyUnusable(object) { + const body = object[kState].body; + return body != null && (body.stream.locked || util.isDisturbed(body.stream)); + } + /** + * @see https://infra.spec.whatwg.org/#parse-json-bytes-to-a-javascript-value + * @param {Uint8Array} bytes + */ + function parseJSONFromBytes(bytes) { + return JSON.parse(utf8DecodeBytes(bytes)); + } + /** + * @see https://fetch.spec.whatwg.org/#concept-body-mime-type + * @param {import('./response').Response|import('./request').Request} requestOrResponse + */ + function bodyMimeType(requestOrResponse) { + /** @type {import('./headers').HeadersList} */ + const headers = requestOrResponse[kState].headersList; + const mimeType = extractMimeType(headers); + if (mimeType === "failure") return null; + return mimeType; + } + module.exports = { + extractBody, + safelyExtractBody, + cloneBody, + mixinBody, + streamRegistry, + hasFinalizationRegistry, + bodyUnusable + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/dispatcher/client-h1.js +var require_client_h1 = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const assert$19 = __require("node:assert"); + const util = require_util$7(); + const { channels } = require_diagnostics(); + const timers = require_timers(); + const { RequestContentLengthMismatchError, ResponseContentLengthMismatchError, RequestAbortedError, HeadersTimeoutError, HeadersOverflowError, SocketError, InformationalError, BodyTimeoutError, HTTPParserError, ResponseExceededMaxSizeError } = require_errors(); + const { kUrl, kReset, kClient, kParser, kBlocking, kRunning, kPending, kSize, kWriting, kQueue, kNoRef, kKeepAliveDefaultTimeout, kHostHeader, kPendingIdx, kRunningIdx, kError, kPipelining, kSocket, kKeepAliveTimeoutValue, kMaxHeadersSize, kKeepAliveMaxTimeout, kKeepAliveTimeoutThreshold, kHeadersTimeout, kBodyTimeout, kStrictContentLength, kMaxRequests, kCounter, kMaxResponseSize, kOnError, kResume, kHTTPContext } = require_symbols$4(); + const constants = require_constants$3(); + const EMPTY_BUF = Buffer.alloc(0); + const FastBuffer = Buffer[Symbol.species]; + const addListener = util.addListener; + const removeAllListeners = util.removeAllListeners; + let extractBody; + async function lazyllhttp() { + const llhttpWasmData = process.env.JEST_WORKER_ID ? require_llhttp_wasm() : void 0; + let mod; + try { + mod = await WebAssembly.compile(require_llhttp_simd_wasm()); + } catch (e) { + /* istanbul ignore next */ + mod = await WebAssembly.compile(llhttpWasmData || require_llhttp_wasm()); + } + return await WebAssembly.instantiate(mod, { env: { + wasm_on_url: (p, at, len) => { + /* istanbul ignore next */ + return 0; + }, + wasm_on_status: (p, at, len) => { + assert$19(currentParser.ptr === p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_message_begin: (p) => { + assert$19(currentParser.ptr === p); + return currentParser.onMessageBegin() || 0; + }, + wasm_on_header_field: (p, at, len) => { + assert$19(currentParser.ptr === p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_header_value: (p, at, len) => { + assert$19(currentParser.ptr === p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => { + assert$19(currentParser.ptr === p); + return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0; + }, + wasm_on_body: (p, at, len) => { + assert$19(currentParser.ptr === p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_message_complete: (p) => { + assert$19(currentParser.ptr === p); + return currentParser.onMessageComplete() || 0; + } + } }); + } + let llhttpInstance = null; + let llhttpPromise = lazyllhttp(); + llhttpPromise.catch(); + let currentParser = null; + let currentBufferRef = null; + let currentBufferSize = 0; + let currentBufferPtr = null; + const USE_FAST_TIMER = 1; + const TIMEOUT_HEADERS = 3; + const TIMEOUT_BODY = 5; + const TIMEOUT_KEEP_ALIVE = 8; + var Parser = class { + constructor(client, socket, { exports: exports$1 }) { + assert$19(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0); + this.llhttp = exports$1; + this.ptr = this.llhttp.llhttp_alloc(constants.TYPE.RESPONSE); + this.client = client; + this.socket = socket; + this.timeout = null; + this.timeoutValue = null; + this.timeoutType = null; + this.statusCode = null; + this.statusText = ""; + this.upgrade = false; + this.headers = []; + this.headersSize = 0; + this.headersMaxSize = client[kMaxHeadersSize]; + this.shouldKeepAlive = false; + this.paused = false; + this.resume = this.resume.bind(this); + this.bytesRead = 0; + this.keepAlive = ""; + this.contentLength = ""; + this.connection = ""; + this.maxResponseSize = client[kMaxResponseSize]; + } + setTimeout(delay, type) { + if (delay !== this.timeoutValue || type & USE_FAST_TIMER ^ this.timeoutType & USE_FAST_TIMER) { + if (this.timeout) { + timers.clearTimeout(this.timeout); + this.timeout = null; + } + if (delay) { + if (type & USE_FAST_TIMER) this.timeout = timers.setFastTimeout(onParserTimeout, delay, new WeakRef(this)); + else { + this.timeout = setTimeout(onParserTimeout, delay, new WeakRef(this)); + this.timeout.unref(); + } + } + this.timeoutValue = delay; + } else if (this.timeout) { + // istanbul ignore else: only for jest + if (this.timeout.refresh) this.timeout.refresh(); + } + this.timeoutType = type; + } + resume() { + if (this.socket.destroyed || !this.paused) return; + assert$19(this.ptr != null); + assert$19(currentParser == null); + this.llhttp.llhttp_resume(this.ptr); + assert$19(this.timeoutType === TIMEOUT_BODY); + if (this.timeout) { + // istanbul ignore else: only for jest + if (this.timeout.refresh) this.timeout.refresh(); + } + this.paused = false; + this.execute(this.socket.read() || EMPTY_BUF); + this.readMore(); + } + readMore() { + while (!this.paused && this.ptr) { + const chunk = this.socket.read(); + if (chunk === null) break; + this.execute(chunk); + } + } + execute(data) { + assert$19(this.ptr != null); + assert$19(currentParser == null); + assert$19(!this.paused); + const { socket, llhttp } = this; + if (data.length > currentBufferSize) { + if (currentBufferPtr) llhttp.free(currentBufferPtr); + currentBufferSize = Math.ceil(data.length / 4096) * 4096; + currentBufferPtr = llhttp.malloc(currentBufferSize); + } + new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(data); + try { + let ret; + try { + currentBufferRef = data; + currentParser = this; + ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, data.length); + } catch (err) { + /* istanbul ignore next: difficult to make a test case for */ + throw err; + } finally { + currentParser = null; + currentBufferRef = null; + } + const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr; + if (ret === constants.ERROR.PAUSED_UPGRADE) this.onUpgrade(data.slice(offset)); + else if (ret === constants.ERROR.PAUSED) { + this.paused = true; + socket.unshift(data.slice(offset)); + } else if (ret !== constants.ERROR.OK) { + const ptr = llhttp.llhttp_get_error_reason(this.ptr); + let message = ""; + /* istanbul ignore else: difficult to make a test case for */ + if (ptr) { + const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0); + message = "Response does not match the HTTP/1.1 protocol (" + Buffer.from(llhttp.memory.buffer, ptr, len).toString() + ")"; + } + throw new HTTPParserError(message, constants.ERROR[ret], data.slice(offset)); + } + } catch (err) { + util.destroy(socket, err); + } + } + destroy() { + assert$19(this.ptr != null); + assert$19(currentParser == null); + this.llhttp.llhttp_free(this.ptr); + this.ptr = null; + this.timeout && timers.clearTimeout(this.timeout); + this.timeout = null; + this.timeoutValue = null; + this.timeoutType = null; + this.paused = false; + } + onStatus(buf) { + this.statusText = buf.toString(); + } + onMessageBegin() { + const { socket, client } = this; + /* istanbul ignore next: difficult to make a test case for */ + if (socket.destroyed) return -1; + const request = client[kQueue][client[kRunningIdx]]; + if (!request) return -1; + request.onResponseStarted(); + } + onHeaderField(buf) { + const len = this.headers.length; + if ((len & 1) === 0) this.headers.push(buf); + else this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]); + this.trackHeader(buf.length); + } + onHeaderValue(buf) { + let len = this.headers.length; + if ((len & 1) === 1) { + this.headers.push(buf); + len += 1; + } else this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]); + const key = this.headers[len - 2]; + if (key.length === 10) { + const headerName = util.bufferToLowerCasedHeaderName(key); + if (headerName === "keep-alive") this.keepAlive += buf.toString(); + else if (headerName === "connection") this.connection += buf.toString(); + } else if (key.length === 14 && util.bufferToLowerCasedHeaderName(key) === "content-length") this.contentLength += buf.toString(); + this.trackHeader(buf.length); + } + trackHeader(len) { + this.headersSize += len; + if (this.headersSize >= this.headersMaxSize) util.destroy(this.socket, new HeadersOverflowError()); + } + onUpgrade(head) { + const { upgrade, client, socket, headers, statusCode } = this; + assert$19(upgrade); + assert$19(client[kSocket] === socket); + assert$19(!socket.destroyed); + assert$19(!this.paused); + assert$19((headers.length & 1) === 0); + const request = client[kQueue][client[kRunningIdx]]; + assert$19(request); + assert$19(request.upgrade || request.method === "CONNECT"); + this.statusCode = null; + this.statusText = ""; + this.shouldKeepAlive = null; + this.headers = []; + this.headersSize = 0; + socket.unshift(head); + socket[kParser].destroy(); + socket[kParser] = null; + socket[kClient] = null; + socket[kError] = null; + removeAllListeners(socket); + client[kSocket] = null; + client[kHTTPContext] = null; + client[kQueue][client[kRunningIdx]++] = null; + client.emit("disconnect", client[kUrl], [client], new InformationalError("upgrade")); + try { + request.onUpgrade(statusCode, headers, socket); + } catch (err) { + util.destroy(socket, err); + } + client[kResume](); + } + onHeadersComplete(statusCode, upgrade, shouldKeepAlive) { + const { client, socket, headers, statusText } = this; + /* istanbul ignore next: difficult to make a test case for */ + if (socket.destroyed) return -1; + const request = client[kQueue][client[kRunningIdx]]; + /* istanbul ignore next: difficult to make a test case for */ + if (!request) return -1; + assert$19(!this.upgrade); + assert$19(this.statusCode < 200); + if (statusCode === 100) { + util.destroy(socket, new SocketError("bad response", util.getSocketInfo(socket))); + return -1; + } + if (upgrade && !request.upgrade) { + util.destroy(socket, new SocketError("bad upgrade", util.getSocketInfo(socket))); + return -1; + } + assert$19(this.timeoutType === TIMEOUT_HEADERS); + this.statusCode = statusCode; + this.shouldKeepAlive = shouldKeepAlive || request.method === "HEAD" && !socket[kReset] && this.connection.toLowerCase() === "keep-alive"; + if (this.statusCode >= 200) { + const bodyTimeout = request.bodyTimeout != null ? request.bodyTimeout : client[kBodyTimeout]; + this.setTimeout(bodyTimeout, TIMEOUT_BODY); + } else if (this.timeout) { + // istanbul ignore else: only for jest + if (this.timeout.refresh) this.timeout.refresh(); + } + if (request.method === "CONNECT") { + assert$19(client[kRunning] === 1); + this.upgrade = true; + return 2; + } + if (upgrade) { + assert$19(client[kRunning] === 1); + this.upgrade = true; + return 2; + } + assert$19((this.headers.length & 1) === 0); + this.headers = []; + this.headersSize = 0; + if (this.shouldKeepAlive && client[kPipelining]) { + const keepAliveTimeout = this.keepAlive ? util.parseKeepAliveTimeout(this.keepAlive) : null; + if (keepAliveTimeout != null) { + const timeout = Math.min(keepAliveTimeout - client[kKeepAliveTimeoutThreshold], client[kKeepAliveMaxTimeout]); + if (timeout <= 0) socket[kReset] = true; + else client[kKeepAliveTimeoutValue] = timeout; + } else client[kKeepAliveTimeoutValue] = client[kKeepAliveDefaultTimeout]; + } else socket[kReset] = true; + const pause = request.onHeaders(statusCode, headers, this.resume, statusText) === false; + if (request.aborted) return -1; + if (request.method === "HEAD") return 1; + if (statusCode < 200) return 1; + if (socket[kBlocking]) { + socket[kBlocking] = false; + client[kResume](); + } + return pause ? constants.ERROR.PAUSED : 0; + } + onBody(buf) { + const { client, socket, statusCode, maxResponseSize } = this; + if (socket.destroyed) return -1; + const request = client[kQueue][client[kRunningIdx]]; + assert$19(request); + assert$19(this.timeoutType === TIMEOUT_BODY); + if (this.timeout) { + // istanbul ignore else: only for jest + if (this.timeout.refresh) this.timeout.refresh(); + } + assert$19(statusCode >= 200); + if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) { + util.destroy(socket, new ResponseExceededMaxSizeError()); + return -1; + } + this.bytesRead += buf.length; + if (request.onData(buf) === false) return constants.ERROR.PAUSED; + } + onMessageComplete() { + const { client, socket, statusCode, upgrade, headers, contentLength, bytesRead, shouldKeepAlive } = this; + if (socket.destroyed && (!statusCode || shouldKeepAlive)) return -1; + if (upgrade) return; + assert$19(statusCode >= 100); + assert$19((this.headers.length & 1) === 0); + const request = client[kQueue][client[kRunningIdx]]; + assert$19(request); + this.statusCode = null; + this.statusText = ""; + this.bytesRead = 0; + this.contentLength = ""; + this.keepAlive = ""; + this.connection = ""; + this.headers = []; + this.headersSize = 0; + if (statusCode < 200) return; + /* istanbul ignore next: should be handled by llhttp? */ + if (request.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) { + util.destroy(socket, new ResponseContentLengthMismatchError()); + return -1; + } + request.onComplete(headers); + client[kQueue][client[kRunningIdx]++] = null; + if (socket[kWriting]) { + assert$19(client[kRunning] === 0); + util.destroy(socket, new InformationalError("reset")); + return constants.ERROR.PAUSED; + } else if (!shouldKeepAlive) { + util.destroy(socket, new InformationalError("reset")); + return constants.ERROR.PAUSED; + } else if (socket[kReset] && client[kRunning] === 0) { + util.destroy(socket, new InformationalError("reset")); + return constants.ERROR.PAUSED; + } else if (client[kPipelining] == null || client[kPipelining] === 1) setImmediate(() => client[kResume]()); + else client[kResume](); + } + }; + function onParserTimeout(parser) { + const { socket, timeoutType, client, paused } = parser.deref(); + /* istanbul ignore else */ + if (timeoutType === TIMEOUT_HEADERS) { + if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) { + assert$19(!paused, "cannot be paused while waiting for headers"); + util.destroy(socket, new HeadersTimeoutError()); + } + } else if (timeoutType === TIMEOUT_BODY) { + if (!paused) util.destroy(socket, new BodyTimeoutError()); + } else if (timeoutType === TIMEOUT_KEEP_ALIVE) { + assert$19(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]); + util.destroy(socket, new InformationalError("socket idle timeout")); + } + } + async function connectH1(client, socket) { + client[kSocket] = socket; + if (!llhttpInstance) { + llhttpInstance = await llhttpPromise; + llhttpPromise = null; + } + socket[kNoRef] = false; + socket[kWriting] = false; + socket[kReset] = false; + socket[kBlocking] = false; + socket[kParser] = new Parser(client, socket, llhttpInstance); + addListener(socket, "error", function(err) { + assert$19(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); + const parser = this[kParser]; + if (err.code === "ECONNRESET" && parser.statusCode && !parser.shouldKeepAlive) { + parser.onMessageComplete(); + return; + } + this[kError] = err; + this[kClient][kOnError](err); + }); + addListener(socket, "readable", function() { + const parser = this[kParser]; + if (parser) parser.readMore(); + }); + addListener(socket, "end", function() { + const parser = this[kParser]; + if (parser.statusCode && !parser.shouldKeepAlive) { + parser.onMessageComplete(); + return; + } + util.destroy(this, new SocketError("other side closed", util.getSocketInfo(this))); + }); + addListener(socket, "close", function() { + const client = this[kClient]; + const parser = this[kParser]; + if (parser) { + if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) parser.onMessageComplete(); + this[kParser].destroy(); + this[kParser] = null; + } + const err = this[kError] || new SocketError("closed", util.getSocketInfo(this)); + client[kSocket] = null; + client[kHTTPContext] = null; + if (client.destroyed) { + assert$19(client[kPending] === 0); + const requests = client[kQueue].splice(client[kRunningIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + util.errorRequest(client, request, err); + } + } else if (client[kRunning] > 0 && err.code !== "UND_ERR_INFO") { + const request = client[kQueue][client[kRunningIdx]]; + client[kQueue][client[kRunningIdx]++] = null; + util.errorRequest(client, request, err); + } + client[kPendingIdx] = client[kRunningIdx]; + assert$19(client[kRunning] === 0); + client.emit("disconnect", client[kUrl], [client], err); + client[kResume](); + }); + let closed = false; + socket.on("close", () => { + closed = true; + }); + return { + version: "h1", + defaultPipelining: 1, + write(...args) { + return writeH1(client, ...args); + }, + resume() { + resumeH1(client); + }, + destroy(err, callback) { + if (closed) queueMicrotask(callback); + else socket.destroy(err).on("close", callback); + }, + get destroyed() { + return socket.destroyed; + }, + busy(request) { + if (socket[kWriting] || socket[kReset] || socket[kBlocking]) return true; + if (request) { + if (client[kRunning] > 0 && !request.idempotent) return true; + if (client[kRunning] > 0 && (request.upgrade || request.method === "CONNECT")) return true; + if (client[kRunning] > 0 && util.bodyLength(request.body) !== 0 && (util.isStream(request.body) || util.isAsyncIterable(request.body) || util.isFormDataLike(request.body))) return true; + } + return false; + } + }; + } + function resumeH1(client) { + const socket = client[kSocket]; + if (socket && !socket.destroyed) { + if (client[kSize] === 0) { + if (!socket[kNoRef] && socket.unref) { + socket.unref(); + socket[kNoRef] = true; + } + } else if (socket[kNoRef] && socket.ref) { + socket.ref(); + socket[kNoRef] = false; + } + if (client[kSize] === 0) { + if (socket[kParser].timeoutType !== TIMEOUT_KEEP_ALIVE) socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_KEEP_ALIVE); + } else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) { + if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) { + const request = client[kQueue][client[kRunningIdx]]; + const headersTimeout = request.headersTimeout != null ? request.headersTimeout : client[kHeadersTimeout]; + socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS); + } + } + } + } + function shouldSendContentLength(method) { + return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT"; + } + function writeH1(client, request) { + const { method, path, host, upgrade, blocking, reset } = request; + let { body, headers, contentLength } = request; + const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH"; + if (util.isFormDataLike(body)) { + if (!extractBody) extractBody = require_body().extractBody; + const [bodyStream, contentType] = extractBody(body); + if (request.contentType == null) headers.push("content-type", contentType); + body = bodyStream.stream; + contentLength = bodyStream.length; + } else if (util.isBlobLike(body) && request.contentType == null && body.type) headers.push("content-type", body.type); + if (body && typeof body.read === "function") body.read(0); + const bodyLength = util.bodyLength(body); + contentLength = bodyLength ?? contentLength; + if (contentLength === null) contentLength = request.contentLength; + if (contentLength === 0 && !expectsPayload) contentLength = null; + if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength !== null && request.contentLength !== contentLength) { + if (client[kStrictContentLength]) { + util.errorRequest(client, request, new RequestContentLengthMismatchError()); + return false; + } + process.emitWarning(new RequestContentLengthMismatchError()); + } + const socket = client[kSocket]; + const abort = (err) => { + if (request.aborted || request.completed) return; + util.errorRequest(client, request, err || new RequestAbortedError()); + util.destroy(body); + util.destroy(socket, new InformationalError("aborted")); + }; + try { + request.onConnect(abort); + } catch (err) { + util.errorRequest(client, request, err); + } + if (request.aborted) return false; + if (method === "HEAD") socket[kReset] = true; + if (upgrade || method === "CONNECT") socket[kReset] = true; + if (reset != null) socket[kReset] = reset; + if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) socket[kReset] = true; + if (blocking) socket[kBlocking] = true; + let header = `${method} ${path} HTTP/1.1\r\n`; + if (typeof host === "string") header += `host: ${host}\r\n`; + else header += client[kHostHeader]; + if (upgrade) header += `connection: upgrade\r\nupgrade: ${upgrade}\r\n`; + else if (client[kPipelining] && !socket[kReset]) header += "connection: keep-alive\r\n"; + else header += "connection: close\r\n"; + if (Array.isArray(headers)) for (let n = 0; n < headers.length; n += 2) { + const key = headers[n + 0]; + const val = headers[n + 1]; + if (Array.isArray(val)) for (let i = 0; i < val.length; i++) header += `${key}: ${val[i]}\r\n`; + else header += `${key}: ${val}\r\n`; + } + if (channels.sendHeaders.hasSubscribers) channels.sendHeaders.publish({ + request, + headers: header, + socket + }); + /* istanbul ignore else: assertion */ + if (!body || bodyLength === 0) writeBuffer(abort, null, client, request, socket, contentLength, header, expectsPayload); + else if (util.isBuffer(body)) writeBuffer(abort, body, client, request, socket, contentLength, header, expectsPayload); + else if (util.isBlobLike(body)) { + if (typeof body.stream === "function") writeIterable(abort, body.stream(), client, request, socket, contentLength, header, expectsPayload); + else writeBlob(abort, body, client, request, socket, contentLength, header, expectsPayload); + } else if (util.isStream(body)) writeStream(abort, body, client, request, socket, contentLength, header, expectsPayload); + else if (util.isIterable(body)) writeIterable(abort, body, client, request, socket, contentLength, header, expectsPayload); + else assert$19(false); + return true; + } + function writeStream(abort, body, client, request, socket, contentLength, header, expectsPayload) { + assert$19(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined"); + let finished = false; + const writer = new AsyncWriter({ + abort, + socket, + request, + contentLength, + client, + expectsPayload, + header + }); + const onData = function(chunk) { + if (finished) return; + try { + if (!writer.write(chunk) && this.pause) this.pause(); + } catch (err) { + util.destroy(this, err); + } + }; + const onDrain = function() { + if (finished) return; + if (body.resume) body.resume(); + }; + const onClose = function() { + queueMicrotask(() => { + body.removeListener("error", onFinished); + }); + if (!finished) { + const err = new RequestAbortedError(); + queueMicrotask(() => onFinished(err)); + } + }; + const onFinished = function(err) { + if (finished) return; + finished = true; + assert$19(socket.destroyed || socket[kWriting] && client[kRunning] <= 1); + socket.off("drain", onDrain).off("error", onFinished); + body.removeListener("data", onData).removeListener("end", onFinished).removeListener("close", onClose); + if (!err) try { + writer.end(); + } catch (er) { + err = er; + } + writer.destroy(err); + if (err && (err.code !== "UND_ERR_INFO" || err.message !== "reset")) util.destroy(body, err); + else util.destroy(body); + }; + body.on("data", onData).on("end", onFinished).on("error", onFinished).on("close", onClose); + if (body.resume) body.resume(); + socket.on("drain", onDrain).on("error", onFinished); + if (body.errorEmitted ?? body.errored) setImmediate(() => onFinished(body.errored)); + else if (body.endEmitted ?? body.readableEnded) setImmediate(() => onFinished(null)); + if (body.closeEmitted ?? body.closed) setImmediate(onClose); + } + function writeBuffer(abort, body, client, request, socket, contentLength, header, expectsPayload) { + try { + if (!body) { + if (contentLength === 0) socket.write(`${header}content-length: 0\r\n\r\n`, "latin1"); + else { + assert$19(contentLength === null, "no body must not have content length"); + socket.write(`${header}\r\n`, "latin1"); + } + } else if (util.isBuffer(body)) { + assert$19(contentLength === body.byteLength, "buffer body must have content length"); + socket.cork(); + socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, "latin1"); + socket.write(body); + socket.uncork(); + request.onBodySent(body); + if (!expectsPayload && request.reset !== false) socket[kReset] = true; + } + request.onRequestSent(); + client[kResume](); + } catch (err) { + abort(err); + } + } + async function writeBlob(abort, body, client, request, socket, contentLength, header, expectsPayload) { + assert$19(contentLength === body.size, "blob body must have content length"); + try { + if (contentLength != null && contentLength !== body.size) throw new RequestContentLengthMismatchError(); + const buffer = Buffer.from(await body.arrayBuffer()); + socket.cork(); + socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, "latin1"); + socket.write(buffer); + socket.uncork(); + request.onBodySent(buffer); + request.onRequestSent(); + if (!expectsPayload && request.reset !== false) socket[kReset] = true; + client[kResume](); + } catch (err) { + abort(err); + } + } + async function writeIterable(abort, body, client, request, socket, contentLength, header, expectsPayload) { + assert$19(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined"); + let callback = null; + function onDrain() { + if (callback) { + const cb = callback; + callback = null; + cb(); + } + } + const waitForDrain = () => new Promise((resolve, reject) => { + assert$19(callback === null); + if (socket[kError]) reject(socket[kError]); + else callback = resolve; + }); + socket.on("close", onDrain).on("drain", onDrain); + const writer = new AsyncWriter({ + abort, + socket, + request, + contentLength, + client, + expectsPayload, + header + }); + try { + for await (const chunk of body) { + if (socket[kError]) throw socket[kError]; + if (!writer.write(chunk)) await waitForDrain(); + } + writer.end(); + } catch (err) { + writer.destroy(err); + } finally { + socket.off("close", onDrain).off("drain", onDrain); + } + } + var AsyncWriter = class { + constructor({ abort, socket, request, contentLength, client, expectsPayload, header }) { + this.socket = socket; + this.request = request; + this.contentLength = contentLength; + this.client = client; + this.bytesWritten = 0; + this.expectsPayload = expectsPayload; + this.header = header; + this.abort = abort; + socket[kWriting] = true; + } + write(chunk) { + const { socket, request, contentLength, client, bytesWritten, expectsPayload, header } = this; + if (socket[kError]) throw socket[kError]; + if (socket.destroyed) return false; + const len = Buffer.byteLength(chunk); + if (!len) return true; + if (contentLength !== null && bytesWritten + len > contentLength) { + if (client[kStrictContentLength]) throw new RequestContentLengthMismatchError(); + process.emitWarning(new RequestContentLengthMismatchError()); + } + socket.cork(); + if (bytesWritten === 0) { + if (!expectsPayload && request.reset !== false) socket[kReset] = true; + if (contentLength === null) socket.write(`${header}transfer-encoding: chunked\r\n`, "latin1"); + else socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, "latin1"); + } + if (contentLength === null) socket.write(`\r\n${len.toString(16)}\r\n`, "latin1"); + this.bytesWritten += len; + const ret = socket.write(chunk); + socket.uncork(); + request.onBodySent(chunk); + if (!ret) { + if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) { + // istanbul ignore else: only for jest + if (socket[kParser].timeout.refresh) socket[kParser].timeout.refresh(); + } + } + return ret; + } + end() { + const { socket, contentLength, client, bytesWritten, expectsPayload, header, request } = this; + request.onRequestSent(); + socket[kWriting] = false; + if (socket[kError]) throw socket[kError]; + if (socket.destroyed) return; + if (bytesWritten === 0) { + if (expectsPayload) socket.write(`${header}content-length: 0\r\n\r\n`, "latin1"); + else socket.write(`${header}\r\n`, "latin1"); + } else if (contentLength === null) socket.write("\r\n0\r\n\r\n", "latin1"); + if (contentLength !== null && bytesWritten !== contentLength) { + if (client[kStrictContentLength]) throw new RequestContentLengthMismatchError(); + else process.emitWarning(new RequestContentLengthMismatchError()); + } + if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) { + // istanbul ignore else: only for jest + if (socket[kParser].timeout.refresh) socket[kParser].timeout.refresh(); + } + client[kResume](); + } + destroy(err) { + const { socket, client, abort } = this; + socket[kWriting] = false; + if (err) { + assert$19(client[kRunning] <= 1, "pipeline should only contain this request"); + abort(err); + } + } + }; + module.exports = connectH1; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/dispatcher/client-h2.js +var require_client_h2 = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const assert$18 = __require("node:assert"); + const { pipeline: pipeline$2 } = __require("node:stream"); + const util = require_util$7(); + const { RequestContentLengthMismatchError, RequestAbortedError, SocketError, InformationalError } = require_errors(); + const { kUrl, kReset, kClient, kRunning, kPending, kQueue, kPendingIdx, kRunningIdx, kError, kSocket, kStrictContentLength, kOnError, kMaxConcurrentStreams, kHTTP2Session, kResume, kSize, kHTTPContext } = require_symbols$4(); + const kOpenStreams = Symbol("open streams"); + let extractBody; + let h2ExperimentalWarned = false; + /** @type {import('http2')} */ + let http2; + try { + http2 = __require("node:http2"); + } catch { + http2 = { constants: {} }; + } + const { constants: { HTTP2_HEADER_AUTHORITY, HTTP2_HEADER_METHOD, HTTP2_HEADER_PATH, HTTP2_HEADER_SCHEME, HTTP2_HEADER_CONTENT_LENGTH, HTTP2_HEADER_EXPECT, HTTP2_HEADER_STATUS } } = http2; + function parseH2Headers(headers) { + const result = []; + for (const [name, value] of Object.entries(headers)) if (Array.isArray(value)) for (const subvalue of value) result.push(Buffer.from(name), Buffer.from(subvalue)); + else result.push(Buffer.from(name), Buffer.from(value)); + return result; + } + async function connectH2(client, socket) { + client[kSocket] = socket; + if (!h2ExperimentalWarned) { + h2ExperimentalWarned = true; + process.emitWarning("H2 support is experimental, expect them to change at any time.", { code: "UNDICI-H2" }); + } + const session = http2.connect(client[kUrl], { + createConnection: () => socket, + peerMaxConcurrentStreams: client[kMaxConcurrentStreams] + }); + session[kOpenStreams] = 0; + session[kClient] = client; + session[kSocket] = socket; + util.addListener(session, "error", onHttp2SessionError); + util.addListener(session, "frameError", onHttp2FrameError); + util.addListener(session, "end", onHttp2SessionEnd); + util.addListener(session, "goaway", onHTTP2GoAway); + util.addListener(session, "close", function() { + const { [kClient]: client } = this; + const { [kSocket]: socket } = client; + const err = this[kSocket][kError] || this[kError] || new SocketError("closed", util.getSocketInfo(socket)); + client[kHTTP2Session] = null; + if (client.destroyed) { + assert$18(client[kPending] === 0); + const requests = client[kQueue].splice(client[kRunningIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + util.errorRequest(client, request, err); + } + } + }); + session.unref(); + client[kHTTP2Session] = session; + socket[kHTTP2Session] = session; + util.addListener(socket, "error", function(err) { + assert$18(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); + this[kError] = err; + this[kClient][kOnError](err); + }); + util.addListener(socket, "end", function() { + util.destroy(this, new SocketError("other side closed", util.getSocketInfo(this))); + }); + util.addListener(socket, "close", function() { + const err = this[kError] || new SocketError("closed", util.getSocketInfo(this)); + client[kSocket] = null; + if (this[kHTTP2Session] != null) this[kHTTP2Session].destroy(err); + client[kPendingIdx] = client[kRunningIdx]; + assert$18(client[kRunning] === 0); + client.emit("disconnect", client[kUrl], [client], err); + client[kResume](); + }); + let closed = false; + socket.on("close", () => { + closed = true; + }); + return { + version: "h2", + defaultPipelining: Infinity, + write(...args) { + return writeH2(client, ...args); + }, + resume() { + resumeH2(client); + }, + destroy(err, callback) { + if (closed) queueMicrotask(callback); + else socket.destroy(err).on("close", callback); + }, + get destroyed() { + return socket.destroyed; + }, + busy() { + return false; + } + }; + } + function resumeH2(client) { + const socket = client[kSocket]; + if (socket?.destroyed === false) { + if (client[kSize] === 0 && client[kMaxConcurrentStreams] === 0) { + socket.unref(); + client[kHTTP2Session].unref(); + } else { + socket.ref(); + client[kHTTP2Session].ref(); + } + } + } + function onHttp2SessionError(err) { + assert$18(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); + this[kSocket][kError] = err; + this[kClient][kOnError](err); + } + function onHttp2FrameError(type, code, id) { + if (id === 0) { + const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`); + this[kSocket][kError] = err; + this[kClient][kOnError](err); + } + } + function onHttp2SessionEnd() { + const err = new SocketError("other side closed", util.getSocketInfo(this[kSocket])); + this.destroy(err); + util.destroy(this[kSocket], err); + } + /** + * This is the root cause of #3011 + * We need to handle GOAWAY frames properly, and trigger the session close + * along with the socket right away + */ + function onHTTP2GoAway(code) { + const err = this[kError] || new SocketError(`HTTP/2: "GOAWAY" frame received with code ${code}`, util.getSocketInfo(this)); + const client = this[kClient]; + client[kSocket] = null; + client[kHTTPContext] = null; + if (this[kHTTP2Session] != null) { + this[kHTTP2Session].destroy(err); + this[kHTTP2Session] = null; + } + util.destroy(this[kSocket], err); + if (client[kRunningIdx] < client[kQueue].length) { + const request = client[kQueue][client[kRunningIdx]]; + client[kQueue][client[kRunningIdx]++] = null; + util.errorRequest(client, request, err); + client[kPendingIdx] = client[kRunningIdx]; + } + assert$18(client[kRunning] === 0); + client.emit("disconnect", client[kUrl], [client], err); + client[kResume](); + } + function shouldSendContentLength(method) { + return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT"; + } + function writeH2(client, request) { + const session = client[kHTTP2Session]; + const { method, path, host, upgrade, expectContinue, signal, headers: reqHeaders } = request; + let { body } = request; + if (upgrade) { + util.errorRequest(client, request, /* @__PURE__ */ new Error("Upgrade not supported for H2")); + return false; + } + const headers = {}; + for (let n = 0; n < reqHeaders.length; n += 2) { + const key = reqHeaders[n + 0]; + const val = reqHeaders[n + 1]; + if (Array.isArray(val)) for (let i = 0; i < val.length; i++) if (headers[key]) headers[key] += `,${val[i]}`; + else headers[key] = val[i]; + else headers[key] = val; + } + /** @type {import('node:http2').ClientHttp2Stream} */ + let stream; + const { hostname, port } = client[kUrl]; + headers[HTTP2_HEADER_AUTHORITY] = host || `${hostname}${port ? `:${port}` : ""}`; + headers[HTTP2_HEADER_METHOD] = method; + const abort = (err) => { + if (request.aborted || request.completed) return; + err = err || new RequestAbortedError(); + util.errorRequest(client, request, err); + if (stream != null) util.destroy(stream, err); + util.destroy(body, err); + client[kQueue][client[kRunningIdx]++] = null; + client[kResume](); + }; + try { + request.onConnect(abort); + } catch (err) { + util.errorRequest(client, request, err); + } + if (request.aborted) return false; + if (method === "CONNECT") { + session.ref(); + stream = session.request(headers, { + endStream: false, + signal + }); + if (stream.id && !stream.pending) { + request.onUpgrade(null, null, stream); + ++session[kOpenStreams]; + client[kQueue][client[kRunningIdx]++] = null; + } else stream.once("ready", () => { + request.onUpgrade(null, null, stream); + ++session[kOpenStreams]; + client[kQueue][client[kRunningIdx]++] = null; + }); + stream.once("close", () => { + session[kOpenStreams] -= 1; + if (session[kOpenStreams] === 0) session.unref(); + }); + return true; + } + headers[HTTP2_HEADER_PATH] = path; + headers[HTTP2_HEADER_SCHEME] = "https"; + const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH"; + if (body && typeof body.read === "function") body.read(0); + let contentLength = util.bodyLength(body); + if (util.isFormDataLike(body)) { + extractBody ??= require_body().extractBody; + const [bodyStream, contentType] = extractBody(body); + headers["content-type"] = contentType; + body = bodyStream.stream; + contentLength = bodyStream.length; + } + if (contentLength == null) contentLength = request.contentLength; + if (contentLength === 0 || !expectsPayload) contentLength = null; + if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength != null && request.contentLength !== contentLength) { + if (client[kStrictContentLength]) { + util.errorRequest(client, request, new RequestContentLengthMismatchError()); + return false; + } + process.emitWarning(new RequestContentLengthMismatchError()); + } + if (contentLength != null) { + assert$18(body, "no body must not have content length"); + headers[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`; + } + session.ref(); + const shouldEndStream = method === "GET" || method === "HEAD" || body === null; + if (expectContinue) { + headers[HTTP2_HEADER_EXPECT] = "100-continue"; + stream = session.request(headers, { + endStream: shouldEndStream, + signal + }); + stream.once("continue", writeBodyH2); + } else { + stream = session.request(headers, { + endStream: shouldEndStream, + signal + }); + writeBodyH2(); + } + ++session[kOpenStreams]; + stream.once("response", (headers) => { + const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers; + request.onResponseStarted(); + if (request.aborted) { + const err = new RequestAbortedError(); + util.errorRequest(client, request, err); + util.destroy(stream, err); + return; + } + if (request.onHeaders(Number(statusCode), parseH2Headers(realHeaders), stream.resume.bind(stream), "") === false) stream.pause(); + stream.on("data", (chunk) => { + if (request.onData(chunk) === false) stream.pause(); + }); + }); + stream.once("end", () => { + if (stream.state?.state == null || stream.state.state < 6) request.onComplete([]); + if (session[kOpenStreams] === 0) session.unref(); + abort(new InformationalError("HTTP/2: stream half-closed (remote)")); + client[kQueue][client[kRunningIdx]++] = null; + client[kPendingIdx] = client[kRunningIdx]; + client[kResume](); + }); + stream.once("close", () => { + session[kOpenStreams] -= 1; + if (session[kOpenStreams] === 0) session.unref(); + }); + stream.once("error", function(err) { + abort(err); + }); + stream.once("frameError", (type, code) => { + abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`)); + }); + return true; + function writeBodyH2() { + /* istanbul ignore else: assertion */ + if (!body || contentLength === 0) writeBuffer(abort, stream, null, client, request, client[kSocket], contentLength, expectsPayload); + else if (util.isBuffer(body)) writeBuffer(abort, stream, body, client, request, client[kSocket], contentLength, expectsPayload); + else if (util.isBlobLike(body)) { + if (typeof body.stream === "function") writeIterable(abort, stream, body.stream(), client, request, client[kSocket], contentLength, expectsPayload); + else writeBlob(abort, stream, body, client, request, client[kSocket], contentLength, expectsPayload); + } else if (util.isStream(body)) writeStream(abort, client[kSocket], expectsPayload, stream, body, client, request, contentLength); + else if (util.isIterable(body)) writeIterable(abort, stream, body, client, request, client[kSocket], contentLength, expectsPayload); + else assert$18(false); + } + } + function writeBuffer(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) { + try { + if (body != null && util.isBuffer(body)) { + assert$18(contentLength === body.byteLength, "buffer body must have content length"); + h2stream.cork(); + h2stream.write(body); + h2stream.uncork(); + h2stream.end(); + request.onBodySent(body); + } + if (!expectsPayload) socket[kReset] = true; + request.onRequestSent(); + client[kResume](); + } catch (error) { + abort(error); + } + } + function writeStream(abort, socket, expectsPayload, h2stream, body, client, request, contentLength) { + assert$18(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined"); + const pipe = pipeline$2(body, h2stream, (err) => { + if (err) { + util.destroy(pipe, err); + abort(err); + } else { + util.removeAllListeners(pipe); + request.onRequestSent(); + if (!expectsPayload) socket[kReset] = true; + client[kResume](); + } + }); + util.addListener(pipe, "data", onPipeData); + function onPipeData(chunk) { + request.onBodySent(chunk); + } + } + async function writeBlob(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) { + assert$18(contentLength === body.size, "blob body must have content length"); + try { + if (contentLength != null && contentLength !== body.size) throw new RequestContentLengthMismatchError(); + const buffer = Buffer.from(await body.arrayBuffer()); + h2stream.cork(); + h2stream.write(buffer); + h2stream.uncork(); + h2stream.end(); + request.onBodySent(buffer); + request.onRequestSent(); + if (!expectsPayload) socket[kReset] = true; + client[kResume](); + } catch (err) { + abort(err); + } + } + async function writeIterable(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) { + assert$18(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined"); + let callback = null; + function onDrain() { + if (callback) { + const cb = callback; + callback = null; + cb(); + } + } + const waitForDrain = () => new Promise((resolve, reject) => { + assert$18(callback === null); + if (socket[kError]) reject(socket[kError]); + else callback = resolve; + }); + h2stream.on("close", onDrain).on("drain", onDrain); + try { + for await (const chunk of body) { + if (socket[kError]) throw socket[kError]; + const res = h2stream.write(chunk); + request.onBodySent(chunk); + if (!res) await waitForDrain(); + } + h2stream.end(); + request.onRequestSent(); + if (!expectsPayload) socket[kReset] = true; + client[kResume](); + } catch (err) { + abort(err); + } finally { + h2stream.off("close", onDrain).off("drain", onDrain); + } + } + module.exports = connectH2; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/handler/redirect-handler.js +var require_redirect_handler = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const util = require_util$7(); + const { kBodyUsed } = require_symbols$4(); + const assert$17 = __require("node:assert"); + const { InvalidArgumentError } = require_errors(); + const EE$1 = __require("node:events"); + const redirectableStatusCodes = [ + 300, + 301, + 302, + 303, + 307, + 308 + ]; + const kBody = Symbol("body"); + var BodyAsyncIterable = class { + constructor(body) { + this[kBody] = body; + this[kBodyUsed] = false; + } + async *[Symbol.asyncIterator]() { + assert$17(!this[kBodyUsed], "disturbed"); + this[kBodyUsed] = true; + yield* this[kBody]; + } + }; + var RedirectHandler = class { + constructor(dispatch, maxRedirections, opts, handler) { + if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) throw new InvalidArgumentError("maxRedirections must be a positive number"); + util.validateHandler(handler, opts.method, opts.upgrade); + this.dispatch = dispatch; + this.location = null; + this.abort = null; + this.opts = { + ...opts, + maxRedirections: 0 + }; + this.maxRedirections = maxRedirections; + this.handler = handler; + this.history = []; + this.redirectionLimitReached = false; + if (util.isStream(this.opts.body)) { + if (util.bodyLength(this.opts.body) === 0) this.opts.body.on("data", function() { + assert$17(false); + }); + if (typeof this.opts.body.readableDidRead !== "boolean") { + this.opts.body[kBodyUsed] = false; + EE$1.prototype.on.call(this.opts.body, "data", function() { + this[kBodyUsed] = true; + }); + } + } else if (this.opts.body && typeof this.opts.body.pipeTo === "function") this.opts.body = new BodyAsyncIterable(this.opts.body); + else if (this.opts.body && typeof this.opts.body !== "string" && !ArrayBuffer.isView(this.opts.body) && util.isIterable(this.opts.body)) this.opts.body = new BodyAsyncIterable(this.opts.body); + } + onConnect(abort) { + this.abort = abort; + this.handler.onConnect(abort, { history: this.history }); + } + onUpgrade(statusCode, headers, socket) { + this.handler.onUpgrade(statusCode, headers, socket); + } + onError(error) { + this.handler.onError(error); + } + onHeaders(statusCode, headers, resume, statusText) { + this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body) ? null : parseLocation(statusCode, headers); + if (this.opts.throwOnMaxRedirect && this.history.length >= this.maxRedirections) { + if (this.request) this.request.abort(/* @__PURE__ */ new Error("max redirects")); + this.redirectionLimitReached = true; + this.abort(/* @__PURE__ */ new Error("max redirects")); + return; + } + if (this.opts.origin) this.history.push(new URL(this.opts.path, this.opts.origin)); + if (!this.location) return this.handler.onHeaders(statusCode, headers, resume, statusText); + const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin))); + const path = search ? `${pathname}${search}` : pathname; + this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin); + this.opts.path = path; + this.opts.origin = origin; + this.opts.maxRedirections = 0; + this.opts.query = null; + if (statusCode === 303 && this.opts.method !== "HEAD") { + this.opts.method = "GET"; + this.opts.body = null; + } + } + onData(chunk) { + if (this.location) {} else return this.handler.onData(chunk); + } + onComplete(trailers) { + if (this.location) { + this.location = null; + this.abort = null; + this.dispatch(this.opts, this); + } else this.handler.onComplete(trailers); + } + onBodySent(chunk) { + if (this.handler.onBodySent) this.handler.onBodySent(chunk); + } + }; + function parseLocation(statusCode, headers) { + if (redirectableStatusCodes.indexOf(statusCode) === -1) return null; + for (let i = 0; i < headers.length; i += 2) if (headers[i].length === 8 && util.headerNameToString(headers[i]) === "location") return headers[i + 1]; + } + function shouldRemoveHeader(header, removeContent, unknownOrigin) { + if (header.length === 4) return util.headerNameToString(header) === "host"; + if (removeContent && util.headerNameToString(header).startsWith("content-")) return true; + if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) { + const name = util.headerNameToString(header); + return name === "authorization" || name === "cookie" || name === "proxy-authorization"; + } + return false; + } + function cleanRequestHeaders(headers, removeContent, unknownOrigin) { + const ret = []; + if (Array.isArray(headers)) { + for (let i = 0; i < headers.length; i += 2) if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin)) ret.push(headers[i], headers[i + 1]); + } else if (headers && typeof headers === "object") { + for (const key of Object.keys(headers)) if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) ret.push(key, headers[key]); + } else assert$17(headers == null, "headers must be an object or an array"); + return ret; + } + module.exports = RedirectHandler; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/interceptor/redirect-interceptor.js +var require_redirect_interceptor = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const RedirectHandler = require_redirect_handler(); + function createRedirectInterceptor({ maxRedirections: defaultMaxRedirections }) { + return (dispatch) => { + return function Intercept(opts, handler) { + const { maxRedirections = defaultMaxRedirections } = opts; + if (!maxRedirections) return dispatch(opts, handler); + const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler); + opts = { + ...opts, + maxRedirections: 0 + }; + return dispatch(opts, redirectHandler); + }; + }; + } + module.exports = createRedirectInterceptor; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/dispatcher/client.js +var require_client = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const assert$16 = __require("node:assert"); + const net = __require("node:net"); + const http$1 = __require("node:http"); + const util = require_util$7(); + const { channels } = require_diagnostics(); + const Request = require_request$1(); + const DispatcherBase = require_dispatcher_base(); + const { InvalidArgumentError, InformationalError, ClientDestroyedError } = require_errors(); + const buildConnector = require_connect(); + const { kUrl, kServerName, kClient, kBusy, kConnect, kResuming, kRunning, kPending, kSize, kQueue, kConnected, kConnecting, kNeedDrain, kKeepAliveDefaultTimeout, kHostHeader, kPendingIdx, kRunningIdx, kError, kPipelining, kKeepAliveTimeoutValue, kMaxHeadersSize, kKeepAliveMaxTimeout, kKeepAliveTimeoutThreshold, kHeadersTimeout, kBodyTimeout, kStrictContentLength, kConnector, kMaxRedirections, kMaxRequests, kCounter, kClose, kDestroy, kDispatch, kInterceptors, kLocalAddress, kMaxResponseSize, kOnError, kHTTPContext, kMaxConcurrentStreams, kResume } = require_symbols$4(); + const connectH1 = require_client_h1(); + const connectH2 = require_client_h2(); + let deprecatedInterceptorWarned = false; + const kClosedResolve = Symbol("kClosedResolve"); + const noop = () => {}; + function getPipelining(client) { + return client[kPipelining] ?? client[kHTTPContext]?.defaultPipelining ?? 1; + } + /** + * @type {import('../../types/client.js').default} + */ + var Client = class extends DispatcherBase { + /** + * + * @param {string|URL} url + * @param {import('../../types/client.js').Client.Options} options + */ + constructor(url, { interceptors, maxHeaderSize, headersTimeout, socketTimeout, requestTimeout, connectTimeout, bodyTimeout, idleTimeout, keepAlive, keepAliveTimeout, maxKeepAliveTimeout, keepAliveMaxTimeout, keepAliveTimeoutThreshold, socketPath, pipelining, tls, strictContentLength, maxCachedSessions, maxRedirections, connect, maxRequestsPerClient, localAddress, maxResponseSize, autoSelectFamily, autoSelectFamilyAttemptTimeout, maxConcurrentStreams, allowH2 } = {}) { + super(); + if (keepAlive !== void 0) throw new InvalidArgumentError("unsupported keepAlive, use pipelining=0 instead"); + if (socketTimeout !== void 0) throw new InvalidArgumentError("unsupported socketTimeout, use headersTimeout & bodyTimeout instead"); + if (requestTimeout !== void 0) throw new InvalidArgumentError("unsupported requestTimeout, use headersTimeout & bodyTimeout instead"); + if (idleTimeout !== void 0) throw new InvalidArgumentError("unsupported idleTimeout, use keepAliveTimeout instead"); + if (maxKeepAliveTimeout !== void 0) throw new InvalidArgumentError("unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead"); + if (maxHeaderSize != null && !Number.isFinite(maxHeaderSize)) throw new InvalidArgumentError("invalid maxHeaderSize"); + if (socketPath != null && typeof socketPath !== "string") throw new InvalidArgumentError("invalid socketPath"); + if (connectTimeout != null && (!Number.isFinite(connectTimeout) || connectTimeout < 0)) throw new InvalidArgumentError("invalid connectTimeout"); + if (keepAliveTimeout != null && (!Number.isFinite(keepAliveTimeout) || keepAliveTimeout <= 0)) throw new InvalidArgumentError("invalid keepAliveTimeout"); + if (keepAliveMaxTimeout != null && (!Number.isFinite(keepAliveMaxTimeout) || keepAliveMaxTimeout <= 0)) throw new InvalidArgumentError("invalid keepAliveMaxTimeout"); + if (keepAliveTimeoutThreshold != null && !Number.isFinite(keepAliveTimeoutThreshold)) throw new InvalidArgumentError("invalid keepAliveTimeoutThreshold"); + if (headersTimeout != null && (!Number.isInteger(headersTimeout) || headersTimeout < 0)) throw new InvalidArgumentError("headersTimeout must be a positive integer or zero"); + if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) throw new InvalidArgumentError("bodyTimeout must be a positive integer or zero"); + if (connect != null && typeof connect !== "function" && typeof connect !== "object") throw new InvalidArgumentError("connect must be a function or an object"); + if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) throw new InvalidArgumentError("maxRedirections must be a positive number"); + if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) throw new InvalidArgumentError("maxRequestsPerClient must be a positive number"); + if (localAddress != null && (typeof localAddress !== "string" || net.isIP(localAddress) === 0)) throw new InvalidArgumentError("localAddress must be valid string IP address"); + if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) throw new InvalidArgumentError("maxResponseSize must be a positive number"); + if (autoSelectFamilyAttemptTimeout != null && (!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1)) throw new InvalidArgumentError("autoSelectFamilyAttemptTimeout must be a positive number"); + if (allowH2 != null && typeof allowH2 !== "boolean") throw new InvalidArgumentError("allowH2 must be a valid boolean value"); + if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== "number" || maxConcurrentStreams < 1)) throw new InvalidArgumentError("maxConcurrentStreams must be a positive integer, greater than 0"); + if (typeof connect !== "function") connect = buildConnector({ + ...tls, + maxCachedSessions, + allowH2, + socketPath, + timeout: connectTimeout, + ...autoSelectFamily ? { + autoSelectFamily, + autoSelectFamilyAttemptTimeout + } : void 0, + ...connect + }); + if (interceptors?.Client && Array.isArray(interceptors.Client)) { + this[kInterceptors] = interceptors.Client; + if (!deprecatedInterceptorWarned) { + deprecatedInterceptorWarned = true; + process.emitWarning("Client.Options#interceptor is deprecated. Use Dispatcher#compose instead.", { code: "UNDICI-CLIENT-INTERCEPTOR-DEPRECATED" }); + } + } else this[kInterceptors] = [createRedirectInterceptor({ maxRedirections })]; + this[kUrl] = util.parseOrigin(url); + this[kConnector] = connect; + this[kPipelining] = pipelining != null ? pipelining : 1; + this[kMaxHeadersSize] = maxHeaderSize || http$1.maxHeaderSize; + this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout; + this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 6e5 : keepAliveMaxTimeout; + this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 2e3 : keepAliveTimeoutThreshold; + this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout]; + this[kServerName] = null; + this[kLocalAddress] = localAddress != null ? localAddress : null; + this[kResuming] = 0; + this[kNeedDrain] = 0; + this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}\r\n`; + this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 3e5; + this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 3e5; + this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength; + this[kMaxRedirections] = maxRedirections; + this[kMaxRequests] = maxRequestsPerClient; + this[kClosedResolve] = null; + this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1; + this[kMaxConcurrentStreams] = maxConcurrentStreams != null ? maxConcurrentStreams : 100; + this[kHTTPContext] = null; + this[kQueue] = []; + this[kRunningIdx] = 0; + this[kPendingIdx] = 0; + this[kResume] = (sync) => resume(this, sync); + this[kOnError] = (err) => onError(this, err); + } + get pipelining() { + return this[kPipelining]; + } + set pipelining(value) { + this[kPipelining] = value; + this[kResume](true); + } + get [kPending]() { + return this[kQueue].length - this[kPendingIdx]; + } + get [kRunning]() { + return this[kPendingIdx] - this[kRunningIdx]; + } + get [kSize]() { + return this[kQueue].length - this[kRunningIdx]; + } + get [kConnected]() { + return !!this[kHTTPContext] && !this[kConnecting] && !this[kHTTPContext].destroyed; + } + get [kBusy]() { + return Boolean(this[kHTTPContext]?.busy(null) || this[kSize] >= (getPipelining(this) || 1) || this[kPending] > 0); + } + /* istanbul ignore: only used for test */ + [kConnect](cb) { + connect(this); + this.once("connect", cb); + } + [kDispatch](opts, handler) { + const origin = opts.origin || this[kUrl].origin; + const request = new Request(origin, opts, handler); + this[kQueue].push(request); + if (this[kResuming]) {} else if (util.bodyLength(request.body) == null && util.isIterable(request.body)) { + this[kResuming] = 1; + queueMicrotask(() => resume(this)); + } else this[kResume](true); + if (this[kResuming] && this[kNeedDrain] !== 2 && this[kBusy]) this[kNeedDrain] = 2; + return this[kNeedDrain] < 2; + } + async [kClose]() { + return new Promise((resolve) => { + if (this[kSize]) this[kClosedResolve] = resolve; + else resolve(null); + }); + } + async [kDestroy](err) { + return new Promise((resolve) => { + const requests = this[kQueue].splice(this[kPendingIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + util.errorRequest(this, request, err); + } + const callback = () => { + if (this[kClosedResolve]) { + this[kClosedResolve](); + this[kClosedResolve] = null; + } + resolve(null); + }; + if (this[kHTTPContext]) { + this[kHTTPContext].destroy(err, callback); + this[kHTTPContext] = null; + } else queueMicrotask(callback); + this[kResume](); + }); + } + }; + const createRedirectInterceptor = require_redirect_interceptor(); + function onError(client, err) { + if (client[kRunning] === 0 && err.code !== "UND_ERR_INFO" && err.code !== "UND_ERR_SOCKET") { + assert$16(client[kPendingIdx] === client[kRunningIdx]); + const requests = client[kQueue].splice(client[kRunningIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + util.errorRequest(client, request, err); + } + assert$16(client[kSize] === 0); + } + } + /** + * @param {Client} client + * @returns + */ + async function connect(client) { + assert$16(!client[kConnecting]); + assert$16(!client[kHTTPContext]); + let { host, hostname, protocol, port } = client[kUrl]; + if (hostname[0] === "[") { + const idx = hostname.indexOf("]"); + assert$16(idx !== -1); + const ip = hostname.substring(1, idx); + assert$16(net.isIP(ip)); + hostname = ip; + } + client[kConnecting] = true; + if (channels.beforeConnect.hasSubscribers) channels.beforeConnect.publish({ + connectParams: { + host, + hostname, + protocol, + port, + version: client[kHTTPContext]?.version, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, + connector: client[kConnector] + }); + try { + const socket = await new Promise((resolve, reject) => { + client[kConnector]({ + host, + hostname, + protocol, + port, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, (err, socket) => { + if (err) reject(err); + else resolve(socket); + }); + }); + if (client.destroyed) { + util.destroy(socket.on("error", noop), new ClientDestroyedError()); + return; + } + assert$16(socket); + try { + client[kHTTPContext] = socket.alpnProtocol === "h2" ? await connectH2(client, socket) : await connectH1(client, socket); + } catch (err) { + socket.destroy().on("error", noop); + throw err; + } + client[kConnecting] = false; + socket[kCounter] = 0; + socket[kMaxRequests] = client[kMaxRequests]; + socket[kClient] = client; + socket[kError] = null; + if (channels.connected.hasSubscribers) channels.connected.publish({ + connectParams: { + host, + hostname, + protocol, + port, + version: client[kHTTPContext]?.version, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, + connector: client[kConnector], + socket + }); + client.emit("connect", client[kUrl], [client]); + } catch (err) { + if (client.destroyed) return; + client[kConnecting] = false; + if (channels.connectError.hasSubscribers) channels.connectError.publish({ + connectParams: { + host, + hostname, + protocol, + port, + version: client[kHTTPContext]?.version, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, + connector: client[kConnector], + error: err + }); + if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") { + assert$16(client[kRunning] === 0); + while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) { + const request = client[kQueue][client[kPendingIdx]++]; + util.errorRequest(client, request, err); + } + } else onError(client, err); + client.emit("connectionError", client[kUrl], [client], err); + } + client[kResume](); + } + function emitDrain(client) { + client[kNeedDrain] = 0; + client.emit("drain", client[kUrl], [client]); + } + function resume(client, sync) { + if (client[kResuming] === 2) return; + client[kResuming] = 2; + _resume(client, sync); + client[kResuming] = 0; + if (client[kRunningIdx] > 256) { + client[kQueue].splice(0, client[kRunningIdx]); + client[kPendingIdx] -= client[kRunningIdx]; + client[kRunningIdx] = 0; + } + } + function _resume(client, sync) { + while (true) { + if (client.destroyed) { + assert$16(client[kPending] === 0); + return; + } + if (client[kClosedResolve] && !client[kSize]) { + client[kClosedResolve](); + client[kClosedResolve] = null; + return; + } + if (client[kHTTPContext]) client[kHTTPContext].resume(); + if (client[kBusy]) client[kNeedDrain] = 2; + else if (client[kNeedDrain] === 2) { + if (sync) { + client[kNeedDrain] = 1; + queueMicrotask(() => emitDrain(client)); + } else emitDrain(client); + continue; + } + if (client[kPending] === 0) return; + if (client[kRunning] >= (getPipelining(client) || 1)) return; + const request = client[kQueue][client[kPendingIdx]]; + if (client[kUrl].protocol === "https:" && client[kServerName] !== request.servername) { + if (client[kRunning] > 0) return; + client[kServerName] = request.servername; + client[kHTTPContext]?.destroy(new InformationalError("servername changed"), () => { + client[kHTTPContext] = null; + resume(client); + }); + } + if (client[kConnecting]) return; + if (!client[kHTTPContext]) { + connect(client); + return; + } + if (client[kHTTPContext].destroyed) return; + if (client[kHTTPContext].busy(request)) return; + if (!request.aborted && client[kHTTPContext].write(request)) client[kPendingIdx]++; + else client[kQueue].splice(client[kPendingIdx], 1); + } + } + module.exports = Client; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/dispatcher/fixed-queue.js +var require_fixed_queue = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const kSize = 2048; + const kMask = 2047; + var FixedCircularBuffer = class { + constructor() { + this.bottom = 0; + this.top = 0; + this.list = new Array(kSize); + this.next = null; + } + isEmpty() { + return this.top === this.bottom; + } + isFull() { + return (this.top + 1 & kMask) === this.bottom; + } + push(data) { + this.list[this.top] = data; + this.top = this.top + 1 & kMask; + } + shift() { + const nextItem = this.list[this.bottom]; + if (nextItem === void 0) return null; + this.list[this.bottom] = void 0; + this.bottom = this.bottom + 1 & kMask; + return nextItem; + } + }; + module.exports = class FixedQueue { + constructor() { + this.head = this.tail = new FixedCircularBuffer(); + } + isEmpty() { + return this.head.isEmpty(); + } + push(data) { + if (this.head.isFull()) this.head = this.head.next = new FixedCircularBuffer(); + this.head.push(data); + } + shift() { + const tail = this.tail; + const next = tail.shift(); + if (tail.isEmpty() && tail.next !== null) this.tail = tail.next; + return next; + } + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/dispatcher/pool-stats.js +var require_pool_stats = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { kFree, kConnected, kPending, kQueued, kRunning, kSize } = require_symbols$4(); + const kPool = Symbol("pool"); + var PoolStats = class { + constructor(pool) { + this[kPool] = pool; + } + get connected() { + return this[kPool][kConnected]; + } + get free() { + return this[kPool][kFree]; + } + get pending() { + return this[kPool][kPending]; + } + get queued() { + return this[kPool][kQueued]; + } + get running() { + return this[kPool][kRunning]; + } + get size() { + return this[kPool][kSize]; + } + }; + module.exports = PoolStats; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/dispatcher/pool-base.js +var require_pool_base = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const DispatcherBase = require_dispatcher_base(); + const FixedQueue = require_fixed_queue(); + const { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = require_symbols$4(); + const PoolStats = require_pool_stats(); + const kClients = Symbol("clients"); + const kNeedDrain = Symbol("needDrain"); + const kQueue = Symbol("queue"); + const kClosedResolve = Symbol("closed resolve"); + const kOnDrain = Symbol("onDrain"); + const kOnConnect = Symbol("onConnect"); + const kOnDisconnect = Symbol("onDisconnect"); + const kOnConnectionError = Symbol("onConnectionError"); + const kGetDispatcher = Symbol("get dispatcher"); + const kAddClient = Symbol("add client"); + const kRemoveClient = Symbol("remove client"); + const kStats = Symbol("stats"); + var PoolBase = class extends DispatcherBase { + constructor() { + super(); + this[kQueue] = new FixedQueue(); + this[kClients] = []; + this[kQueued] = 0; + const pool = this; + this[kOnDrain] = function onDrain(origin, targets) { + const queue = pool[kQueue]; + let needDrain = false; + while (!needDrain) { + const item = queue.shift(); + if (!item) break; + pool[kQueued]--; + needDrain = !this.dispatch(item.opts, item.handler); + } + this[kNeedDrain] = needDrain; + if (!this[kNeedDrain] && pool[kNeedDrain]) { + pool[kNeedDrain] = false; + pool.emit("drain", origin, [pool, ...targets]); + } + if (pool[kClosedResolve] && queue.isEmpty()) Promise.all(pool[kClients].map((c) => c.close())).then(pool[kClosedResolve]); + }; + this[kOnConnect] = (origin, targets) => { + pool.emit("connect", origin, [pool, ...targets]); + }; + this[kOnDisconnect] = (origin, targets, err) => { + pool.emit("disconnect", origin, [pool, ...targets], err); + }; + this[kOnConnectionError] = (origin, targets, err) => { + pool.emit("connectionError", origin, [pool, ...targets], err); + }; + this[kStats] = new PoolStats(this); + } + get [kBusy]() { + return this[kNeedDrain]; + } + get [kConnected]() { + return this[kClients].filter((client) => client[kConnected]).length; + } + get [kFree]() { + return this[kClients].filter((client) => client[kConnected] && !client[kNeedDrain]).length; + } + get [kPending]() { + let ret = this[kQueued]; + for (const { [kPending]: pending } of this[kClients]) ret += pending; + return ret; + } + get [kRunning]() { + let ret = 0; + for (const { [kRunning]: running } of this[kClients]) ret += running; + return ret; + } + get [kSize]() { + let ret = this[kQueued]; + for (const { [kSize]: size } of this[kClients]) ret += size; + return ret; + } + get stats() { + return this[kStats]; + } + async [kClose]() { + if (this[kQueue].isEmpty()) await Promise.all(this[kClients].map((c) => c.close())); + else await new Promise((resolve) => { + this[kClosedResolve] = resolve; + }); + } + async [kDestroy](err) { + while (true) { + const item = this[kQueue].shift(); + if (!item) break; + item.handler.onError(err); + } + await Promise.all(this[kClients].map((c) => c.destroy(err))); + } + [kDispatch](opts, handler) { + const dispatcher = this[kGetDispatcher](); + if (!dispatcher) { + this[kNeedDrain] = true; + this[kQueue].push({ + opts, + handler + }); + this[kQueued]++; + } else if (!dispatcher.dispatch(opts, handler)) { + dispatcher[kNeedDrain] = true; + this[kNeedDrain] = !this[kGetDispatcher](); + } + return !this[kNeedDrain]; + } + [kAddClient](client) { + client.on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]); + this[kClients].push(client); + if (this[kNeedDrain]) queueMicrotask(() => { + if (this[kNeedDrain]) this[kOnDrain](client[kUrl], [this, client]); + }); + return this; + } + [kRemoveClient](client) { + client.close(() => { + const idx = this[kClients].indexOf(client); + if (idx !== -1) this[kClients].splice(idx, 1); + }); + this[kNeedDrain] = this[kClients].some((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true); + } + }; + module.exports = { + PoolBase, + kClients, + kNeedDrain, + kAddClient, + kRemoveClient, + kGetDispatcher + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/dispatcher/pool.js +var require_pool = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { PoolBase, kClients, kNeedDrain, kAddClient, kGetDispatcher } = require_pool_base(); + const Client = require_client(); + const { InvalidArgumentError } = require_errors(); + const util = require_util$7(); + const { kUrl, kInterceptors } = require_symbols$4(); + const buildConnector = require_connect(); + const kOptions = Symbol("options"); + const kConnections = Symbol("connections"); + const kFactory = Symbol("factory"); + function defaultFactory(origin, opts) { + return new Client(origin, opts); + } + var Pool = class extends PoolBase { + constructor(origin, { connections, factory = defaultFactory, connect, connectTimeout, tls, maxCachedSessions, socketPath, autoSelectFamily, autoSelectFamilyAttemptTimeout, allowH2, ...options } = {}) { + super(); + if (connections != null && (!Number.isFinite(connections) || connections < 0)) throw new InvalidArgumentError("invalid connections"); + if (typeof factory !== "function") throw new InvalidArgumentError("factory must be a function."); + if (connect != null && typeof connect !== "function" && typeof connect !== "object") throw new InvalidArgumentError("connect must be a function or an object"); + if (typeof connect !== "function") connect = buildConnector({ + ...tls, + maxCachedSessions, + allowH2, + socketPath, + timeout: connectTimeout, + ...autoSelectFamily ? { + autoSelectFamily, + autoSelectFamilyAttemptTimeout + } : void 0, + ...connect + }); + this[kInterceptors] = options.interceptors?.Pool && Array.isArray(options.interceptors.Pool) ? options.interceptors.Pool : []; + this[kConnections] = connections || null; + this[kUrl] = util.parseOrigin(origin); + this[kOptions] = { + ...util.deepClone(options), + connect, + allowH2 + }; + this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0; + this[kFactory] = factory; + this.on("connectionError", (origin, targets, error) => { + for (const target of targets) { + const idx = this[kClients].indexOf(target); + if (idx !== -1) this[kClients].splice(idx, 1); + } + }); + } + [kGetDispatcher]() { + for (const client of this[kClients]) if (!client[kNeedDrain]) return client; + if (!this[kConnections] || this[kClients].length < this[kConnections]) { + const dispatcher = this[kFactory](this[kUrl], this[kOptions]); + this[kAddClient](dispatcher); + return dispatcher; + } + } + }; + module.exports = Pool; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/dispatcher/balanced-pool.js +var require_balanced_pool = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { BalancedPoolMissingUpstreamError, InvalidArgumentError } = require_errors(); + const { PoolBase, kClients, kNeedDrain, kAddClient, kRemoveClient, kGetDispatcher } = require_pool_base(); + const Pool = require_pool(); + const { kUrl, kInterceptors } = require_symbols$4(); + const { parseOrigin } = require_util$7(); + const kFactory = Symbol("factory"); + const kOptions = Symbol("options"); + const kGreatestCommonDivisor = Symbol("kGreatestCommonDivisor"); + const kCurrentWeight = Symbol("kCurrentWeight"); + const kIndex = Symbol("kIndex"); + const kWeight = Symbol("kWeight"); + const kMaxWeightPerServer = Symbol("kMaxWeightPerServer"); + const kErrorPenalty = Symbol("kErrorPenalty"); + /** + * Calculate the greatest common divisor of two numbers by + * using the Euclidean algorithm. + * + * @param {number} a + * @param {number} b + * @returns {number} + */ + function getGreatestCommonDivisor(a, b) { + if (a === 0) return b; + while (b !== 0) { + const t = b; + b = a % b; + a = t; + } + return a; + } + function defaultFactory(origin, opts) { + return new Pool(origin, opts); + } + var BalancedPool = class extends PoolBase { + constructor(upstreams = [], { factory = defaultFactory, ...opts } = {}) { + super(); + this[kOptions] = opts; + this[kIndex] = -1; + this[kCurrentWeight] = 0; + this[kMaxWeightPerServer] = this[kOptions].maxWeightPerServer || 100; + this[kErrorPenalty] = this[kOptions].errorPenalty || 15; + if (!Array.isArray(upstreams)) upstreams = [upstreams]; + if (typeof factory !== "function") throw new InvalidArgumentError("factory must be a function."); + this[kInterceptors] = opts.interceptors?.BalancedPool && Array.isArray(opts.interceptors.BalancedPool) ? opts.interceptors.BalancedPool : []; + this[kFactory] = factory; + for (const upstream of upstreams) this.addUpstream(upstream); + this._updateBalancedPoolStats(); + } + addUpstream(upstream) { + const upstreamOrigin = parseOrigin(upstream).origin; + if (this[kClients].find((pool) => pool[kUrl].origin === upstreamOrigin && pool.closed !== true && pool.destroyed !== true)) return this; + const pool = this[kFactory](upstreamOrigin, Object.assign({}, this[kOptions])); + this[kAddClient](pool); + pool.on("connect", () => { + pool[kWeight] = Math.min(this[kMaxWeightPerServer], pool[kWeight] + this[kErrorPenalty]); + }); + pool.on("connectionError", () => { + pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty]); + this._updateBalancedPoolStats(); + }); + pool.on("disconnect", (...args) => { + const err = args[2]; + if (err && err.code === "UND_ERR_SOCKET") { + pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty]); + this._updateBalancedPoolStats(); + } + }); + for (const client of this[kClients]) client[kWeight] = this[kMaxWeightPerServer]; + this._updateBalancedPoolStats(); + return this; + } + _updateBalancedPoolStats() { + let result = 0; + for (let i = 0; i < this[kClients].length; i++) result = getGreatestCommonDivisor(this[kClients][i][kWeight], result); + this[kGreatestCommonDivisor] = result; + } + removeUpstream(upstream) { + const upstreamOrigin = parseOrigin(upstream).origin; + const pool = this[kClients].find((pool) => pool[kUrl].origin === upstreamOrigin && pool.closed !== true && pool.destroyed !== true); + if (pool) this[kRemoveClient](pool); + return this; + } + get upstreams() { + return this[kClients].filter((dispatcher) => dispatcher.closed !== true && dispatcher.destroyed !== true).map((p) => p[kUrl].origin); + } + [kGetDispatcher]() { + if (this[kClients].length === 0) throw new BalancedPoolMissingUpstreamError(); + if (!this[kClients].find((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true)) return; + if (this[kClients].map((pool) => pool[kNeedDrain]).reduce((a, b) => a && b, true)) return; + let counter = 0; + let maxWeightIndex = this[kClients].findIndex((pool) => !pool[kNeedDrain]); + while (counter++ < this[kClients].length) { + this[kIndex] = (this[kIndex] + 1) % this[kClients].length; + const pool = this[kClients][this[kIndex]]; + if (pool[kWeight] > this[kClients][maxWeightIndex][kWeight] && !pool[kNeedDrain]) maxWeightIndex = this[kIndex]; + if (this[kIndex] === 0) { + this[kCurrentWeight] = this[kCurrentWeight] - this[kGreatestCommonDivisor]; + if (this[kCurrentWeight] <= 0) this[kCurrentWeight] = this[kMaxWeightPerServer]; + } + if (pool[kWeight] >= this[kCurrentWeight] && !pool[kNeedDrain]) return pool; + } + this[kCurrentWeight] = this[kClients][maxWeightIndex][kWeight]; + this[kIndex] = maxWeightIndex; + return this[kClients][maxWeightIndex]; + } + }; + module.exports = BalancedPool; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/dispatcher/agent.js +var require_agent = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { InvalidArgumentError } = require_errors(); + const { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols$4(); + const DispatcherBase = require_dispatcher_base(); + const Pool = require_pool(); + const Client = require_client(); + const util = require_util$7(); + const createRedirectInterceptor = require_redirect_interceptor(); + const kOnConnect = Symbol("onConnect"); + const kOnDisconnect = Symbol("onDisconnect"); + const kOnConnectionError = Symbol("onConnectionError"); + const kMaxRedirections = Symbol("maxRedirections"); + const kOnDrain = Symbol("onDrain"); + const kFactory = Symbol("factory"); + const kOptions = Symbol("options"); + function defaultFactory(origin, opts) { + return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts); + } + var Agent = class extends DispatcherBase { + constructor({ factory = defaultFactory, maxRedirections = 0, connect, ...options } = {}) { + super(); + if (typeof factory !== "function") throw new InvalidArgumentError("factory must be a function."); + if (connect != null && typeof connect !== "function" && typeof connect !== "object") throw new InvalidArgumentError("connect must be a function or an object"); + if (!Number.isInteger(maxRedirections) || maxRedirections < 0) throw new InvalidArgumentError("maxRedirections must be a positive number"); + if (connect && typeof connect !== "function") connect = { ...connect }; + this[kInterceptors] = options.interceptors?.Agent && Array.isArray(options.interceptors.Agent) ? options.interceptors.Agent : [createRedirectInterceptor({ maxRedirections })]; + this[kOptions] = { + ...util.deepClone(options), + connect + }; + this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0; + this[kMaxRedirections] = maxRedirections; + this[kFactory] = factory; + this[kClients] = /* @__PURE__ */ new Map(); + this[kOnDrain] = (origin, targets) => { + this.emit("drain", origin, [this, ...targets]); + }; + this[kOnConnect] = (origin, targets) => { + this.emit("connect", origin, [this, ...targets]); + }; + this[kOnDisconnect] = (origin, targets, err) => { + this.emit("disconnect", origin, [this, ...targets], err); + }; + this[kOnConnectionError] = (origin, targets, err) => { + this.emit("connectionError", origin, [this, ...targets], err); + }; + } + get [kRunning]() { + let ret = 0; + for (const client of this[kClients].values()) ret += client[kRunning]; + return ret; + } + [kDispatch](opts, handler) { + let key; + if (opts.origin && (typeof opts.origin === "string" || opts.origin instanceof URL)) key = String(opts.origin); + else throw new InvalidArgumentError("opts.origin must be a non-empty string or URL."); + let dispatcher = this[kClients].get(key); + if (!dispatcher) { + dispatcher = this[kFactory](opts.origin, this[kOptions]).on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]); + this[kClients].set(key, dispatcher); + } + return dispatcher.dispatch(opts, handler); + } + async [kClose]() { + const closePromises = []; + for (const client of this[kClients].values()) closePromises.push(client.close()); + this[kClients].clear(); + await Promise.all(closePromises); + } + async [kDestroy](err) { + const destroyPromises = []; + for (const client of this[kClients].values()) destroyPromises.push(client.destroy(err)); + this[kClients].clear(); + await Promise.all(destroyPromises); + } + }; + module.exports = Agent; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/dispatcher/proxy-agent.js +var require_proxy_agent = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { kProxy, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols$4(); + const { URL: URL$1 } = __require("node:url"); + const Agent = require_agent(); + const Pool = require_pool(); + const DispatcherBase = require_dispatcher_base(); + const { InvalidArgumentError, RequestAbortedError, SecureProxyConnectionError } = require_errors(); + const buildConnector = require_connect(); + const Client = require_client(); + const kAgent = Symbol("proxy agent"); + const kClient = Symbol("proxy client"); + const kProxyHeaders = Symbol("proxy headers"); + const kRequestTls = Symbol("request tls settings"); + const kProxyTls = Symbol("proxy tls settings"); + const kConnectEndpoint = Symbol("connect endpoint function"); + const kTunnelProxy = Symbol("tunnel proxy"); + function defaultProtocolPort(protocol) { + return protocol === "https:" ? 443 : 80; + } + function defaultFactory(origin, opts) { + return new Pool(origin, opts); + } + const noop = () => {}; + function defaultAgentFactory(origin, opts) { + if (opts.connections === 1) return new Client(origin, opts); + return new Pool(origin, opts); + } + var Http1ProxyWrapper = class extends DispatcherBase { + #client; + constructor(proxyUrl, { headers = {}, connect, factory }) { + super(); + if (!proxyUrl) throw new InvalidArgumentError("Proxy URL is mandatory"); + this[kProxyHeaders] = headers; + if (factory) this.#client = factory(proxyUrl, { connect }); + else this.#client = new Client(proxyUrl, { connect }); + } + [kDispatch](opts, handler) { + const onHeaders = handler.onHeaders; + handler.onHeaders = function(statusCode, data, resume) { + if (statusCode === 407) { + if (typeof handler.onError === "function") handler.onError(new InvalidArgumentError("Proxy Authentication Required (407)")); + return; + } + if (onHeaders) onHeaders.call(this, statusCode, data, resume); + }; + const { origin, path = "/", headers = {} } = opts; + opts.path = origin + path; + if (!("host" in headers) && !("Host" in headers)) { + const { host } = new URL$1(origin); + headers.host = host; + } + opts.headers = { + ...this[kProxyHeaders], + ...headers + }; + return this.#client[kDispatch](opts, handler); + } + async [kClose]() { + return this.#client.close(); + } + async [kDestroy](err) { + return this.#client.destroy(err); + } + }; + var ProxyAgent = class extends DispatcherBase { + constructor(opts) { + super(); + if (!opts || typeof opts === "object" && !(opts instanceof URL$1) && !opts.uri) throw new InvalidArgumentError("Proxy uri is mandatory"); + const { clientFactory = defaultFactory } = opts; + if (typeof clientFactory !== "function") throw new InvalidArgumentError("Proxy opts.clientFactory must be a function."); + const { proxyTunnel = true } = opts; + const url = this.#getUrl(opts); + const { href, origin, port, protocol, username, password, hostname: proxyHostname } = url; + this[kProxy] = { + uri: href, + protocol + }; + this[kInterceptors] = opts.interceptors?.ProxyAgent && Array.isArray(opts.interceptors.ProxyAgent) ? opts.interceptors.ProxyAgent : []; + this[kRequestTls] = opts.requestTls; + this[kProxyTls] = opts.proxyTls; + this[kProxyHeaders] = opts.headers || {}; + this[kTunnelProxy] = proxyTunnel; + if (opts.auth && opts.token) throw new InvalidArgumentError("opts.auth cannot be used in combination with opts.token"); + else if (opts.auth) this[kProxyHeaders]["proxy-authorization"] = `Basic ${opts.auth}`; + else if (opts.token) this[kProxyHeaders]["proxy-authorization"] = opts.token; + else if (username && password) this[kProxyHeaders]["proxy-authorization"] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString("base64")}`; + const connect = buildConnector({ ...opts.proxyTls }); + this[kConnectEndpoint] = buildConnector({ ...opts.requestTls }); + const agentFactory = opts.factory || defaultAgentFactory; + const factory = (origin, options) => { + const { protocol } = new URL$1(origin); + if (!this[kTunnelProxy] && protocol === "http:" && this[kProxy].protocol === "http:") return new Http1ProxyWrapper(this[kProxy].uri, { + headers: this[kProxyHeaders], + connect, + factory: agentFactory + }); + return agentFactory(origin, options); + }; + this[kClient] = clientFactory(url, { connect }); + this[kAgent] = new Agent({ + ...opts, + factory, + connect: async (opts, callback) => { + let requestedPath = opts.host; + if (!opts.port) requestedPath += `:${defaultProtocolPort(opts.protocol)}`; + try { + const { socket, statusCode } = await this[kClient].connect({ + origin, + port, + path: requestedPath, + signal: opts.signal, + headers: { + ...this[kProxyHeaders], + host: opts.host + }, + servername: this[kProxyTls]?.servername || proxyHostname + }); + if (statusCode !== 200) { + socket.on("error", noop).destroy(); + callback(new RequestAbortedError(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`)); + } + if (opts.protocol !== "https:") { + callback(null, socket); + return; + } + let servername; + if (this[kRequestTls]) servername = this[kRequestTls].servername; + else servername = opts.servername; + this[kConnectEndpoint]({ + ...opts, + servername, + httpSocket: socket + }, callback); + } catch (err) { + if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") callback(new SecureProxyConnectionError(err)); + else callback(err); + } + } + }); + } + dispatch(opts, handler) { + const headers = buildHeaders(opts.headers); + throwIfProxyAuthIsSent(headers); + if (headers && !("host" in headers) && !("Host" in headers)) { + const { host } = new URL$1(opts.origin); + headers.host = host; + } + return this[kAgent].dispatch({ + ...opts, + headers + }, handler); + } + /** + * @param {import('../types/proxy-agent').ProxyAgent.Options | string | URL} opts + * @returns {URL} + */ + #getUrl(opts) { + if (typeof opts === "string") return new URL$1(opts); + else if (opts instanceof URL$1) return opts; + else return new URL$1(opts.uri); + } + async [kClose]() { + await this[kAgent].close(); + await this[kClient].close(); + } + async [kDestroy]() { + await this[kAgent].destroy(); + await this[kClient].destroy(); + } + }; + /** + * @param {string[] | Record} headers + * @returns {Record} + */ + function buildHeaders(headers) { + if (Array.isArray(headers)) { + /** @type {Record} */ + const headersPair = {}; + for (let i = 0; i < headers.length; i += 2) headersPair[headers[i]] = headers[i + 1]; + return headersPair; + } + return headers; + } + /** + * @param {Record} headers + * + * Previous versions of ProxyAgent suggests the Proxy-Authorization in request headers + * Nevertheless, it was changed and to avoid a security vulnerability by end users + * this check was created. + * It should be removed in the next major version for performance reasons + */ + function throwIfProxyAuthIsSent(headers) { + if (headers && Object.keys(headers).find((key) => key.toLowerCase() === "proxy-authorization")) throw new InvalidArgumentError("Proxy-Authorization should be sent in ProxyAgent constructor"); + } + module.exports = ProxyAgent; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/dispatcher/env-http-proxy-agent.js +var require_env_http_proxy_agent = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const DispatcherBase = require_dispatcher_base(); + const { kClose, kDestroy, kClosed, kDestroyed, kDispatch, kNoProxyAgent, kHttpProxyAgent, kHttpsProxyAgent } = require_symbols$4(); + const ProxyAgent = require_proxy_agent(); + const Agent = require_agent(); + const DEFAULT_PORTS = { + "http:": 80, + "https:": 443 + }; + let experimentalWarned = false; + var EnvHttpProxyAgent = class extends DispatcherBase { + #noProxyValue = null; + #noProxyEntries = null; + #opts = null; + constructor(opts = {}) { + super(); + this.#opts = opts; + if (!experimentalWarned) { + experimentalWarned = true; + process.emitWarning("EnvHttpProxyAgent is experimental, expect them to change at any time.", { code: "UNDICI-EHPA" }); + } + const { httpProxy, httpsProxy, noProxy, ...agentOpts } = opts; + this[kNoProxyAgent] = new Agent(agentOpts); + const HTTP_PROXY = httpProxy ?? process.env.http_proxy ?? process.env.HTTP_PROXY; + if (HTTP_PROXY) this[kHttpProxyAgent] = new ProxyAgent({ + ...agentOpts, + uri: HTTP_PROXY + }); + else this[kHttpProxyAgent] = this[kNoProxyAgent]; + const HTTPS_PROXY = httpsProxy ?? process.env.https_proxy ?? process.env.HTTPS_PROXY; + if (HTTPS_PROXY) this[kHttpsProxyAgent] = new ProxyAgent({ + ...agentOpts, + uri: HTTPS_PROXY + }); + else this[kHttpsProxyAgent] = this[kHttpProxyAgent]; + this.#parseNoProxy(); + } + [kDispatch](opts, handler) { + const url = new URL(opts.origin); + return this.#getProxyAgentForUrl(url).dispatch(opts, handler); + } + async [kClose]() { + await this[kNoProxyAgent].close(); + if (!this[kHttpProxyAgent][kClosed]) await this[kHttpProxyAgent].close(); + if (!this[kHttpsProxyAgent][kClosed]) await this[kHttpsProxyAgent].close(); + } + async [kDestroy](err) { + await this[kNoProxyAgent].destroy(err); + if (!this[kHttpProxyAgent][kDestroyed]) await this[kHttpProxyAgent].destroy(err); + if (!this[kHttpsProxyAgent][kDestroyed]) await this[kHttpsProxyAgent].destroy(err); + } + #getProxyAgentForUrl(url) { + let { protocol, host: hostname, port } = url; + hostname = hostname.replace(/:\d*$/, "").toLowerCase(); + port = Number.parseInt(port, 10) || DEFAULT_PORTS[protocol] || 0; + if (!this.#shouldProxy(hostname, port)) return this[kNoProxyAgent]; + if (protocol === "https:") return this[kHttpsProxyAgent]; + return this[kHttpProxyAgent]; + } + #shouldProxy(hostname, port) { + if (this.#noProxyChanged) this.#parseNoProxy(); + if (this.#noProxyEntries.length === 0) return true; + if (this.#noProxyValue === "*") return false; + for (let i = 0; i < this.#noProxyEntries.length; i++) { + const entry = this.#noProxyEntries[i]; + if (entry.port && entry.port !== port) continue; + if (!/^[.*]/.test(entry.hostname)) { + if (hostname === entry.hostname) return false; + } else if (hostname.endsWith(entry.hostname.replace(/^\*/, ""))) return false; + } + return true; + } + #parseNoProxy() { + const noProxyValue = this.#opts.noProxy ?? this.#noProxyEnv; + const noProxySplit = noProxyValue.split(/[,\s]/); + const noProxyEntries = []; + for (let i = 0; i < noProxySplit.length; i++) { + const entry = noProxySplit[i]; + if (!entry) continue; + const parsed = entry.match(/^(.+):(\d+)$/); + noProxyEntries.push({ + hostname: (parsed ? parsed[1] : entry).toLowerCase(), + port: parsed ? Number.parseInt(parsed[2], 10) : 0 + }); + } + this.#noProxyValue = noProxyValue; + this.#noProxyEntries = noProxyEntries; + } + get #noProxyChanged() { + if (this.#opts.noProxy !== void 0) return false; + return this.#noProxyValue !== this.#noProxyEnv; + } + get #noProxyEnv() { + return process.env.no_proxy ?? process.env.NO_PROXY ?? ""; + } + }; + module.exports = EnvHttpProxyAgent; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/handler/retry-handler.js +var require_retry_handler = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const assert$15 = __require("node:assert"); + const { kRetryHandlerDefaultRetry } = require_symbols$4(); + const { RequestRetryError } = require_errors(); + const { isDisturbed, parseHeaders, parseRangeHeader, wrapRequestBody } = require_util$7(); + function calculateRetryAfterHeader(retryAfter) { + const current = Date.now(); + return new Date(retryAfter).getTime() - current; + } + module.exports = class RetryHandler { + constructor(opts, handlers) { + const { retryOptions, ...dispatchOpts } = opts; + const { retry: retryFn, maxRetries, maxTimeout, minTimeout, timeoutFactor, methods, errorCodes, retryAfter, statusCodes } = retryOptions ?? {}; + this.dispatch = handlers.dispatch; + this.handler = handlers.handler; + this.opts = { + ...dispatchOpts, + body: wrapRequestBody(opts.body) + }; + this.abort = null; + this.aborted = false; + this.retryOpts = { + retry: retryFn ?? RetryHandler[kRetryHandlerDefaultRetry], + retryAfter: retryAfter ?? true, + maxTimeout: maxTimeout ?? 3e4, + minTimeout: minTimeout ?? 500, + timeoutFactor: timeoutFactor ?? 2, + maxRetries: maxRetries ?? 5, + methods: methods ?? [ + "GET", + "HEAD", + "OPTIONS", + "PUT", + "DELETE", + "TRACE" + ], + statusCodes: statusCodes ?? [ + 500, + 502, + 503, + 504, + 429 + ], + errorCodes: errorCodes ?? [ + "ECONNRESET", + "ECONNREFUSED", + "ENOTFOUND", + "ENETDOWN", + "ENETUNREACH", + "EHOSTDOWN", + "EHOSTUNREACH", + "EPIPE", + "UND_ERR_SOCKET" + ] + }; + this.retryCount = 0; + this.retryCountCheckpoint = 0; + this.start = 0; + this.end = null; + this.etag = null; + this.resume = null; + this.handler.onConnect((reason) => { + this.aborted = true; + if (this.abort) this.abort(reason); + else this.reason = reason; + }); + } + onRequestSent() { + if (this.handler.onRequestSent) this.handler.onRequestSent(); + } + onUpgrade(statusCode, headers, socket) { + if (this.handler.onUpgrade) this.handler.onUpgrade(statusCode, headers, socket); + } + onConnect(abort) { + if (this.aborted) abort(this.reason); + else this.abort = abort; + } + onBodySent(chunk) { + if (this.handler.onBodySent) return this.handler.onBodySent(chunk); + } + static [kRetryHandlerDefaultRetry](err, { state, opts }, cb) { + const { statusCode, code, headers } = err; + const { method, retryOptions } = opts; + const { maxRetries, minTimeout, maxTimeout, timeoutFactor, statusCodes, errorCodes, methods } = retryOptions; + const { counter } = state; + if (code && code !== "UND_ERR_REQ_RETRY" && !errorCodes.includes(code)) { + cb(err); + return; + } + if (Array.isArray(methods) && !methods.includes(method)) { + cb(err); + return; + } + if (statusCode != null && Array.isArray(statusCodes) && !statusCodes.includes(statusCode)) { + cb(err); + return; + } + if (counter > maxRetries) { + cb(err); + return; + } + let retryAfterHeader = headers?.["retry-after"]; + if (retryAfterHeader) { + retryAfterHeader = Number(retryAfterHeader); + retryAfterHeader = Number.isNaN(retryAfterHeader) ? calculateRetryAfterHeader(retryAfterHeader) : retryAfterHeader * 1e3; + } + const retryTimeout = retryAfterHeader > 0 ? Math.min(retryAfterHeader, maxTimeout) : Math.min(minTimeout * timeoutFactor ** (counter - 1), maxTimeout); + setTimeout(() => cb(null), retryTimeout); + } + onHeaders(statusCode, rawHeaders, resume, statusMessage) { + const headers = parseHeaders(rawHeaders); + this.retryCount += 1; + if (statusCode >= 300) { + if (this.retryOpts.statusCodes.includes(statusCode) === false) return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage); + else { + this.abort(new RequestRetryError("Request failed", statusCode, { + headers, + data: { count: this.retryCount } + })); + return false; + } + } + if (this.resume != null) { + this.resume = null; + if (statusCode !== 206 && (this.start > 0 || statusCode !== 200)) { + this.abort(new RequestRetryError("server does not support the range header and the payload was partially consumed", statusCode, { + headers, + data: { count: this.retryCount } + })); + return false; + } + const contentRange = parseRangeHeader(headers["content-range"]); + if (!contentRange) { + this.abort(new RequestRetryError("Content-Range mismatch", statusCode, { + headers, + data: { count: this.retryCount } + })); + return false; + } + if (this.etag != null && this.etag !== headers.etag) { + this.abort(new RequestRetryError("ETag mismatch", statusCode, { + headers, + data: { count: this.retryCount } + })); + return false; + } + const { start, size, end = size - 1 } = contentRange; + assert$15(this.start === start, "content-range mismatch"); + assert$15(this.end == null || this.end === end, "content-range mismatch"); + this.resume = resume; + return true; + } + if (this.end == null) { + if (statusCode === 206) { + const range = parseRangeHeader(headers["content-range"]); + if (range == null) return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage); + const { start, size, end = size - 1 } = range; + assert$15(start != null && Number.isFinite(start), "content-range mismatch"); + assert$15(end != null && Number.isFinite(end), "invalid content-length"); + this.start = start; + this.end = end; + } + if (this.end == null) { + const contentLength = headers["content-length"]; + this.end = contentLength != null ? Number(contentLength) - 1 : null; + } + assert$15(Number.isFinite(this.start)); + assert$15(this.end == null || Number.isFinite(this.end), "invalid content-length"); + this.resume = resume; + this.etag = headers.etag != null ? headers.etag : null; + if (this.etag != null && this.etag.startsWith("W/")) this.etag = null; + return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage); + } + const err = new RequestRetryError("Request failed", statusCode, { + headers, + data: { count: this.retryCount } + }); + this.abort(err); + return false; + } + onData(chunk) { + this.start += chunk.length; + return this.handler.onData(chunk); + } + onComplete(rawTrailers) { + this.retryCount = 0; + return this.handler.onComplete(rawTrailers); + } + onError(err) { + if (this.aborted || isDisturbed(this.opts.body)) return this.handler.onError(err); + if (this.retryCount - this.retryCountCheckpoint > 0) this.retryCount = this.retryCountCheckpoint + (this.retryCount - this.retryCountCheckpoint); + else this.retryCount += 1; + this.retryOpts.retry(err, { + state: { counter: this.retryCount }, + opts: { + retryOptions: this.retryOpts, + ...this.opts + } + }, onRetry.bind(this)); + function onRetry(err) { + if (err != null || this.aborted || isDisturbed(this.opts.body)) return this.handler.onError(err); + if (this.start !== 0) { + const headers = { range: `bytes=${this.start}-${this.end ?? ""}` }; + if (this.etag != null) headers["if-match"] = this.etag; + this.opts = { + ...this.opts, + headers: { + ...this.opts.headers, + ...headers + } + }; + } + try { + this.retryCountCheckpoint = this.retryCount; + this.dispatch(this.opts, this); + } catch (err) { + this.handler.onError(err); + } + } + } + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/dispatcher/retry-agent.js +var require_retry_agent = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const Dispatcher = require_dispatcher(); + const RetryHandler = require_retry_handler(); + var RetryAgent = class extends Dispatcher { + #agent = null; + #options = null; + constructor(agent, options = {}) { + super(options); + this.#agent = agent; + this.#options = options; + } + dispatch(opts, handler) { + const retry = new RetryHandler({ + ...opts, + retryOptions: this.#options + }, { + dispatch: this.#agent.dispatch.bind(this.#agent), + handler + }); + return this.#agent.dispatch(opts, retry); + } + close() { + return this.#agent.close(); + } + destroy() { + return this.#agent.destroy(); + } + }; + module.exports = RetryAgent; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/api/readable.js +var require_readable = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const assert$14 = __require("node:assert"); + const { Readable: Readable$2 } = __require("node:stream"); + const { RequestAbortedError, NotSupportedError, InvalidArgumentError, AbortError } = require_errors(); + const util = require_util$7(); + const { ReadableStreamFrom } = require_util$7(); + const kConsume = Symbol("kConsume"); + const kReading = Symbol("kReading"); + const kBody = Symbol("kBody"); + const kAbort = Symbol("kAbort"); + const kContentType = Symbol("kContentType"); + const kContentLength = Symbol("kContentLength"); + const noop = () => {}; + var BodyReadable = class extends Readable$2 { + constructor({ resume, abort, contentType = "", contentLength, highWaterMark = 65536 }) { + super({ + autoDestroy: true, + read: resume, + highWaterMark + }); + this._readableState.dataEmitted = false; + this[kAbort] = abort; + this[kConsume] = null; + this[kBody] = null; + this[kContentType] = contentType; + this[kContentLength] = contentLength; + this[kReading] = false; + } + destroy(err) { + if (!err && !this._readableState.endEmitted) err = new RequestAbortedError(); + if (err) this[kAbort](); + return super.destroy(err); + } + _destroy(err, callback) { + if (!this[kReading]) setImmediate(() => { + callback(err); + }); + else callback(err); + } + on(ev, ...args) { + if (ev === "data" || ev === "readable") this[kReading] = true; + return super.on(ev, ...args); + } + addListener(ev, ...args) { + return this.on(ev, ...args); + } + off(ev, ...args) { + const ret = super.off(ev, ...args); + if (ev === "data" || ev === "readable") this[kReading] = this.listenerCount("data") > 0 || this.listenerCount("readable") > 0; + return ret; + } + removeListener(ev, ...args) { + return this.off(ev, ...args); + } + push(chunk) { + if (this[kConsume] && chunk !== null) { + consumePush(this[kConsume], chunk); + return this[kReading] ? super.push(chunk) : true; + } + return super.push(chunk); + } + async text() { + return consume(this, "text"); + } + async json() { + return consume(this, "json"); + } + async blob() { + return consume(this, "blob"); + } + async bytes() { + return consume(this, "bytes"); + } + async arrayBuffer() { + return consume(this, "arrayBuffer"); + } + async formData() { + throw new NotSupportedError(); + } + get bodyUsed() { + return util.isDisturbed(this); + } + get body() { + if (!this[kBody]) { + this[kBody] = ReadableStreamFrom(this); + if (this[kConsume]) { + this[kBody].getReader(); + assert$14(this[kBody].locked); + } + } + return this[kBody]; + } + async dump(opts) { + let limit = Number.isFinite(opts?.limit) ? opts.limit : 131072; + const signal = opts?.signal; + if (signal != null && (typeof signal !== "object" || !("aborted" in signal))) throw new InvalidArgumentError("signal must be an AbortSignal"); + signal?.throwIfAborted(); + if (this._readableState.closeEmitted) return null; + return await new Promise((resolve, reject) => { + if (this[kContentLength] > limit) this.destroy(new AbortError()); + const onAbort = () => { + this.destroy(signal.reason ?? new AbortError()); + }; + signal?.addEventListener("abort", onAbort); + this.on("close", function() { + signal?.removeEventListener("abort", onAbort); + if (signal?.aborted) reject(signal.reason ?? new AbortError()); + else resolve(null); + }).on("error", noop).on("data", function(chunk) { + limit -= chunk.length; + if (limit <= 0) this.destroy(); + }).resume(); + }); + } + }; + function isLocked(self) { + return self[kBody] && self[kBody].locked === true || self[kConsume]; + } + function isUnusable(self) { + return util.isDisturbed(self) || isLocked(self); + } + async function consume(stream, type) { + assert$14(!stream[kConsume]); + return new Promise((resolve, reject) => { + if (isUnusable(stream)) { + const rState = stream._readableState; + if (rState.destroyed && rState.closeEmitted === false) stream.on("error", (err) => { + reject(err); + }).on("close", () => { + reject(/* @__PURE__ */ new TypeError("unusable")); + }); + else reject(rState.errored ?? /* @__PURE__ */ new TypeError("unusable")); + } else queueMicrotask(() => { + stream[kConsume] = { + type, + stream, + resolve, + reject, + length: 0, + body: [] + }; + stream.on("error", function(err) { + consumeFinish(this[kConsume], err); + }).on("close", function() { + if (this[kConsume].body !== null) consumeFinish(this[kConsume], new RequestAbortedError()); + }); + consumeStart(stream[kConsume]); + }); + }); + } + function consumeStart(consume) { + if (consume.body === null) return; + const { _readableState: state } = consume.stream; + if (state.bufferIndex) { + const start = state.bufferIndex; + const end = state.buffer.length; + for (let n = start; n < end; n++) consumePush(consume, state.buffer[n]); + } else for (const chunk of state.buffer) consumePush(consume, chunk); + if (state.endEmitted) consumeEnd(this[kConsume]); + else consume.stream.on("end", function() { + consumeEnd(this[kConsume]); + }); + consume.stream.resume(); + while (consume.stream.read() != null); + } + /** + * @param {Buffer[]} chunks + * @param {number} length + */ + function chunksDecode(chunks, length) { + if (chunks.length === 0 || length === 0) return ""; + const buffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, length); + const bufferLength = buffer.length; + const start = bufferLength > 2 && buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191 ? 3 : 0; + return buffer.utf8Slice(start, bufferLength); + } + /** + * @param {Buffer[]} chunks + * @param {number} length + * @returns {Uint8Array} + */ + function chunksConcat(chunks, length) { + if (chunks.length === 0 || length === 0) return /* @__PURE__ */ new Uint8Array(0); + if (chunks.length === 1) return new Uint8Array(chunks[0]); + const buffer = new Uint8Array(Buffer.allocUnsafeSlow(length).buffer); + let offset = 0; + for (let i = 0; i < chunks.length; ++i) { + const chunk = chunks[i]; + buffer.set(chunk, offset); + offset += chunk.length; + } + return buffer; + } + function consumeEnd(consume) { + const { type, body, resolve, stream, length } = consume; + try { + if (type === "text") resolve(chunksDecode(body, length)); + else if (type === "json") resolve(JSON.parse(chunksDecode(body, length))); + else if (type === "arrayBuffer") resolve(chunksConcat(body, length).buffer); + else if (type === "blob") resolve(new Blob(body, { type: stream[kContentType] })); + else if (type === "bytes") resolve(chunksConcat(body, length)); + consumeFinish(consume); + } catch (err) { + stream.destroy(err); + } + } + function consumePush(consume, chunk) { + consume.length += chunk.length; + consume.body.push(chunk); + } + function consumeFinish(consume, err) { + if (consume.body === null) return; + if (err) consume.reject(err); + else consume.resolve(); + consume.type = null; + consume.stream = null; + consume.resolve = null; + consume.reject = null; + consume.length = 0; + consume.body = null; + } + module.exports = { + Readable: BodyReadable, + chunksDecode + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/api/util.js +var require_util$5 = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const assert$13 = __require("node:assert"); + const { ResponseStatusCodeError } = require_errors(); + const { chunksDecode } = require_readable(); + const CHUNK_LIMIT = 131072; + async function getResolveErrorBodyCallback({ callback, body, contentType, statusCode, statusMessage, headers }) { + assert$13(body); + let chunks = []; + let length = 0; + try { + for await (const chunk of body) { + chunks.push(chunk); + length += chunk.length; + if (length > CHUNK_LIMIT) { + chunks = []; + length = 0; + break; + } + } + } catch { + chunks = []; + length = 0; + } + const message = `Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`; + if (statusCode === 204 || !contentType || !length) { + queueMicrotask(() => callback(new ResponseStatusCodeError(message, statusCode, headers))); + return; + } + const stackTraceLimit = Error.stackTraceLimit; + Error.stackTraceLimit = 0; + let payload; + try { + if (isContentTypeApplicationJson(contentType)) payload = JSON.parse(chunksDecode(chunks, length)); + else if (isContentTypeText(contentType)) payload = chunksDecode(chunks, length); + } catch {} finally { + Error.stackTraceLimit = stackTraceLimit; + } + queueMicrotask(() => callback(new ResponseStatusCodeError(message, statusCode, headers, payload))); + } + const isContentTypeApplicationJson = (contentType) => { + return contentType.length > 15 && contentType[11] === "/" && contentType[0] === "a" && contentType[1] === "p" && contentType[2] === "p" && contentType[3] === "l" && contentType[4] === "i" && contentType[5] === "c" && contentType[6] === "a" && contentType[7] === "t" && contentType[8] === "i" && contentType[9] === "o" && contentType[10] === "n" && contentType[12] === "j" && contentType[13] === "s" && contentType[14] === "o" && contentType[15] === "n"; + }; + const isContentTypeText = (contentType) => { + return contentType.length > 4 && contentType[4] === "/" && contentType[0] === "t" && contentType[1] === "e" && contentType[2] === "x" && contentType[3] === "t"; + }; + module.exports = { + getResolveErrorBodyCallback, + isContentTypeApplicationJson, + isContentTypeText + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/api/api-request.js +var require_api_request = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const assert$12 = __require("node:assert"); + const { Readable } = require_readable(); + const { InvalidArgumentError, RequestAbortedError } = require_errors(); + const util = require_util$7(); + const { getResolveErrorBodyCallback } = require_util$5(); + const { AsyncResource: AsyncResource$4 } = __require("node:async_hooks"); + var RequestHandler = class extends AsyncResource$4 { + constructor(opts, callback) { + if (!opts || typeof opts !== "object") throw new InvalidArgumentError("invalid opts"); + const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError, highWaterMark } = opts; + try { + if (typeof callback !== "function") throw new InvalidArgumentError("invalid callback"); + if (highWaterMark && (typeof highWaterMark !== "number" || highWaterMark < 0)) throw new InvalidArgumentError("invalid highWaterMark"); + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + if (method === "CONNECT") throw new InvalidArgumentError("invalid method"); + if (onInfo && typeof onInfo !== "function") throw new InvalidArgumentError("invalid onInfo callback"); + super("UNDICI_REQUEST"); + } catch (err) { + if (util.isStream(body)) util.destroy(body.on("error", util.nop), err); + throw err; + } + this.method = method; + this.responseHeaders = responseHeaders || null; + this.opaque = opaque || null; + this.callback = callback; + this.res = null; + this.abort = null; + this.body = body; + this.trailers = {}; + this.context = null; + this.onInfo = onInfo || null; + this.throwOnError = throwOnError; + this.highWaterMark = highWaterMark; + this.signal = signal; + this.reason = null; + this.removeAbortListener = null; + if (util.isStream(body)) body.on("error", (err) => { + this.onError(err); + }); + if (this.signal) { + if (this.signal.aborted) this.reason = this.signal.reason ?? new RequestAbortedError(); + else this.removeAbortListener = util.addAbortListener(this.signal, () => { + this.reason = this.signal.reason ?? new RequestAbortedError(); + if (this.res) util.destroy(this.res.on("error", util.nop), this.reason); + else if (this.abort) this.abort(this.reason); + if (this.removeAbortListener) { + this.res?.off("close", this.removeAbortListener); + this.removeAbortListener(); + this.removeAbortListener = null; + } + }); + } + } + onConnect(abort, context) { + if (this.reason) { + abort(this.reason); + return; + } + assert$12(this.callback); + this.abort = abort; + this.context = context; + } + onHeaders(statusCode, rawHeaders, resume, statusMessage) { + const { callback, opaque, abort, context, responseHeaders, highWaterMark } = this; + const headers = responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + if (statusCode < 200) { + if (this.onInfo) this.onInfo({ + statusCode, + headers + }); + return; + } + const parsedHeaders = responseHeaders === "raw" ? util.parseHeaders(rawHeaders) : headers; + const contentType = parsedHeaders["content-type"]; + const contentLength = parsedHeaders["content-length"]; + const res = new Readable({ + resume, + abort, + contentType, + contentLength: this.method !== "HEAD" && contentLength ? Number(contentLength) : null, + highWaterMark + }); + if (this.removeAbortListener) res.on("close", this.removeAbortListener); + this.callback = null; + this.res = res; + if (callback !== null) { + if (this.throwOnError && statusCode >= 400) this.runInAsyncScope(getResolveErrorBodyCallback, null, { + callback, + body: res, + contentType, + statusCode, + statusMessage, + headers + }); + else this.runInAsyncScope(callback, null, null, { + statusCode, + headers, + trailers: this.trailers, + opaque, + body: res, + context + }); + } + } + onData(chunk) { + return this.res.push(chunk); + } + onComplete(trailers) { + util.parseHeaders(trailers, this.trailers); + this.res.push(null); + } + onError(err) { + const { res, callback, body, opaque } = this; + if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + if (res) { + this.res = null; + queueMicrotask(() => { + util.destroy(res, err); + }); + } + if (body) { + this.body = null; + util.destroy(body, err); + } + if (this.removeAbortListener) { + res?.off("close", this.removeAbortListener); + this.removeAbortListener(); + this.removeAbortListener = null; + } + } + }; + function request(opts, callback) { + if (callback === void 0) return new Promise((resolve, reject) => { + request.call(this, opts, (err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + try { + this.dispatch(opts, new RequestHandler(opts, callback)); + } catch (err) { + if (typeof callback !== "function") throw err; + const opaque = opts?.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module.exports = request; + module.exports.RequestHandler = RequestHandler; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/api/abort-signal.js +var require_abort_signal = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { addAbortListener } = require_util$7(); + const { RequestAbortedError } = require_errors(); + const kListener = Symbol("kListener"); + const kSignal = Symbol("kSignal"); + function abort(self) { + if (self.abort) self.abort(self[kSignal]?.reason); + else self.reason = self[kSignal]?.reason ?? new RequestAbortedError(); + removeSignal(self); + } + function addSignal(self, signal) { + self.reason = null; + self[kSignal] = null; + self[kListener] = null; + if (!signal) return; + if (signal.aborted) { + abort(self); + return; + } + self[kSignal] = signal; + self[kListener] = () => { + abort(self); + }; + addAbortListener(self[kSignal], self[kListener]); + } + function removeSignal(self) { + if (!self[kSignal]) return; + if ("removeEventListener" in self[kSignal]) self[kSignal].removeEventListener("abort", self[kListener]); + else self[kSignal].removeListener("abort", self[kListener]); + self[kSignal] = null; + self[kListener] = null; + } + module.exports = { + addSignal, + removeSignal + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/api/api-stream.js +var require_api_stream = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const assert$11 = __require("node:assert"); + const { finished: finished$1, PassThrough: PassThrough$1 } = __require("node:stream"); + const { InvalidArgumentError, InvalidReturnValueError } = require_errors(); + const util = require_util$7(); + const { getResolveErrorBodyCallback } = require_util$5(); + const { AsyncResource: AsyncResource$3 } = __require("node:async_hooks"); + const { addSignal, removeSignal } = require_abort_signal(); + var StreamHandler = class extends AsyncResource$3 { + constructor(opts, factory, callback) { + if (!opts || typeof opts !== "object") throw new InvalidArgumentError("invalid opts"); + const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError } = opts; + try { + if (typeof callback !== "function") throw new InvalidArgumentError("invalid callback"); + if (typeof factory !== "function") throw new InvalidArgumentError("invalid factory"); + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + if (method === "CONNECT") throw new InvalidArgumentError("invalid method"); + if (onInfo && typeof onInfo !== "function") throw new InvalidArgumentError("invalid onInfo callback"); + super("UNDICI_STREAM"); + } catch (err) { + if (util.isStream(body)) util.destroy(body.on("error", util.nop), err); + throw err; + } + this.responseHeaders = responseHeaders || null; + this.opaque = opaque || null; + this.factory = factory; + this.callback = callback; + this.res = null; + this.abort = null; + this.context = null; + this.trailers = null; + this.body = body; + this.onInfo = onInfo || null; + this.throwOnError = throwOnError || false; + if (util.isStream(body)) body.on("error", (err) => { + this.onError(err); + }); + addSignal(this, signal); + } + onConnect(abort, context) { + if (this.reason) { + abort(this.reason); + return; + } + assert$11(this.callback); + this.abort = abort; + this.context = context; + } + onHeaders(statusCode, rawHeaders, resume, statusMessage) { + const { factory, opaque, context, callback, responseHeaders } = this; + const headers = responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + if (statusCode < 200) { + if (this.onInfo) this.onInfo({ + statusCode, + headers + }); + return; + } + this.factory = null; + let res; + if (this.throwOnError && statusCode >= 400) { + const contentType = (responseHeaders === "raw" ? util.parseHeaders(rawHeaders) : headers)["content-type"]; + res = new PassThrough$1(); + this.callback = null; + this.runInAsyncScope(getResolveErrorBodyCallback, null, { + callback, + body: res, + contentType, + statusCode, + statusMessage, + headers + }); + } else { + if (factory === null) return; + res = this.runInAsyncScope(factory, null, { + statusCode, + headers, + opaque, + context + }); + if (!res || typeof res.write !== "function" || typeof res.end !== "function" || typeof res.on !== "function") throw new InvalidReturnValueError("expected Writable"); + finished$1(res, { readable: false }, (err) => { + const { callback, res, opaque, trailers, abort } = this; + this.res = null; + if (err || !res.readable) util.destroy(res, err); + this.callback = null; + this.runInAsyncScope(callback, null, err || null, { + opaque, + trailers + }); + if (err) abort(); + }); + } + res.on("drain", resume); + this.res = res; + return (res.writableNeedDrain !== void 0 ? res.writableNeedDrain : res._writableState?.needDrain) !== true; + } + onData(chunk) { + const { res } = this; + return res ? res.write(chunk) : true; + } + onComplete(trailers) { + const { res } = this; + removeSignal(this); + if (!res) return; + this.trailers = util.parseHeaders(trailers); + res.end(); + } + onError(err) { + const { res, callback, opaque, body } = this; + removeSignal(this); + this.factory = null; + if (res) { + this.res = null; + util.destroy(res, err); + } else if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + if (body) { + this.body = null; + util.destroy(body, err); + } + } + }; + function stream(opts, factory, callback) { + if (callback === void 0) return new Promise((resolve, reject) => { + stream.call(this, opts, factory, (err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + try { + this.dispatch(opts, new StreamHandler(opts, factory, callback)); + } catch (err) { + if (typeof callback !== "function") throw err; + const opaque = opts?.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module.exports = stream; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/api/api-pipeline.js +var require_api_pipeline = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { Readable: Readable$1, Duplex, PassThrough } = __require("node:stream"); + const { InvalidArgumentError, InvalidReturnValueError, RequestAbortedError } = require_errors(); + const util = require_util$7(); + const { AsyncResource: AsyncResource$2 } = __require("node:async_hooks"); + const { addSignal, removeSignal } = require_abort_signal(); + const assert$10 = __require("node:assert"); + const kResume = Symbol("resume"); + var PipelineRequest = class extends Readable$1 { + constructor() { + super({ autoDestroy: true }); + this[kResume] = null; + } + _read() { + const { [kResume]: resume } = this; + if (resume) { + this[kResume] = null; + resume(); + } + } + _destroy(err, callback) { + this._read(); + callback(err); + } + }; + var PipelineResponse = class extends Readable$1 { + constructor(resume) { + super({ autoDestroy: true }); + this[kResume] = resume; + } + _read() { + this[kResume](); + } + _destroy(err, callback) { + if (!err && !this._readableState.endEmitted) err = new RequestAbortedError(); + callback(err); + } + }; + var PipelineHandler = class extends AsyncResource$2 { + constructor(opts, handler) { + if (!opts || typeof opts !== "object") throw new InvalidArgumentError("invalid opts"); + if (typeof handler !== "function") throw new InvalidArgumentError("invalid handler"); + const { signal, method, opaque, onInfo, responseHeaders } = opts; + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + if (method === "CONNECT") throw new InvalidArgumentError("invalid method"); + if (onInfo && typeof onInfo !== "function") throw new InvalidArgumentError("invalid onInfo callback"); + super("UNDICI_PIPELINE"); + this.opaque = opaque || null; + this.responseHeaders = responseHeaders || null; + this.handler = handler; + this.abort = null; + this.context = null; + this.onInfo = onInfo || null; + this.req = new PipelineRequest().on("error", util.nop); + this.ret = new Duplex({ + readableObjectMode: opts.objectMode, + autoDestroy: true, + read: () => { + const { body } = this; + if (body?.resume) body.resume(); + }, + write: (chunk, encoding, callback) => { + const { req } = this; + if (req.push(chunk, encoding) || req._readableState.destroyed) callback(); + else req[kResume] = callback; + }, + destroy: (err, callback) => { + const { body, req, res, ret, abort } = this; + if (!err && !ret._readableState.endEmitted) err = new RequestAbortedError(); + if (abort && err) abort(); + util.destroy(body, err); + util.destroy(req, err); + util.destroy(res, err); + removeSignal(this); + callback(err); + } + }).on("prefinish", () => { + const { req } = this; + req.push(null); + }); + this.res = null; + addSignal(this, signal); + } + onConnect(abort, context) { + const { ret, res } = this; + if (this.reason) { + abort(this.reason); + return; + } + assert$10(!res, "pipeline cannot be retried"); + assert$10(!ret.destroyed); + this.abort = abort; + this.context = context; + } + onHeaders(statusCode, rawHeaders, resume) { + const { opaque, handler, context } = this; + if (statusCode < 200) { + if (this.onInfo) { + const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + this.onInfo({ + statusCode, + headers + }); + } + return; + } + this.res = new PipelineResponse(resume); + let body; + try { + this.handler = null; + const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + body = this.runInAsyncScope(handler, null, { + statusCode, + headers, + opaque, + body: this.res, + context + }); + } catch (err) { + this.res.on("error", util.nop); + throw err; + } + if (!body || typeof body.on !== "function") throw new InvalidReturnValueError("expected Readable"); + body.on("data", (chunk) => { + const { ret, body } = this; + if (!ret.push(chunk) && body.pause) body.pause(); + }).on("error", (err) => { + const { ret } = this; + util.destroy(ret, err); + }).on("end", () => { + const { ret } = this; + ret.push(null); + }).on("close", () => { + const { ret } = this; + if (!ret._readableState.ended) util.destroy(ret, new RequestAbortedError()); + }); + this.body = body; + } + onData(chunk) { + const { res } = this; + return res.push(chunk); + } + onComplete(trailers) { + const { res } = this; + res.push(null); + } + onError(err) { + const { ret } = this; + this.handler = null; + util.destroy(ret, err); + } + }; + function pipeline(opts, handler) { + try { + const pipelineHandler = new PipelineHandler(opts, handler); + this.dispatch({ + ...opts, + body: pipelineHandler.req + }, pipelineHandler); + return pipelineHandler.ret; + } catch (err) { + return new PassThrough().destroy(err); + } + } + module.exports = pipeline; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/api/api-upgrade.js +var require_api_upgrade = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { InvalidArgumentError, SocketError } = require_errors(); + const { AsyncResource: AsyncResource$1 } = __require("node:async_hooks"); + const util = require_util$7(); + const { addSignal, removeSignal } = require_abort_signal(); + const assert$9 = __require("node:assert"); + var UpgradeHandler = class extends AsyncResource$1 { + constructor(opts, callback) { + if (!opts || typeof opts !== "object") throw new InvalidArgumentError("invalid opts"); + if (typeof callback !== "function") throw new InvalidArgumentError("invalid callback"); + const { signal, opaque, responseHeaders } = opts; + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + super("UNDICI_UPGRADE"); + this.responseHeaders = responseHeaders || null; + this.opaque = opaque || null; + this.callback = callback; + this.abort = null; + this.context = null; + addSignal(this, signal); + } + onConnect(abort, context) { + if (this.reason) { + abort(this.reason); + return; + } + assert$9(this.callback); + this.abort = abort; + this.context = null; + } + onHeaders() { + throw new SocketError("bad upgrade", null); + } + onUpgrade(statusCode, rawHeaders, socket) { + assert$9(statusCode === 101); + const { callback, opaque, context } = this; + removeSignal(this); + this.callback = null; + const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + this.runInAsyncScope(callback, null, null, { + headers, + socket, + opaque, + context + }); + } + onError(err) { + const { callback, opaque } = this; + removeSignal(this); + if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + } + }; + function upgrade(opts, callback) { + if (callback === void 0) return new Promise((resolve, reject) => { + upgrade.call(this, opts, (err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + try { + const upgradeHandler = new UpgradeHandler(opts, callback); + this.dispatch({ + ...opts, + method: opts.method || "GET", + upgrade: opts.protocol || "Websocket" + }, upgradeHandler); + } catch (err) { + if (typeof callback !== "function") throw err; + const opaque = opts?.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module.exports = upgrade; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/api/api-connect.js +var require_api_connect = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const assert$8 = __require("node:assert"); + const { AsyncResource } = __require("node:async_hooks"); + const { InvalidArgumentError, SocketError } = require_errors(); + const util = require_util$7(); + const { addSignal, removeSignal } = require_abort_signal(); + var ConnectHandler = class extends AsyncResource { + constructor(opts, callback) { + if (!opts || typeof opts !== "object") throw new InvalidArgumentError("invalid opts"); + if (typeof callback !== "function") throw new InvalidArgumentError("invalid callback"); + const { signal, opaque, responseHeaders } = opts; + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + super("UNDICI_CONNECT"); + this.opaque = opaque || null; + this.responseHeaders = responseHeaders || null; + this.callback = callback; + this.abort = null; + addSignal(this, signal); + } + onConnect(abort, context) { + if (this.reason) { + abort(this.reason); + return; + } + assert$8(this.callback); + this.abort = abort; + this.context = context; + } + onHeaders() { + throw new SocketError("bad connect", null); + } + onUpgrade(statusCode, rawHeaders, socket) { + const { callback, opaque, context } = this; + removeSignal(this); + this.callback = null; + let headers = rawHeaders; + if (headers != null) headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + this.runInAsyncScope(callback, null, null, { + statusCode, + headers, + socket, + opaque, + context + }); + } + onError(err) { + const { callback, opaque } = this; + removeSignal(this); + if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + } + }; + function connect(opts, callback) { + if (callback === void 0) return new Promise((resolve, reject) => { + connect.call(this, opts, (err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + try { + const connectHandler = new ConnectHandler(opts, callback); + this.dispatch({ + ...opts, + method: "CONNECT" + }, connectHandler); + } catch (err) { + if (typeof callback !== "function") throw err; + const opaque = opts?.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module.exports = connect; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/api/index.js +var require_api = /* @__PURE__ */ __commonJSMin(((exports, module) => { + module.exports.request = require_api_request(); + module.exports.stream = require_api_stream(); + module.exports.pipeline = require_api_pipeline(); + module.exports.upgrade = require_api_upgrade(); + module.exports.connect = require_api_connect(); +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/mock/mock-errors.js +var require_mock_errors = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { UndiciError } = require_errors(); + const kMockNotMatchedError = Symbol.for("undici.error.UND_MOCK_ERR_MOCK_NOT_MATCHED"); + module.exports = { MockNotMatchedError: class MockNotMatchedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, MockNotMatchedError); + this.name = "MockNotMatchedError"; + this.message = message || "The request does not match any registered mock dispatches"; + this.code = "UND_MOCK_ERR_MOCK_NOT_MATCHED"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kMockNotMatchedError] === true; + } + [kMockNotMatchedError] = true; + } }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/mock/mock-symbols.js +var require_mock_symbols = /* @__PURE__ */ __commonJSMin(((exports, module) => { + module.exports = { + kAgent: Symbol("agent"), + kOptions: Symbol("options"), + kFactory: Symbol("factory"), + kDispatches: Symbol("dispatches"), + kDispatchKey: Symbol("dispatch key"), + kDefaultHeaders: Symbol("default headers"), + kDefaultTrailers: Symbol("default trailers"), + kContentLength: Symbol("content length"), + kMockAgent: Symbol("mock agent"), + kMockAgentSet: Symbol("mock agent set"), + kMockAgentGet: Symbol("mock agent get"), + kMockDispatch: Symbol("mock dispatch"), + kClose: Symbol("close"), + kOriginalClose: Symbol("original agent close"), + kOrigin: Symbol("origin"), + kIsMockActive: Symbol("is mock active"), + kNetConnect: Symbol("net connect"), + kGetNetConnect: Symbol("get net connect"), + kConnected: Symbol("connected") + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/mock/mock-utils.js +var require_mock_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { MockNotMatchedError } = require_mock_errors(); + const { kDispatches, kMockAgent, kOriginalDispatch, kOrigin, kGetNetConnect } = require_mock_symbols(); + const { buildURL } = require_util$7(); + const { STATUS_CODES: STATUS_CODES$1 } = __require("node:http"); + const { types: { isPromise } } = __require("node:util"); + function matchValue(match, value) { + if (typeof match === "string") return match === value; + if (match instanceof RegExp) return match.test(value); + if (typeof match === "function") return match(value) === true; + return false; + } + function lowerCaseEntries(headers) { + return Object.fromEntries(Object.entries(headers).map(([headerName, headerValue]) => { + return [headerName.toLocaleLowerCase(), headerValue]; + })); + } + /** + * @param {import('../../index').Headers|string[]|Record} headers + * @param {string} key + */ + function getHeaderByName(headers, key) { + if (Array.isArray(headers)) { + for (let i = 0; i < headers.length; i += 2) if (headers[i].toLocaleLowerCase() === key.toLocaleLowerCase()) return headers[i + 1]; + return; + } else if (typeof headers.get === "function") return headers.get(key); + else return lowerCaseEntries(headers)[key.toLocaleLowerCase()]; + } + /** @param {string[]} headers */ + function buildHeadersFromArray(headers) { + const clone = headers.slice(); + const entries = []; + for (let index = 0; index < clone.length; index += 2) entries.push([clone[index], clone[index + 1]]); + return Object.fromEntries(entries); + } + function matchHeaders(mockDispatch, headers) { + if (typeof mockDispatch.headers === "function") { + if (Array.isArray(headers)) headers = buildHeadersFromArray(headers); + return mockDispatch.headers(headers ? lowerCaseEntries(headers) : {}); + } + if (typeof mockDispatch.headers === "undefined") return true; + if (typeof headers !== "object" || typeof mockDispatch.headers !== "object") return false; + for (const [matchHeaderName, matchHeaderValue] of Object.entries(mockDispatch.headers)) if (!matchValue(matchHeaderValue, getHeaderByName(headers, matchHeaderName))) return false; + return true; + } + function safeUrl(path) { + if (typeof path !== "string") return path; + const pathSegments = path.split("?"); + if (pathSegments.length !== 2) return path; + const qp = new URLSearchParams(pathSegments.pop()); + qp.sort(); + return [...pathSegments, qp.toString()].join("?"); + } + function matchKey(mockDispatch, { path, method, body, headers }) { + const pathMatch = matchValue(mockDispatch.path, path); + const methodMatch = matchValue(mockDispatch.method, method); + const bodyMatch = typeof mockDispatch.body !== "undefined" ? matchValue(mockDispatch.body, body) : true; + const headersMatch = matchHeaders(mockDispatch, headers); + return pathMatch && methodMatch && bodyMatch && headersMatch; + } + function getResponseData(data) { + if (Buffer.isBuffer(data)) return data; + else if (data instanceof Uint8Array) return data; + else if (data instanceof ArrayBuffer) return data; + else if (typeof data === "object") return JSON.stringify(data); + else return data.toString(); + } + function getMockDispatch(mockDispatches, key) { + const basePath = key.query ? buildURL(key.path, key.query) : key.path; + const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath; + let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path }) => matchValue(safeUrl(path), resolvedPath)); + if (matchedMockDispatches.length === 0) throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`); + matchedMockDispatches = matchedMockDispatches.filter(({ method }) => matchValue(method, key.method)); + if (matchedMockDispatches.length === 0) throw new MockNotMatchedError(`Mock dispatch not matched for method '${key.method}' on path '${resolvedPath}'`); + matchedMockDispatches = matchedMockDispatches.filter(({ body }) => typeof body !== "undefined" ? matchValue(body, key.body) : true); + if (matchedMockDispatches.length === 0) throw new MockNotMatchedError(`Mock dispatch not matched for body '${key.body}' on path '${resolvedPath}'`); + matchedMockDispatches = matchedMockDispatches.filter((mockDispatch) => matchHeaders(mockDispatch, key.headers)); + if (matchedMockDispatches.length === 0) { + const headers = typeof key.headers === "object" ? JSON.stringify(key.headers) : key.headers; + throw new MockNotMatchedError(`Mock dispatch not matched for headers '${headers}' on path '${resolvedPath}'`); + } + return matchedMockDispatches[0]; + } + function addMockDispatch(mockDispatches, key, data) { + const baseData = { + timesInvoked: 0, + times: 1, + persist: false, + consumed: false + }; + const replyData = typeof data === "function" ? { callback: data } : { ...data }; + const newMockDispatch = { + ...baseData, + ...key, + pending: true, + data: { + error: null, + ...replyData + } + }; + mockDispatches.push(newMockDispatch); + return newMockDispatch; + } + function deleteMockDispatch(mockDispatches, key) { + const index = mockDispatches.findIndex((dispatch) => { + if (!dispatch.consumed) return false; + return matchKey(dispatch, key); + }); + if (index !== -1) mockDispatches.splice(index, 1); + } + function buildKey(opts) { + const { path, method, body, headers, query } = opts; + return { + path, + method, + body, + headers, + query + }; + } + function generateKeyValues(data) { + const keys = Object.keys(data); + const result = []; + for (let i = 0; i < keys.length; ++i) { + const key = keys[i]; + const value = data[key]; + const name = Buffer.from(`${key}`); + if (Array.isArray(value)) for (let j = 0; j < value.length; ++j) result.push(name, Buffer.from(`${value[j]}`)); + else result.push(name, Buffer.from(`${value}`)); + } + return result; + } + /** + * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Status + * @param {number} statusCode + */ + function getStatusText(statusCode) { + return STATUS_CODES$1[statusCode] || "unknown"; + } + async function getResponse(body) { + const buffers = []; + for await (const data of body) buffers.push(data); + return Buffer.concat(buffers).toString("utf8"); + } + /** + * Mock dispatch function used to simulate undici dispatches + */ + function mockDispatch(opts, handler) { + const key = buildKey(opts); + const mockDispatch = getMockDispatch(this[kDispatches], key); + mockDispatch.timesInvoked++; + if (mockDispatch.data.callback) mockDispatch.data = { + ...mockDispatch.data, + ...mockDispatch.data.callback(opts) + }; + const { data: { statusCode, data, headers, trailers, error }, delay, persist } = mockDispatch; + const { timesInvoked, times } = mockDispatch; + mockDispatch.consumed = !persist && timesInvoked >= times; + mockDispatch.pending = timesInvoked < times; + if (error !== null) { + deleteMockDispatch(this[kDispatches], key); + handler.onError(error); + return true; + } + if (typeof delay === "number" && delay > 0) setTimeout(() => { + handleReply(this[kDispatches]); + }, delay); + else handleReply(this[kDispatches]); + function handleReply(mockDispatches, _data = data) { + const optsHeaders = Array.isArray(opts.headers) ? buildHeadersFromArray(opts.headers) : opts.headers; + const body = typeof _data === "function" ? _data({ + ...opts, + headers: optsHeaders + }) : _data; + if (isPromise(body)) { + body.then((newData) => handleReply(mockDispatches, newData)); + return; + } + const responseData = getResponseData(body); + const responseHeaders = generateKeyValues(headers); + const responseTrailers = generateKeyValues(trailers); + handler.onConnect?.((err) => handler.onError(err), null); + handler.onHeaders?.(statusCode, responseHeaders, resume, getStatusText(statusCode)); + handler.onData?.(Buffer.from(responseData)); + handler.onComplete?.(responseTrailers); + deleteMockDispatch(mockDispatches, key); + } + function resume() {} + return true; + } + function buildMockDispatch() { + const agent = this[kMockAgent]; + const origin = this[kOrigin]; + const originalDispatch = this[kOriginalDispatch]; + return function dispatch(opts, handler) { + if (agent.isMockActive) try { + mockDispatch.call(this, opts, handler); + } catch (error) { + if (error instanceof MockNotMatchedError) { + const netConnect = agent[kGetNetConnect](); + if (netConnect === false) throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)`); + if (checkNetConnect(netConnect, origin)) originalDispatch.call(this, opts, handler); + else throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)`); + } else throw error; + } + else originalDispatch.call(this, opts, handler); + }; + } + function checkNetConnect(netConnect, origin) { + const url = new URL(origin); + if (netConnect === true) return true; + else if (Array.isArray(netConnect) && netConnect.some((matcher) => matchValue(matcher, url.host))) return true; + return false; + } + function buildMockOptions(opts) { + if (opts) { + const { agent, ...mockOptions } = opts; + return mockOptions; + } + } + module.exports = { + getResponseData, + getMockDispatch, + addMockDispatch, + deleteMockDispatch, + buildKey, + generateKeyValues, + matchValue, + getResponse, + getStatusText, + mockDispatch, + buildMockDispatch, + checkNetConnect, + buildMockOptions, + getHeaderByName, + buildHeadersFromArray + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/mock/mock-interceptor.js +var require_mock_interceptor = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { getResponseData, buildKey, addMockDispatch } = require_mock_utils(); + const { kDispatches, kDispatchKey, kDefaultHeaders, kDefaultTrailers, kContentLength, kMockDispatch } = require_mock_symbols(); + const { InvalidArgumentError } = require_errors(); + const { buildURL } = require_util$7(); + /** + * Defines the scope API for an interceptor reply + */ + var MockScope = class { + constructor(mockDispatch) { + this[kMockDispatch] = mockDispatch; + } + /** + * Delay a reply by a set amount in ms. + */ + delay(waitInMs) { + if (typeof waitInMs !== "number" || !Number.isInteger(waitInMs) || waitInMs <= 0) throw new InvalidArgumentError("waitInMs must be a valid integer > 0"); + this[kMockDispatch].delay = waitInMs; + return this; + } + /** + * For a defined reply, never mark as consumed. + */ + persist() { + this[kMockDispatch].persist = true; + return this; + } + /** + * Allow one to define a reply for a set amount of matching requests. + */ + times(repeatTimes) { + if (typeof repeatTimes !== "number" || !Number.isInteger(repeatTimes) || repeatTimes <= 0) throw new InvalidArgumentError("repeatTimes must be a valid integer > 0"); + this[kMockDispatch].times = repeatTimes; + return this; + } + }; + /** + * Defines an interceptor for a Mock + */ + var MockInterceptor = class { + constructor(opts, mockDispatches) { + if (typeof opts !== "object") throw new InvalidArgumentError("opts must be an object"); + if (typeof opts.path === "undefined") throw new InvalidArgumentError("opts.path must be defined"); + if (typeof opts.method === "undefined") opts.method = "GET"; + if (typeof opts.path === "string") { + if (opts.query) opts.path = buildURL(opts.path, opts.query); + else { + const parsedURL = new URL(opts.path, "data://"); + opts.path = parsedURL.pathname + parsedURL.search; + } + } + if (typeof opts.method === "string") opts.method = opts.method.toUpperCase(); + this[kDispatchKey] = buildKey(opts); + this[kDispatches] = mockDispatches; + this[kDefaultHeaders] = {}; + this[kDefaultTrailers] = {}; + this[kContentLength] = false; + } + createMockScopeDispatchData({ statusCode, data, responseOptions }) { + const responseData = getResponseData(data); + const contentLength = this[kContentLength] ? { "content-length": responseData.length } : {}; + return { + statusCode, + data, + headers: { + ...this[kDefaultHeaders], + ...contentLength, + ...responseOptions.headers + }, + trailers: { + ...this[kDefaultTrailers], + ...responseOptions.trailers + } + }; + } + validateReplyParameters(replyParameters) { + if (typeof replyParameters.statusCode === "undefined") throw new InvalidArgumentError("statusCode must be defined"); + if (typeof replyParameters.responseOptions !== "object" || replyParameters.responseOptions === null) throw new InvalidArgumentError("responseOptions must be an object"); + } + /** + * Mock an undici request with a defined reply. + */ + reply(replyOptionsCallbackOrStatusCode) { + if (typeof replyOptionsCallbackOrStatusCode === "function") { + const wrappedDefaultsCallback = (opts) => { + const resolvedData = replyOptionsCallbackOrStatusCode(opts); + if (typeof resolvedData !== "object" || resolvedData === null) throw new InvalidArgumentError("reply options callback must return an object"); + const replyParameters = { + data: "", + responseOptions: {}, + ...resolvedData + }; + this.validateReplyParameters(replyParameters); + return { ...this.createMockScopeDispatchData(replyParameters) }; + }; + return new MockScope(addMockDispatch(this[kDispatches], this[kDispatchKey], wrappedDefaultsCallback)); + } + const replyParameters = { + statusCode: replyOptionsCallbackOrStatusCode, + data: arguments[1] === void 0 ? "" : arguments[1], + responseOptions: arguments[2] === void 0 ? {} : arguments[2] + }; + this.validateReplyParameters(replyParameters); + const dispatchData = this.createMockScopeDispatchData(replyParameters); + return new MockScope(addMockDispatch(this[kDispatches], this[kDispatchKey], dispatchData)); + } + /** + * Mock an undici request with a defined error. + */ + replyWithError(error) { + if (typeof error === "undefined") throw new InvalidArgumentError("error must be defined"); + return new MockScope(addMockDispatch(this[kDispatches], this[kDispatchKey], { error })); + } + /** + * Set default reply headers on the interceptor for subsequent replies + */ + defaultReplyHeaders(headers) { + if (typeof headers === "undefined") throw new InvalidArgumentError("headers must be defined"); + this[kDefaultHeaders] = headers; + return this; + } + /** + * Set default reply trailers on the interceptor for subsequent replies + */ + defaultReplyTrailers(trailers) { + if (typeof trailers === "undefined") throw new InvalidArgumentError("trailers must be defined"); + this[kDefaultTrailers] = trailers; + return this; + } + /** + * Set reply content length header for replies on the interceptor + */ + replyContentLength() { + this[kContentLength] = true; + return this; + } + }; + module.exports.MockInterceptor = MockInterceptor; + module.exports.MockScope = MockScope; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/mock/mock-client.js +var require_mock_client = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { promisify: promisify$1 } = __require("node:util"); + const Client = require_client(); + const { buildMockDispatch } = require_mock_utils(); + const { kDispatches, kMockAgent, kClose, kOriginalClose, kOrigin, kOriginalDispatch, kConnected } = require_mock_symbols(); + const { MockInterceptor } = require_mock_interceptor(); + const Symbols = require_symbols$4(); + const { InvalidArgumentError } = require_errors(); + /** + * MockClient provides an API that extends the Client to influence the mockDispatches. + */ + var MockClient = class extends Client { + constructor(origin, opts) { + super(origin, opts); + if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") throw new InvalidArgumentError("Argument opts.agent must implement Agent"); + this[kMockAgent] = opts.agent; + this[kOrigin] = origin; + this[kDispatches] = []; + this[kConnected] = 1; + this[kOriginalDispatch] = this.dispatch; + this[kOriginalClose] = this.close.bind(this); + this.dispatch = buildMockDispatch.call(this); + this.close = this[kClose]; + } + get [Symbols.kConnected]() { + return this[kConnected]; + } + /** + * Sets up the base interceptor for mocking replies from undici. + */ + intercept(opts) { + return new MockInterceptor(opts, this[kDispatches]); + } + async [kClose]() { + await promisify$1(this[kOriginalClose])(); + this[kConnected] = 0; + this[kMockAgent][Symbols.kClients].delete(this[kOrigin]); + } + }; + module.exports = MockClient; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/mock/mock-pool.js +var require_mock_pool = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { promisify } = __require("node:util"); + const Pool = require_pool(); + const { buildMockDispatch } = require_mock_utils(); + const { kDispatches, kMockAgent, kClose, kOriginalClose, kOrigin, kOriginalDispatch, kConnected } = require_mock_symbols(); + const { MockInterceptor } = require_mock_interceptor(); + const Symbols = require_symbols$4(); + const { InvalidArgumentError } = require_errors(); + /** + * MockPool provides an API that extends the Pool to influence the mockDispatches. + */ + var MockPool = class extends Pool { + constructor(origin, opts) { + super(origin, opts); + if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") throw new InvalidArgumentError("Argument opts.agent must implement Agent"); + this[kMockAgent] = opts.agent; + this[kOrigin] = origin; + this[kDispatches] = []; + this[kConnected] = 1; + this[kOriginalDispatch] = this.dispatch; + this[kOriginalClose] = this.close.bind(this); + this.dispatch = buildMockDispatch.call(this); + this.close = this[kClose]; + } + get [Symbols.kConnected]() { + return this[kConnected]; + } + /** + * Sets up the base interceptor for mocking replies from undici. + */ + intercept(opts) { + return new MockInterceptor(opts, this[kDispatches]); + } + async [kClose]() { + await promisify(this[kOriginalClose])(); + this[kConnected] = 0; + this[kMockAgent][Symbols.kClients].delete(this[kOrigin]); + } + }; + module.exports = MockPool; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/mock/pluralizer.js +var require_pluralizer = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const singulars = { + pronoun: "it", + is: "is", + was: "was", + this: "this" + }; + const plurals = { + pronoun: "they", + is: "are", + was: "were", + this: "these" + }; + module.exports = class Pluralizer { + constructor(singular, plural) { + this.singular = singular; + this.plural = plural; + } + pluralize(count) { + const one = count === 1; + const keys = one ? singulars : plurals; + const noun = one ? this.singular : this.plural; + return { + ...keys, + count, + noun + }; + } + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/mock/pending-interceptors-formatter.js +var require_pending_interceptors_formatter = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { Transform: Transform$1 } = __require("node:stream"); + const { Console } = __require("node:console"); + const PERSISTENT = process.versions.icu ? "✅" : "Y "; + const NOT_PERSISTENT = process.versions.icu ? "❌" : "N "; + /** + * Gets the output of `console.table(…)` as a string. + */ + module.exports = class PendingInterceptorsFormatter { + constructor({ disableColors } = {}) { + this.transform = new Transform$1({ transform(chunk, _enc, cb) { + cb(null, chunk); + } }); + this.logger = new Console({ + stdout: this.transform, + inspectOptions: { colors: !disableColors && !process.env.CI } + }); + } + format(pendingInterceptors) { + const withPrettyHeaders = pendingInterceptors.map(({ method, path, data: { statusCode }, persist, times, timesInvoked, origin }) => ({ + Method: method, + Origin: origin, + Path: path, + "Status code": statusCode, + Persistent: persist ? PERSISTENT : NOT_PERSISTENT, + Invocations: timesInvoked, + Remaining: persist ? Infinity : times - timesInvoked + })); + this.logger.table(withPrettyHeaders); + return this.transform.read().toString(); + } + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/mock/mock-agent.js +var require_mock_agent = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { kClients } = require_symbols$4(); + const Agent = require_agent(); + const { kAgent, kMockAgentSet, kMockAgentGet, kDispatches, kIsMockActive, kNetConnect, kGetNetConnect, kOptions, kFactory } = require_mock_symbols(); + const MockClient = require_mock_client(); + const MockPool = require_mock_pool(); + const { matchValue, buildMockOptions } = require_mock_utils(); + const { InvalidArgumentError, UndiciError } = require_errors(); + const Dispatcher = require_dispatcher(); + const Pluralizer = require_pluralizer(); + const PendingInterceptorsFormatter = require_pending_interceptors_formatter(); + var MockAgent = class extends Dispatcher { + constructor(opts) { + super(opts); + this[kNetConnect] = true; + this[kIsMockActive] = true; + if (opts?.agent && typeof opts.agent.dispatch !== "function") throw new InvalidArgumentError("Argument opts.agent must implement Agent"); + const agent = opts?.agent ? opts.agent : new Agent(opts); + this[kAgent] = agent; + this[kClients] = agent[kClients]; + this[kOptions] = buildMockOptions(opts); + } + get(origin) { + let dispatcher = this[kMockAgentGet](origin); + if (!dispatcher) { + dispatcher = this[kFactory](origin); + this[kMockAgentSet](origin, dispatcher); + } + return dispatcher; + } + dispatch(opts, handler) { + this.get(opts.origin); + return this[kAgent].dispatch(opts, handler); + } + async close() { + await this[kAgent].close(); + this[kClients].clear(); + } + deactivate() { + this[kIsMockActive] = false; + } + activate() { + this[kIsMockActive] = true; + } + enableNetConnect(matcher) { + if (typeof matcher === "string" || typeof matcher === "function" || matcher instanceof RegExp) { + if (Array.isArray(this[kNetConnect])) this[kNetConnect].push(matcher); + else this[kNetConnect] = [matcher]; + } else if (typeof matcher === "undefined") this[kNetConnect] = true; + else throw new InvalidArgumentError("Unsupported matcher. Must be one of String|Function|RegExp."); + } + disableNetConnect() { + this[kNetConnect] = false; + } + get isMockActive() { + return this[kIsMockActive]; + } + [kMockAgentSet](origin, dispatcher) { + this[kClients].set(origin, dispatcher); + } + [kFactory](origin) { + const mockOptions = Object.assign({ agent: this }, this[kOptions]); + return this[kOptions] && this[kOptions].connections === 1 ? new MockClient(origin, mockOptions) : new MockPool(origin, mockOptions); + } + [kMockAgentGet](origin) { + const client = this[kClients].get(origin); + if (client) return client; + if (typeof origin !== "string") { + const dispatcher = this[kFactory]("http://localhost:9999"); + this[kMockAgentSet](origin, dispatcher); + return dispatcher; + } + for (const [keyMatcher, nonExplicitDispatcher] of Array.from(this[kClients])) if (nonExplicitDispatcher && typeof keyMatcher !== "string" && matchValue(keyMatcher, origin)) { + const dispatcher = this[kFactory](origin); + this[kMockAgentSet](origin, dispatcher); + dispatcher[kDispatches] = nonExplicitDispatcher[kDispatches]; + return dispatcher; + } + } + [kGetNetConnect]() { + return this[kNetConnect]; + } + pendingInterceptors() { + const mockAgentClients = this[kClients]; + return Array.from(mockAgentClients.entries()).flatMap(([origin, scope]) => scope[kDispatches].map((dispatch) => ({ + ...dispatch, + origin + }))).filter(({ pending }) => pending); + } + assertNoPendingInterceptors({ pendingInterceptorsFormatter = new PendingInterceptorsFormatter() } = {}) { + const pending = this.pendingInterceptors(); + if (pending.length === 0) return; + const pluralizer = new Pluralizer("interceptor", "interceptors").pluralize(pending.length); + throw new UndiciError(` +${pluralizer.count} ${pluralizer.noun} ${pluralizer.is} pending: + +${pendingInterceptorsFormatter.format(pending)} +`.trim()); + } + }; + module.exports = MockAgent; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/global.js +var require_global = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const globalDispatcher = Symbol.for("undici.globalDispatcher.1"); + const { InvalidArgumentError } = require_errors(); + const Agent = require_agent(); + if (getGlobalDispatcher() === void 0) setGlobalDispatcher(new Agent()); + function setGlobalDispatcher(agent) { + if (!agent || typeof agent.dispatch !== "function") throw new InvalidArgumentError("Argument agent must implement Agent"); + Object.defineProperty(globalThis, globalDispatcher, { + value: agent, + writable: true, + enumerable: false, + configurable: false + }); + } + function getGlobalDispatcher() { + return globalThis[globalDispatcher]; + } + module.exports = { + setGlobalDispatcher, + getGlobalDispatcher + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/handler/decorator-handler.js +var require_decorator_handler = /* @__PURE__ */ __commonJSMin(((exports, module) => { + module.exports = class DecoratorHandler { + #handler; + constructor(handler) { + if (typeof handler !== "object" || handler === null) throw new TypeError("handler must be an object"); + this.#handler = handler; + } + onConnect(...args) { + return this.#handler.onConnect?.(...args); + } + onError(...args) { + return this.#handler.onError?.(...args); + } + onUpgrade(...args) { + return this.#handler.onUpgrade?.(...args); + } + onResponseStarted(...args) { + return this.#handler.onResponseStarted?.(...args); + } + onHeaders(...args) { + return this.#handler.onHeaders?.(...args); + } + onData(...args) { + return this.#handler.onData?.(...args); + } + onComplete(...args) { + return this.#handler.onComplete?.(...args); + } + onBodySent(...args) { + return this.#handler.onBodySent?.(...args); + } + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/interceptor/redirect.js +var require_redirect = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const RedirectHandler = require_redirect_handler(); + module.exports = (opts) => { + const globalMaxRedirections = opts?.maxRedirections; + return (dispatch) => { + return function redirectInterceptor(opts, handler) { + const { maxRedirections = globalMaxRedirections, ...baseOpts } = opts; + if (!maxRedirections) return dispatch(opts, handler); + return dispatch(baseOpts, new RedirectHandler(dispatch, maxRedirections, opts, handler)); + }; + }; + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/interceptor/retry.js +var require_retry = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const RetryHandler = require_retry_handler(); + module.exports = (globalOpts) => { + return (dispatch) => { + return function retryInterceptor(opts, handler) { + return dispatch(opts, new RetryHandler({ + ...opts, + retryOptions: { + ...globalOpts, + ...opts.retryOptions + } + }, { + handler, + dispatch + })); + }; + }; + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/interceptor/dump.js +var require_dump = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const util = require_util$7(); + const { InvalidArgumentError, RequestAbortedError } = require_errors(); + const DecoratorHandler = require_decorator_handler(); + var DumpHandler = class extends DecoratorHandler { + #maxSize = 1048576; + #abort = null; + #dumped = false; + #aborted = false; + #size = 0; + #reason = null; + #handler = null; + constructor({ maxSize }, handler) { + super(handler); + if (maxSize != null && (!Number.isFinite(maxSize) || maxSize < 1)) throw new InvalidArgumentError("maxSize must be a number greater than 0"); + this.#maxSize = maxSize ?? this.#maxSize; + this.#handler = handler; + } + onConnect(abort) { + this.#abort = abort; + this.#handler.onConnect(this.#customAbort.bind(this)); + } + #customAbort(reason) { + this.#aborted = true; + this.#reason = reason; + } + onHeaders(statusCode, rawHeaders, resume, statusMessage) { + const contentLength = util.parseHeaders(rawHeaders)["content-length"]; + if (contentLength != null && contentLength > this.#maxSize) throw new RequestAbortedError(`Response size (${contentLength}) larger than maxSize (${this.#maxSize})`); + if (this.#aborted) return true; + return this.#handler.onHeaders(statusCode, rawHeaders, resume, statusMessage); + } + onError(err) { + if (this.#dumped) return; + err = this.#reason ?? err; + this.#handler.onError(err); + } + onData(chunk) { + this.#size = this.#size + chunk.length; + if (this.#size >= this.#maxSize) { + this.#dumped = true; + if (this.#aborted) this.#handler.onError(this.#reason); + else this.#handler.onComplete([]); + } + return true; + } + onComplete(trailers) { + if (this.#dumped) return; + if (this.#aborted) { + this.#handler.onError(this.reason); + return; + } + this.#handler.onComplete(trailers); + } + }; + function createDumpInterceptor({ maxSize: defaultMaxSize } = { maxSize: 1048576 }) { + return (dispatch) => { + return function Intercept(opts, handler) { + const { dumpMaxSize = defaultMaxSize } = opts; + return dispatch(opts, new DumpHandler({ maxSize: dumpMaxSize }, handler)); + }; + }; + } + module.exports = createDumpInterceptor; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/interceptor/dns.js +var require_dns = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { isIP } = __require("node:net"); + const { lookup } = __require("node:dns"); + const DecoratorHandler = require_decorator_handler(); + const { InvalidArgumentError, InformationalError } = require_errors(); + const maxInt = Math.pow(2, 31) - 1; + var DNSInstance = class { + #maxTTL = 0; + #maxItems = 0; + #records = /* @__PURE__ */ new Map(); + dualStack = true; + affinity = null; + lookup = null; + pick = null; + constructor(opts) { + this.#maxTTL = opts.maxTTL; + this.#maxItems = opts.maxItems; + this.dualStack = opts.dualStack; + this.affinity = opts.affinity; + this.lookup = opts.lookup ?? this.#defaultLookup; + this.pick = opts.pick ?? this.#defaultPick; + } + get full() { + return this.#records.size === this.#maxItems; + } + runLookup(origin, opts, cb) { + const ips = this.#records.get(origin.hostname); + if (ips == null && this.full) { + cb(null, origin.origin); + return; + } + const newOpts = { + affinity: this.affinity, + dualStack: this.dualStack, + lookup: this.lookup, + pick: this.pick, + ...opts.dns, + maxTTL: this.#maxTTL, + maxItems: this.#maxItems + }; + if (ips == null) this.lookup(origin, newOpts, (err, addresses) => { + if (err || addresses == null || addresses.length === 0) { + cb(err ?? new InformationalError("No DNS entries found")); + return; + } + this.setRecords(origin, addresses); + const records = this.#records.get(origin.hostname); + const ip = this.pick(origin, records, newOpts.affinity); + let port; + if (typeof ip.port === "number") port = `:${ip.port}`; + else if (origin.port !== "") port = `:${origin.port}`; + else port = ""; + cb(null, `${origin.protocol}//${ip.family === 6 ? `[${ip.address}]` : ip.address}${port}`); + }); + else { + const ip = this.pick(origin, ips, newOpts.affinity); + if (ip == null) { + this.#records.delete(origin.hostname); + this.runLookup(origin, opts, cb); + return; + } + let port; + if (typeof ip.port === "number") port = `:${ip.port}`; + else if (origin.port !== "") port = `:${origin.port}`; + else port = ""; + cb(null, `${origin.protocol}//${ip.family === 6 ? `[${ip.address}]` : ip.address}${port}`); + } + } + #defaultLookup(origin, opts, cb) { + lookup(origin.hostname, { + all: true, + family: this.dualStack === false ? this.affinity : 0, + order: "ipv4first" + }, (err, addresses) => { + if (err) return cb(err); + const results = /* @__PURE__ */ new Map(); + for (const addr of addresses) results.set(`${addr.address}:${addr.family}`, addr); + cb(null, results.values()); + }); + } + #defaultPick(origin, hostnameRecords, affinity) { + let ip = null; + const { records, offset } = hostnameRecords; + let family; + if (this.dualStack) { + if (affinity == null) { + if (offset == null || offset === maxInt) { + hostnameRecords.offset = 0; + affinity = 4; + } else { + hostnameRecords.offset++; + affinity = (hostnameRecords.offset & 1) === 1 ? 6 : 4; + } + } + if (records[affinity] != null && records[affinity].ips.length > 0) family = records[affinity]; + else family = records[affinity === 4 ? 6 : 4]; + } else family = records[affinity]; + if (family == null || family.ips.length === 0) return ip; + if (family.offset == null || family.offset === maxInt) family.offset = 0; + else family.offset++; + const position = family.offset % family.ips.length; + ip = family.ips[position] ?? null; + if (ip == null) return ip; + if (Date.now() - ip.timestamp > ip.ttl) { + family.ips.splice(position, 1); + return this.pick(origin, hostnameRecords, affinity); + } + return ip; + } + setRecords(origin, addresses) { + const timestamp = Date.now(); + const records = { records: { + 4: null, + 6: null + } }; + for (const record of addresses) { + record.timestamp = timestamp; + if (typeof record.ttl === "number") record.ttl = Math.min(record.ttl, this.#maxTTL); + else record.ttl = this.#maxTTL; + const familyRecords = records.records[record.family] ?? { ips: [] }; + familyRecords.ips.push(record); + records.records[record.family] = familyRecords; + } + this.#records.set(origin.hostname, records); + } + getHandler(meta, opts) { + return new DNSDispatchHandler(this, meta, opts); + } + }; + var DNSDispatchHandler = class extends DecoratorHandler { + #state = null; + #opts = null; + #dispatch = null; + #handler = null; + #origin = null; + constructor(state, { origin, handler, dispatch }, opts) { + super(handler); + this.#origin = origin; + this.#handler = handler; + this.#opts = { ...opts }; + this.#state = state; + this.#dispatch = dispatch; + } + onError(err) { + switch (err.code) { + case "ETIMEDOUT": + case "ECONNREFUSED": + if (this.#state.dualStack) { + this.#state.runLookup(this.#origin, this.#opts, (err, newOrigin) => { + if (err) return this.#handler.onError(err); + const dispatchOpts = { + ...this.#opts, + origin: newOrigin + }; + this.#dispatch(dispatchOpts, this); + }); + return; + } + this.#handler.onError(err); + return; + case "ENOTFOUND": this.#state.deleteRecord(this.#origin); + default: this.#handler.onError(err); + } + } + }; + module.exports = (interceptorOpts) => { + if (interceptorOpts?.maxTTL != null && (typeof interceptorOpts?.maxTTL !== "number" || interceptorOpts?.maxTTL < 0)) throw new InvalidArgumentError("Invalid maxTTL. Must be a positive number"); + if (interceptorOpts?.maxItems != null && (typeof interceptorOpts?.maxItems !== "number" || interceptorOpts?.maxItems < 1)) throw new InvalidArgumentError("Invalid maxItems. Must be a positive number and greater than zero"); + if (interceptorOpts?.affinity != null && interceptorOpts?.affinity !== 4 && interceptorOpts?.affinity !== 6) throw new InvalidArgumentError("Invalid affinity. Must be either 4 or 6"); + if (interceptorOpts?.dualStack != null && typeof interceptorOpts?.dualStack !== "boolean") throw new InvalidArgumentError("Invalid dualStack. Must be a boolean"); + if (interceptorOpts?.lookup != null && typeof interceptorOpts?.lookup !== "function") throw new InvalidArgumentError("Invalid lookup. Must be a function"); + if (interceptorOpts?.pick != null && typeof interceptorOpts?.pick !== "function") throw new InvalidArgumentError("Invalid pick. Must be a function"); + const dualStack = interceptorOpts?.dualStack ?? true; + let affinity; + if (dualStack) affinity = interceptorOpts?.affinity ?? null; + else affinity = interceptorOpts?.affinity ?? 4; + const instance = new DNSInstance({ + maxTTL: interceptorOpts?.maxTTL ?? 1e4, + lookup: interceptorOpts?.lookup ?? null, + pick: interceptorOpts?.pick ?? null, + dualStack, + affinity, + maxItems: interceptorOpts?.maxItems ?? Infinity + }); + return (dispatch) => { + return function dnsInterceptor(origDispatchOpts, handler) { + const origin = origDispatchOpts.origin.constructor === URL ? origDispatchOpts.origin : new URL(origDispatchOpts.origin); + if (isIP(origin.hostname) !== 0) return dispatch(origDispatchOpts, handler); + instance.runLookup(origin, origDispatchOpts, (err, newOrigin) => { + if (err) return handler.onError(err); + let dispatchOpts = null; + dispatchOpts = { + ...origDispatchOpts, + servername: origin.hostname, + origin: newOrigin, + headers: { + host: origin.hostname, + ...origDispatchOpts.headers + } + }; + dispatch(dispatchOpts, instance.getHandler({ + origin, + dispatch, + handler + }, origDispatchOpts)); + }); + return true; + }; + }; + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fetch/headers.js +var require_headers = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { kConstruct } = require_symbols$4(); + const { kEnumerableProperty } = require_util$7(); + const { iteratorMixin, isValidHeaderName, isValidHeaderValue } = require_util$6(); + const { webidl } = require_webidl(); + const assert$7 = __require("node:assert"); + const util = __require("node:util"); + const kHeadersMap = Symbol("headers map"); + const kHeadersSortedMap = Symbol("headers map sorted"); + /** + * @param {number} code + */ + function isHTTPWhiteSpaceCharCode(code) { + return code === 10 || code === 13 || code === 9 || code === 32; + } + /** + * @see https://fetch.spec.whatwg.org/#concept-header-value-normalize + * @param {string} potentialValue + */ + function headerValueNormalize(potentialValue) { + let i = 0; + let j = potentialValue.length; + while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(j - 1))) --j; + while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(i))) ++i; + return i === 0 && j === potentialValue.length ? potentialValue : potentialValue.substring(i, j); + } + function fill(headers, object) { + if (Array.isArray(object)) for (let i = 0; i < object.length; ++i) { + const header = object[i]; + if (header.length !== 2) throw webidl.errors.exception({ + header: "Headers constructor", + message: `expected name/value pair to be length 2, found ${header.length}.` + }); + appendHeader(headers, header[0], header[1]); + } + else if (typeof object === "object" && object !== null) { + const keys = Object.keys(object); + for (let i = 0; i < keys.length; ++i) appendHeader(headers, keys[i], object[keys[i]]); + } else throw webidl.errors.conversionFailed({ + prefix: "Headers constructor", + argument: "Argument 1", + types: ["sequence>", "record"] + }); + } + /** + * @see https://fetch.spec.whatwg.org/#concept-headers-append + */ + function appendHeader(headers, name, value) { + value = headerValueNormalize(value); + if (!isValidHeaderName(name)) throw webidl.errors.invalidArgument({ + prefix: "Headers.append", + value: name, + type: "header name" + }); + else if (!isValidHeaderValue(value)) throw webidl.errors.invalidArgument({ + prefix: "Headers.append", + value, + type: "header value" + }); + if (getHeadersGuard(headers) === "immutable") throw new TypeError("immutable"); + return getHeadersList(headers).append(name, value, false); + } + function compareHeaderName(a, b) { + return a[0] < b[0] ? -1 : 1; + } + var HeadersList = class HeadersList { + /** @type {[string, string][]|null} */ + cookies = null; + constructor(init) { + if (init instanceof HeadersList) { + this[kHeadersMap] = new Map(init[kHeadersMap]); + this[kHeadersSortedMap] = init[kHeadersSortedMap]; + this.cookies = init.cookies === null ? null : [...init.cookies]; + } else { + this[kHeadersMap] = new Map(init); + this[kHeadersSortedMap] = null; + } + } + /** + * @see https://fetch.spec.whatwg.org/#header-list-contains + * @param {string} name + * @param {boolean} isLowerCase + */ + contains(name, isLowerCase) { + return this[kHeadersMap].has(isLowerCase ? name : name.toLowerCase()); + } + clear() { + this[kHeadersMap].clear(); + this[kHeadersSortedMap] = null; + this.cookies = null; + } + /** + * @see https://fetch.spec.whatwg.org/#concept-header-list-append + * @param {string} name + * @param {string} value + * @param {boolean} isLowerCase + */ + append(name, value, isLowerCase) { + this[kHeadersSortedMap] = null; + const lowercaseName = isLowerCase ? name : name.toLowerCase(); + const exists = this[kHeadersMap].get(lowercaseName); + if (exists) { + const delimiter = lowercaseName === "cookie" ? "; " : ", "; + this[kHeadersMap].set(lowercaseName, { + name: exists.name, + value: `${exists.value}${delimiter}${value}` + }); + } else this[kHeadersMap].set(lowercaseName, { + name, + value + }); + if (lowercaseName === "set-cookie") (this.cookies ??= []).push(value); + } + /** + * @see https://fetch.spec.whatwg.org/#concept-header-list-set + * @param {string} name + * @param {string} value + * @param {boolean} isLowerCase + */ + set(name, value, isLowerCase) { + this[kHeadersSortedMap] = null; + const lowercaseName = isLowerCase ? name : name.toLowerCase(); + if (lowercaseName === "set-cookie") this.cookies = [value]; + this[kHeadersMap].set(lowercaseName, { + name, + value + }); + } + /** + * @see https://fetch.spec.whatwg.org/#concept-header-list-delete + * @param {string} name + * @param {boolean} isLowerCase + */ + delete(name, isLowerCase) { + this[kHeadersSortedMap] = null; + if (!isLowerCase) name = name.toLowerCase(); + if (name === "set-cookie") this.cookies = null; + this[kHeadersMap].delete(name); + } + /** + * @see https://fetch.spec.whatwg.org/#concept-header-list-get + * @param {string} name + * @param {boolean} isLowerCase + * @returns {string | null} + */ + get(name, isLowerCase) { + return this[kHeadersMap].get(isLowerCase ? name : name.toLowerCase())?.value ?? null; + } + *[Symbol.iterator]() { + for (const { 0: name, 1: { value } } of this[kHeadersMap]) yield [name, value]; + } + get entries() { + const headers = {}; + if (this[kHeadersMap].size !== 0) for (const { name, value } of this[kHeadersMap].values()) headers[name] = value; + return headers; + } + rawValues() { + return this[kHeadersMap].values(); + } + get entriesList() { + const headers = []; + if (this[kHeadersMap].size !== 0) for (const { 0: lowerName, 1: { name, value } } of this[kHeadersMap]) if (lowerName === "set-cookie") for (const cookie of this.cookies) headers.push([name, cookie]); + else headers.push([name, value]); + return headers; + } + toSortedArray() { + const size = this[kHeadersMap].size; + const array = new Array(size); + if (size <= 32) { + if (size === 0) return array; + const iterator = this[kHeadersMap][Symbol.iterator](); + const firstValue = iterator.next().value; + array[0] = [firstValue[0], firstValue[1].value]; + assert$7(firstValue[1].value !== null); + for (let i = 1, j = 0, right = 0, left = 0, pivot = 0, x, value; i < size; ++i) { + value = iterator.next().value; + x = array[i] = [value[0], value[1].value]; + assert$7(x[1] !== null); + left = 0; + right = i; + while (left < right) { + pivot = left + (right - left >> 1); + if (array[pivot][0] <= x[0]) left = pivot + 1; + else right = pivot; + } + if (i !== pivot) { + j = i; + while (j > left) array[j] = array[--j]; + array[left] = x; + } + } + /* c8 ignore next 4 */ + if (!iterator.next().done) throw new TypeError("Unreachable"); + return array; + } else { + let i = 0; + for (const { 0: name, 1: { value } } of this[kHeadersMap]) { + array[i++] = [name, value]; + assert$7(value !== null); + } + return array.sort(compareHeaderName); + } + } + }; + var Headers = class Headers { + #guard; + #headersList; + constructor(init = void 0) { + webidl.util.markAsUncloneable(this); + if (init === kConstruct) return; + this.#headersList = new HeadersList(); + this.#guard = "none"; + if (init !== void 0) { + init = webidl.converters.HeadersInit(init, "Headers contructor", "init"); + fill(this, init); + } + } + append(name, value) { + webidl.brandCheck(this, Headers); + webidl.argumentLengthCheck(arguments, 2, "Headers.append"); + const prefix = "Headers.append"; + name = webidl.converters.ByteString(name, prefix, "name"); + value = webidl.converters.ByteString(value, prefix, "value"); + return appendHeader(this, name, value); + } + delete(name) { + webidl.brandCheck(this, Headers); + webidl.argumentLengthCheck(arguments, 1, "Headers.delete"); + name = webidl.converters.ByteString(name, "Headers.delete", "name"); + if (!isValidHeaderName(name)) throw webidl.errors.invalidArgument({ + prefix: "Headers.delete", + value: name, + type: "header name" + }); + if (this.#guard === "immutable") throw new TypeError("immutable"); + if (!this.#headersList.contains(name, false)) return; + this.#headersList.delete(name, false); + } + get(name) { + webidl.brandCheck(this, Headers); + webidl.argumentLengthCheck(arguments, 1, "Headers.get"); + const prefix = "Headers.get"; + name = webidl.converters.ByteString(name, prefix, "name"); + if (!isValidHeaderName(name)) throw webidl.errors.invalidArgument({ + prefix, + value: name, + type: "header name" + }); + return this.#headersList.get(name, false); + } + has(name) { + webidl.brandCheck(this, Headers); + webidl.argumentLengthCheck(arguments, 1, "Headers.has"); + const prefix = "Headers.has"; + name = webidl.converters.ByteString(name, prefix, "name"); + if (!isValidHeaderName(name)) throw webidl.errors.invalidArgument({ + prefix, + value: name, + type: "header name" + }); + return this.#headersList.contains(name, false); + } + set(name, value) { + webidl.brandCheck(this, Headers); + webidl.argumentLengthCheck(arguments, 2, "Headers.set"); + const prefix = "Headers.set"; + name = webidl.converters.ByteString(name, prefix, "name"); + value = webidl.converters.ByteString(value, prefix, "value"); + value = headerValueNormalize(value); + if (!isValidHeaderName(name)) throw webidl.errors.invalidArgument({ + prefix, + value: name, + type: "header name" + }); + else if (!isValidHeaderValue(value)) throw webidl.errors.invalidArgument({ + prefix, + value, + type: "header value" + }); + if (this.#guard === "immutable") throw new TypeError("immutable"); + this.#headersList.set(name, value, false); + } + getSetCookie() { + webidl.brandCheck(this, Headers); + const list = this.#headersList.cookies; + if (list) return [...list]; + return []; + } + get [kHeadersSortedMap]() { + if (this.#headersList[kHeadersSortedMap]) return this.#headersList[kHeadersSortedMap]; + const headers = []; + const names = this.#headersList.toSortedArray(); + const cookies = this.#headersList.cookies; + if (cookies === null || cookies.length === 1) return this.#headersList[kHeadersSortedMap] = names; + for (let i = 0; i < names.length; ++i) { + const { 0: name, 1: value } = names[i]; + if (name === "set-cookie") for (let j = 0; j < cookies.length; ++j) headers.push([name, cookies[j]]); + else headers.push([name, value]); + } + return this.#headersList[kHeadersSortedMap] = headers; + } + [util.inspect.custom](depth, options) { + options.depth ??= depth; + return `Headers ${util.formatWithOptions(options, this.#headersList.entries)}`; + } + static getHeadersGuard(o) { + return o.#guard; + } + static setHeadersGuard(o, guard) { + o.#guard = guard; + } + static getHeadersList(o) { + return o.#headersList; + } + static setHeadersList(o, list) { + o.#headersList = list; + } + }; + const { getHeadersGuard, setHeadersGuard, getHeadersList, setHeadersList } = Headers; + Reflect.deleteProperty(Headers, "getHeadersGuard"); + Reflect.deleteProperty(Headers, "setHeadersGuard"); + Reflect.deleteProperty(Headers, "getHeadersList"); + Reflect.deleteProperty(Headers, "setHeadersList"); + iteratorMixin("Headers", Headers, kHeadersSortedMap, 0, 1); + Object.defineProperties(Headers.prototype, { + append: kEnumerableProperty, + delete: kEnumerableProperty, + get: kEnumerableProperty, + has: kEnumerableProperty, + set: kEnumerableProperty, + getSetCookie: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "Headers", + configurable: true + }, + [util.inspect.custom]: { enumerable: false } + }); + webidl.converters.HeadersInit = function(V, prefix, argument) { + if (webidl.util.Type(V) === "Object") { + const iterator = Reflect.get(V, Symbol.iterator); + if (!util.types.isProxy(V) && iterator === Headers.prototype.entries) try { + return getHeadersList(V).entriesList; + } catch {} + if (typeof iterator === "function") return webidl.converters["sequence>"](V, prefix, argument, iterator.bind(V)); + return webidl.converters["record"](V, prefix, argument); + } + throw webidl.errors.conversionFailed({ + prefix: "Headers constructor", + argument: "Argument 1", + types: ["sequence>", "record"] + }); + }; + module.exports = { + fill, + compareHeaderName, + Headers, + HeadersList, + getHeadersGuard, + setHeadersGuard, + setHeadersList, + getHeadersList + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fetch/response.js +var require_response = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { Headers, HeadersList, fill, getHeadersGuard, setHeadersGuard, setHeadersList } = require_headers(); + const { extractBody, cloneBody, mixinBody, hasFinalizationRegistry, streamRegistry, bodyUnusable } = require_body(); + const util = require_util$7(); + const nodeUtil$1 = __require("node:util"); + const { kEnumerableProperty } = util; + const { isValidReasonPhrase, isCancelled, isAborted, isBlobLike, serializeJavascriptValueToJSONString, isErrorLike, isomorphicEncode, environmentSettingsObject: relevantRealm } = require_util$6(); + const { redirectStatusSet, nullBodyStatus } = require_constants$2(); + const { kState, kHeaders } = require_symbols$3(); + const { webidl } = require_webidl(); + const { FormData } = require_formdata(); + const { URLSerializer } = require_data_url(); + const { kConstruct } = require_symbols$4(); + const assert$6 = __require("node:assert"); + const { types: types$2 } = __require("node:util"); + const textEncoder = new TextEncoder("utf-8"); + var Response = class Response { + static error() { + return fromInnerResponse(makeNetworkError(), "immutable"); + } + static json(data, init = {}) { + webidl.argumentLengthCheck(arguments, 1, "Response.json"); + if (init !== null) init = webidl.converters.ResponseInit(init); + const bytes = textEncoder.encode(serializeJavascriptValueToJSONString(data)); + const body = extractBody(bytes); + const responseObject = fromInnerResponse(makeResponse({}), "response"); + initializeResponse(responseObject, init, { + body: body[0], + type: "application/json" + }); + return responseObject; + } + static redirect(url, status = 302) { + webidl.argumentLengthCheck(arguments, 1, "Response.redirect"); + url = webidl.converters.USVString(url); + status = webidl.converters["unsigned short"](status); + let parsedURL; + try { + parsedURL = new URL(url, relevantRealm.settingsObject.baseUrl); + } catch (err) { + throw new TypeError(`Failed to parse URL from ${url}`, { cause: err }); + } + if (!redirectStatusSet.has(status)) throw new RangeError(`Invalid status code ${status}`); + const responseObject = fromInnerResponse(makeResponse({}), "immutable"); + responseObject[kState].status = status; + const value = isomorphicEncode(URLSerializer(parsedURL)); + responseObject[kState].headersList.append("location", value, true); + return responseObject; + } + constructor(body = null, init = {}) { + webidl.util.markAsUncloneable(this); + if (body === kConstruct) return; + if (body !== null) body = webidl.converters.BodyInit(body); + init = webidl.converters.ResponseInit(init); + this[kState] = makeResponse({}); + this[kHeaders] = new Headers(kConstruct); + setHeadersGuard(this[kHeaders], "response"); + setHeadersList(this[kHeaders], this[kState].headersList); + let bodyWithType = null; + if (body != null) { + const [extractedBody, type] = extractBody(body); + bodyWithType = { + body: extractedBody, + type + }; + } + initializeResponse(this, init, bodyWithType); + } + get type() { + webidl.brandCheck(this, Response); + return this[kState].type; + } + get url() { + webidl.brandCheck(this, Response); + const urlList = this[kState].urlList; + const url = urlList[urlList.length - 1] ?? null; + if (url === null) return ""; + return URLSerializer(url, true); + } + get redirected() { + webidl.brandCheck(this, Response); + return this[kState].urlList.length > 1; + } + get status() { + webidl.brandCheck(this, Response); + return this[kState].status; + } + get ok() { + webidl.brandCheck(this, Response); + return this[kState].status >= 200 && this[kState].status <= 299; + } + get statusText() { + webidl.brandCheck(this, Response); + return this[kState].statusText; + } + get headers() { + webidl.brandCheck(this, Response); + return this[kHeaders]; + } + get body() { + webidl.brandCheck(this, Response); + return this[kState].body ? this[kState].body.stream : null; + } + get bodyUsed() { + webidl.brandCheck(this, Response); + return !!this[kState].body && util.isDisturbed(this[kState].body.stream); + } + clone() { + webidl.brandCheck(this, Response); + if (bodyUnusable(this)) throw webidl.errors.exception({ + header: "Response.clone", + message: "Body has already been consumed." + }); + const clonedResponse = cloneResponse(this[kState]); + if (hasFinalizationRegistry && this[kState].body?.stream) streamRegistry.register(this, new WeakRef(this[kState].body.stream)); + return fromInnerResponse(clonedResponse, getHeadersGuard(this[kHeaders])); + } + [nodeUtil$1.inspect.custom](depth, options) { + if (options.depth === null) options.depth = 2; + options.colors ??= true; + const properties = { + status: this.status, + statusText: this.statusText, + headers: this.headers, + body: this.body, + bodyUsed: this.bodyUsed, + ok: this.ok, + redirected: this.redirected, + type: this.type, + url: this.url + }; + return `Response ${nodeUtil$1.formatWithOptions(options, properties)}`; + } + }; + mixinBody(Response); + Object.defineProperties(Response.prototype, { + type: kEnumerableProperty, + url: kEnumerableProperty, + status: kEnumerableProperty, + ok: kEnumerableProperty, + redirected: kEnumerableProperty, + statusText: kEnumerableProperty, + headers: kEnumerableProperty, + clone: kEnumerableProperty, + body: kEnumerableProperty, + bodyUsed: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "Response", + configurable: true + } + }); + Object.defineProperties(Response, { + json: kEnumerableProperty, + redirect: kEnumerableProperty, + error: kEnumerableProperty + }); + function cloneResponse(response) { + if (response.internalResponse) return filterResponse(cloneResponse(response.internalResponse), response.type); + const newResponse = makeResponse({ + ...response, + body: null + }); + if (response.body != null) newResponse.body = cloneBody(newResponse, response.body); + return newResponse; + } + function makeResponse(init) { + return { + aborted: false, + rangeRequested: false, + timingAllowPassed: false, + requestIncludesCredentials: false, + type: "default", + status: 200, + timingInfo: null, + cacheState: "", + statusText: "", + ...init, + headersList: init?.headersList ? new HeadersList(init?.headersList) : new HeadersList(), + urlList: init?.urlList ? [...init.urlList] : [] + }; + } + function makeNetworkError(reason) { + return makeResponse({ + type: "error", + status: 0, + error: isErrorLike(reason) ? reason : new Error(reason ? String(reason) : reason), + aborted: reason && reason.name === "AbortError" + }); + } + function isNetworkError(response) { + return response.type === "error" && response.status === 0; + } + function makeFilteredResponse(response, state) { + state = { + internalResponse: response, + ...state + }; + return new Proxy(response, { + get(target, p) { + return p in state ? state[p] : target[p]; + }, + set(target, p, value) { + assert$6(!(p in state)); + target[p] = value; + return true; + } + }); + } + function filterResponse(response, type) { + if (type === "basic") return makeFilteredResponse(response, { + type: "basic", + headersList: response.headersList + }); + else if (type === "cors") return makeFilteredResponse(response, { + type: "cors", + headersList: response.headersList + }); + else if (type === "opaque") return makeFilteredResponse(response, { + type: "opaque", + urlList: Object.freeze([]), + status: 0, + statusText: "", + body: null + }); + else if (type === "opaqueredirect") return makeFilteredResponse(response, { + type: "opaqueredirect", + status: 0, + statusText: "", + headersList: [], + body: null + }); + else assert$6(false); + } + function makeAppropriateNetworkError(fetchParams, err = null) { + assert$6(isCancelled(fetchParams)); + return isAborted(fetchParams) ? makeNetworkError(Object.assign(new DOMException("The operation was aborted.", "AbortError"), { cause: err })) : makeNetworkError(Object.assign(new DOMException("Request was cancelled."), { cause: err })); + } + function initializeResponse(response, init, body) { + if (init.status !== null && (init.status < 200 || init.status > 599)) throw new RangeError("init[\"status\"] must be in the range of 200 to 599, inclusive."); + if ("statusText" in init && init.statusText != null) { + if (!isValidReasonPhrase(String(init.statusText))) throw new TypeError("Invalid statusText"); + } + if ("status" in init && init.status != null) response[kState].status = init.status; + if ("statusText" in init && init.statusText != null) response[kState].statusText = init.statusText; + if ("headers" in init && init.headers != null) fill(response[kHeaders], init.headers); + if (body) { + if (nullBodyStatus.includes(response.status)) throw webidl.errors.exception({ + header: "Response constructor", + message: `Invalid response status code ${response.status}` + }); + response[kState].body = body.body; + if (body.type != null && !response[kState].headersList.contains("content-type", true)) response[kState].headersList.append("content-type", body.type, true); + } + } + /** + * @see https://fetch.spec.whatwg.org/#response-create + * @param {any} innerResponse + * @param {'request' | 'immutable' | 'request-no-cors' | 'response' | 'none'} guard + * @returns {Response} + */ + function fromInnerResponse(innerResponse, guard) { + const response = new Response(kConstruct); + response[kState] = innerResponse; + response[kHeaders] = new Headers(kConstruct); + setHeadersList(response[kHeaders], innerResponse.headersList); + setHeadersGuard(response[kHeaders], guard); + if (hasFinalizationRegistry && innerResponse.body?.stream) streamRegistry.register(response, new WeakRef(innerResponse.body.stream)); + return response; + } + webidl.converters.ReadableStream = webidl.interfaceConverter(ReadableStream); + webidl.converters.FormData = webidl.interfaceConverter(FormData); + webidl.converters.URLSearchParams = webidl.interfaceConverter(URLSearchParams); + webidl.converters.XMLHttpRequestBodyInit = function(V, prefix, name) { + if (typeof V === "string") return webidl.converters.USVString(V, prefix, name); + if (isBlobLike(V)) return webidl.converters.Blob(V, prefix, name, { strict: false }); + if (ArrayBuffer.isView(V) || types$2.isArrayBuffer(V)) return webidl.converters.BufferSource(V, prefix, name); + if (util.isFormDataLike(V)) return webidl.converters.FormData(V, prefix, name, { strict: false }); + if (V instanceof URLSearchParams) return webidl.converters.URLSearchParams(V, prefix, name); + return webidl.converters.DOMString(V, prefix, name); + }; + webidl.converters.BodyInit = function(V, prefix, argument) { + if (V instanceof ReadableStream) return webidl.converters.ReadableStream(V, prefix, argument); + if (V?.[Symbol.asyncIterator]) return V; + return webidl.converters.XMLHttpRequestBodyInit(V, prefix, argument); + }; + webidl.converters.ResponseInit = webidl.dictionaryConverter([ + { + key: "status", + converter: webidl.converters["unsigned short"], + defaultValue: () => 200 + }, + { + key: "statusText", + converter: webidl.converters.ByteString, + defaultValue: () => "" + }, + { + key: "headers", + converter: webidl.converters.HeadersInit + } + ]); + module.exports = { + isNetworkError, + makeNetworkError, + makeResponse, + makeAppropriateNetworkError, + filterResponse, + Response, + cloneResponse, + fromInnerResponse + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fetch/dispatcher-weakref.js +var require_dispatcher_weakref = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { kConnected, kSize } = require_symbols$4(); + var CompatWeakRef = class { + constructor(value) { + this.value = value; + } + deref() { + return this.value[kConnected] === 0 && this.value[kSize] === 0 ? void 0 : this.value; + } + }; + var CompatFinalizer = class { + constructor(finalizer) { + this.finalizer = finalizer; + } + register(dispatcher, key) { + if (dispatcher.on) dispatcher.on("disconnect", () => { + if (dispatcher[kConnected] === 0 && dispatcher[kSize] === 0) this.finalizer(key); + }); + } + unregister(key) {} + }; + module.exports = function() { + if (process.env.NODE_V8_COVERAGE && process.version.startsWith("v18")) { + process._rawDebug("Using compatibility WeakRef and FinalizationRegistry"); + return { + WeakRef: CompatWeakRef, + FinalizationRegistry: CompatFinalizer + }; + } + return { + WeakRef, + FinalizationRegistry + }; + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fetch/request.js +var require_request = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { extractBody, mixinBody, cloneBody, bodyUnusable } = require_body(); + const { Headers, fill: fillHeaders, HeadersList, setHeadersGuard, getHeadersGuard, setHeadersList, getHeadersList } = require_headers(); + const { FinalizationRegistry } = require_dispatcher_weakref()(); + const util = require_util$7(); + const nodeUtil = __require("node:util"); + const { isValidHTTPToken, sameOrigin, environmentSettingsObject } = require_util$6(); + const { forbiddenMethodsSet, corsSafeListedMethodsSet, referrerPolicy, requestRedirect, requestMode, requestCredentials, requestCache, requestDuplex } = require_constants$2(); + const { kEnumerableProperty, normalizedMethodRecordsBase, normalizedMethodRecords } = util; + const { kHeaders, kSignal, kState, kDispatcher } = require_symbols$3(); + const { webidl } = require_webidl(); + const { URLSerializer } = require_data_url(); + const { kConstruct } = require_symbols$4(); + const assert$5 = __require("node:assert"); + const { getMaxListeners, setMaxListeners, getEventListeners, defaultMaxListeners } = __require("node:events"); + const kAbortController = Symbol("abortController"); + const requestFinalizer = new FinalizationRegistry(({ signal, abort }) => { + signal.removeEventListener("abort", abort); + }); + const dependentControllerMap = /* @__PURE__ */ new WeakMap(); + function buildAbort(acRef) { + return abort; + function abort() { + const ac = acRef.deref(); + if (ac !== void 0) { + requestFinalizer.unregister(abort); + this.removeEventListener("abort", abort); + ac.abort(this.reason); + const controllerList = dependentControllerMap.get(ac.signal); + if (controllerList !== void 0) { + if (controllerList.size !== 0) { + for (const ref of controllerList) { + const ctrl = ref.deref(); + if (ctrl !== void 0) ctrl.abort(this.reason); + } + controllerList.clear(); + } + dependentControllerMap.delete(ac.signal); + } + } + } + } + let patchMethodWarning = false; + var Request = class Request { + constructor(input, init = {}) { + webidl.util.markAsUncloneable(this); + if (input === kConstruct) return; + const prefix = "Request constructor"; + webidl.argumentLengthCheck(arguments, 1, prefix); + input = webidl.converters.RequestInfo(input, prefix, "input"); + init = webidl.converters.RequestInit(init, prefix, "init"); + let request = null; + let fallbackMode = null; + const baseUrl = environmentSettingsObject.settingsObject.baseUrl; + let signal = null; + if (typeof input === "string") { + this[kDispatcher] = init.dispatcher; + let parsedURL; + try { + parsedURL = new URL(input, baseUrl); + } catch (err) { + throw new TypeError("Failed to parse URL from " + input, { cause: err }); + } + if (parsedURL.username || parsedURL.password) throw new TypeError("Request cannot be constructed from a URL that includes credentials: " + input); + request = makeRequest({ urlList: [parsedURL] }); + fallbackMode = "cors"; + } else { + this[kDispatcher] = init.dispatcher || input[kDispatcher]; + assert$5(input instanceof Request); + request = input[kState]; + signal = input[kSignal]; + } + const origin = environmentSettingsObject.settingsObject.origin; + let window = "client"; + if (request.window?.constructor?.name === "EnvironmentSettingsObject" && sameOrigin(request.window, origin)) window = request.window; + if (init.window != null) throw new TypeError(`'window' option '${window}' must be null`); + if ("window" in init) window = "no-window"; + request = makeRequest({ + method: request.method, + headersList: request.headersList, + unsafeRequest: request.unsafeRequest, + client: environmentSettingsObject.settingsObject, + window, + priority: request.priority, + origin: request.origin, + referrer: request.referrer, + referrerPolicy: request.referrerPolicy, + mode: request.mode, + credentials: request.credentials, + cache: request.cache, + redirect: request.redirect, + integrity: request.integrity, + keepalive: request.keepalive, + reloadNavigation: request.reloadNavigation, + historyNavigation: request.historyNavigation, + urlList: [...request.urlList] + }); + const initHasKey = Object.keys(init).length !== 0; + if (initHasKey) { + if (request.mode === "navigate") request.mode = "same-origin"; + request.reloadNavigation = false; + request.historyNavigation = false; + request.origin = "client"; + request.referrer = "client"; + request.referrerPolicy = ""; + request.url = request.urlList[request.urlList.length - 1]; + request.urlList = [request.url]; + } + if (init.referrer !== void 0) { + const referrer = init.referrer; + if (referrer === "") request.referrer = "no-referrer"; + else { + let parsedReferrer; + try { + parsedReferrer = new URL(referrer, baseUrl); + } catch (err) { + throw new TypeError(`Referrer "${referrer}" is not a valid URL.`, { cause: err }); + } + if (parsedReferrer.protocol === "about:" && parsedReferrer.hostname === "client" || origin && !sameOrigin(parsedReferrer, environmentSettingsObject.settingsObject.baseUrl)) request.referrer = "client"; + else request.referrer = parsedReferrer; + } + } + if (init.referrerPolicy !== void 0) request.referrerPolicy = init.referrerPolicy; + let mode; + if (init.mode !== void 0) mode = init.mode; + else mode = fallbackMode; + if (mode === "navigate") throw webidl.errors.exception({ + header: "Request constructor", + message: "invalid request mode navigate." + }); + if (mode != null) request.mode = mode; + if (init.credentials !== void 0) request.credentials = init.credentials; + if (init.cache !== void 0) request.cache = init.cache; + if (request.cache === "only-if-cached" && request.mode !== "same-origin") throw new TypeError("'only-if-cached' can be set only with 'same-origin' mode"); + if (init.redirect !== void 0) request.redirect = init.redirect; + if (init.integrity != null) request.integrity = String(init.integrity); + if (init.keepalive !== void 0) request.keepalive = Boolean(init.keepalive); + if (init.method !== void 0) { + let method = init.method; + const mayBeNormalized = normalizedMethodRecords[method]; + if (mayBeNormalized !== void 0) request.method = mayBeNormalized; + else { + if (!isValidHTTPToken(method)) throw new TypeError(`'${method}' is not a valid HTTP method.`); + const upperCase = method.toUpperCase(); + if (forbiddenMethodsSet.has(upperCase)) throw new TypeError(`'${method}' HTTP method is unsupported.`); + method = normalizedMethodRecordsBase[upperCase] ?? method; + request.method = method; + } + if (!patchMethodWarning && request.method === "patch") { + process.emitWarning("Using `patch` is highly likely to result in a `405 Method Not Allowed`. `PATCH` is much more likely to succeed.", { code: "UNDICI-FETCH-patch" }); + patchMethodWarning = true; + } + } + if (init.signal !== void 0) signal = init.signal; + this[kState] = request; + const ac = new AbortController(); + this[kSignal] = ac.signal; + if (signal != null) { + if (!signal || typeof signal.aborted !== "boolean" || typeof signal.addEventListener !== "function") throw new TypeError("Failed to construct 'Request': member signal is not of type AbortSignal."); + if (signal.aborted) ac.abort(signal.reason); + else { + this[kAbortController] = ac; + const abort = buildAbort(new WeakRef(ac)); + try { + if (typeof getMaxListeners === "function" && getMaxListeners(signal) === defaultMaxListeners) setMaxListeners(1500, signal); + else if (getEventListeners(signal, "abort").length >= defaultMaxListeners) setMaxListeners(1500, signal); + } catch {} + util.addAbortListener(signal, abort); + requestFinalizer.register(ac, { + signal, + abort + }, abort); + } + } + this[kHeaders] = new Headers(kConstruct); + setHeadersList(this[kHeaders], request.headersList); + setHeadersGuard(this[kHeaders], "request"); + if (mode === "no-cors") { + if (!corsSafeListedMethodsSet.has(request.method)) throw new TypeError(`'${request.method} is unsupported in no-cors mode.`); + setHeadersGuard(this[kHeaders], "request-no-cors"); + } + if (initHasKey) { + /** @type {HeadersList} */ + const headersList = getHeadersList(this[kHeaders]); + const headers = init.headers !== void 0 ? init.headers : new HeadersList(headersList); + headersList.clear(); + if (headers instanceof HeadersList) { + for (const { name, value } of headers.rawValues()) headersList.append(name, value, false); + headersList.cookies = headers.cookies; + } else fillHeaders(this[kHeaders], headers); + } + const inputBody = input instanceof Request ? input[kState].body : null; + if ((init.body != null || inputBody != null) && (request.method === "GET" || request.method === "HEAD")) throw new TypeError("Request with GET/HEAD method cannot have body."); + let initBody = null; + if (init.body != null) { + const [extractedBody, contentType] = extractBody(init.body, request.keepalive); + initBody = extractedBody; + if (contentType && !getHeadersList(this[kHeaders]).contains("content-type", true)) this[kHeaders].append("content-type", contentType); + } + const inputOrInitBody = initBody ?? inputBody; + if (inputOrInitBody != null && inputOrInitBody.source == null) { + if (initBody != null && init.duplex == null) throw new TypeError("RequestInit: duplex option is required when sending a body."); + if (request.mode !== "same-origin" && request.mode !== "cors") throw new TypeError("If request is made from ReadableStream, mode should be \"same-origin\" or \"cors\""); + request.useCORSPreflightFlag = true; + } + let finalBody = inputOrInitBody; + if (initBody == null && inputBody != null) { + if (bodyUnusable(input)) throw new TypeError("Cannot construct a Request with a Request object that has already been used."); + const identityTransform = new TransformStream(); + inputBody.stream.pipeThrough(identityTransform); + finalBody = { + source: inputBody.source, + length: inputBody.length, + stream: identityTransform.readable + }; + } + this[kState].body = finalBody; + } + get method() { + webidl.brandCheck(this, Request); + return this[kState].method; + } + get url() { + webidl.brandCheck(this, Request); + return URLSerializer(this[kState].url); + } + get headers() { + webidl.brandCheck(this, Request); + return this[kHeaders]; + } + get destination() { + webidl.brandCheck(this, Request); + return this[kState].destination; + } + get referrer() { + webidl.brandCheck(this, Request); + if (this[kState].referrer === "no-referrer") return ""; + if (this[kState].referrer === "client") return "about:client"; + return this[kState].referrer.toString(); + } + get referrerPolicy() { + webidl.brandCheck(this, Request); + return this[kState].referrerPolicy; + } + get mode() { + webidl.brandCheck(this, Request); + return this[kState].mode; + } + get credentials() { + return this[kState].credentials; + } + get cache() { + webidl.brandCheck(this, Request); + return this[kState].cache; + } + get redirect() { + webidl.brandCheck(this, Request); + return this[kState].redirect; + } + get integrity() { + webidl.brandCheck(this, Request); + return this[kState].integrity; + } + get keepalive() { + webidl.brandCheck(this, Request); + return this[kState].keepalive; + } + get isReloadNavigation() { + webidl.brandCheck(this, Request); + return this[kState].reloadNavigation; + } + get isHistoryNavigation() { + webidl.brandCheck(this, Request); + return this[kState].historyNavigation; + } + get signal() { + webidl.brandCheck(this, Request); + return this[kSignal]; + } + get body() { + webidl.brandCheck(this, Request); + return this[kState].body ? this[kState].body.stream : null; + } + get bodyUsed() { + webidl.brandCheck(this, Request); + return !!this[kState].body && util.isDisturbed(this[kState].body.stream); + } + get duplex() { + webidl.brandCheck(this, Request); + return "half"; + } + clone() { + webidl.brandCheck(this, Request); + if (bodyUnusable(this)) throw new TypeError("unusable"); + const clonedRequest = cloneRequest(this[kState]); + const ac = new AbortController(); + if (this.signal.aborted) ac.abort(this.signal.reason); + else { + let list = dependentControllerMap.get(this.signal); + if (list === void 0) { + list = /* @__PURE__ */ new Set(); + dependentControllerMap.set(this.signal, list); + } + const acRef = new WeakRef(ac); + list.add(acRef); + util.addAbortListener(ac.signal, buildAbort(acRef)); + } + return fromInnerRequest(clonedRequest, ac.signal, getHeadersGuard(this[kHeaders])); + } + [nodeUtil.inspect.custom](depth, options) { + if (options.depth === null) options.depth = 2; + options.colors ??= true; + const properties = { + method: this.method, + url: this.url, + headers: this.headers, + destination: this.destination, + referrer: this.referrer, + referrerPolicy: this.referrerPolicy, + mode: this.mode, + credentials: this.credentials, + cache: this.cache, + redirect: this.redirect, + integrity: this.integrity, + keepalive: this.keepalive, + isReloadNavigation: this.isReloadNavigation, + isHistoryNavigation: this.isHistoryNavigation, + signal: this.signal + }; + return `Request ${nodeUtil.formatWithOptions(options, properties)}`; + } + }; + mixinBody(Request); + function makeRequest(init) { + return { + method: init.method ?? "GET", + localURLsOnly: init.localURLsOnly ?? false, + unsafeRequest: init.unsafeRequest ?? false, + body: init.body ?? null, + client: init.client ?? null, + reservedClient: init.reservedClient ?? null, + replacesClientId: init.replacesClientId ?? "", + window: init.window ?? "client", + keepalive: init.keepalive ?? false, + serviceWorkers: init.serviceWorkers ?? "all", + initiator: init.initiator ?? "", + destination: init.destination ?? "", + priority: init.priority ?? null, + origin: init.origin ?? "client", + policyContainer: init.policyContainer ?? "client", + referrer: init.referrer ?? "client", + referrerPolicy: init.referrerPolicy ?? "", + mode: init.mode ?? "no-cors", + useCORSPreflightFlag: init.useCORSPreflightFlag ?? false, + credentials: init.credentials ?? "same-origin", + useCredentials: init.useCredentials ?? false, + cache: init.cache ?? "default", + redirect: init.redirect ?? "follow", + integrity: init.integrity ?? "", + cryptoGraphicsNonceMetadata: init.cryptoGraphicsNonceMetadata ?? "", + parserMetadata: init.parserMetadata ?? "", + reloadNavigation: init.reloadNavigation ?? false, + historyNavigation: init.historyNavigation ?? false, + userActivation: init.userActivation ?? false, + taintedOrigin: init.taintedOrigin ?? false, + redirectCount: init.redirectCount ?? 0, + responseTainting: init.responseTainting ?? "basic", + preventNoCacheCacheControlHeaderModification: init.preventNoCacheCacheControlHeaderModification ?? false, + done: init.done ?? false, + timingAllowFailed: init.timingAllowFailed ?? false, + urlList: init.urlList, + url: init.urlList[0], + headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList() + }; + } + function cloneRequest(request) { + const newRequest = makeRequest({ + ...request, + body: null + }); + if (request.body != null) newRequest.body = cloneBody(newRequest, request.body); + return newRequest; + } + /** + * @see https://fetch.spec.whatwg.org/#request-create + * @param {any} innerRequest + * @param {AbortSignal} signal + * @param {'request' | 'immutable' | 'request-no-cors' | 'response' | 'none'} guard + * @returns {Request} + */ + function fromInnerRequest(innerRequest, signal, guard) { + const request = new Request(kConstruct); + request[kState] = innerRequest; + request[kSignal] = signal; + request[kHeaders] = new Headers(kConstruct); + setHeadersList(request[kHeaders], innerRequest.headersList); + setHeadersGuard(request[kHeaders], guard); + return request; + } + Object.defineProperties(Request.prototype, { + method: kEnumerableProperty, + url: kEnumerableProperty, + headers: kEnumerableProperty, + redirect: kEnumerableProperty, + clone: kEnumerableProperty, + signal: kEnumerableProperty, + duplex: kEnumerableProperty, + destination: kEnumerableProperty, + body: kEnumerableProperty, + bodyUsed: kEnumerableProperty, + isHistoryNavigation: kEnumerableProperty, + isReloadNavigation: kEnumerableProperty, + keepalive: kEnumerableProperty, + integrity: kEnumerableProperty, + cache: kEnumerableProperty, + credentials: kEnumerableProperty, + attribute: kEnumerableProperty, + referrerPolicy: kEnumerableProperty, + referrer: kEnumerableProperty, + mode: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "Request", + configurable: true + } + }); + webidl.converters.Request = webidl.interfaceConverter(Request); + webidl.converters.RequestInfo = function(V, prefix, argument) { + if (typeof V === "string") return webidl.converters.USVString(V, prefix, argument); + if (V instanceof Request) return webidl.converters.Request(V, prefix, argument); + return webidl.converters.USVString(V, prefix, argument); + }; + webidl.converters.AbortSignal = webidl.interfaceConverter(AbortSignal); + webidl.converters.RequestInit = webidl.dictionaryConverter([ + { + key: "method", + converter: webidl.converters.ByteString + }, + { + key: "headers", + converter: webidl.converters.HeadersInit + }, + { + key: "body", + converter: webidl.nullableConverter(webidl.converters.BodyInit) + }, + { + key: "referrer", + converter: webidl.converters.USVString + }, + { + key: "referrerPolicy", + converter: webidl.converters.DOMString, + allowedValues: referrerPolicy + }, + { + key: "mode", + converter: webidl.converters.DOMString, + allowedValues: requestMode + }, + { + key: "credentials", + converter: webidl.converters.DOMString, + allowedValues: requestCredentials + }, + { + key: "cache", + converter: webidl.converters.DOMString, + allowedValues: requestCache + }, + { + key: "redirect", + converter: webidl.converters.DOMString, + allowedValues: requestRedirect + }, + { + key: "integrity", + converter: webidl.converters.DOMString + }, + { + key: "keepalive", + converter: webidl.converters.boolean + }, + { + key: "signal", + converter: webidl.nullableConverter((signal) => webidl.converters.AbortSignal(signal, "RequestInit", "signal", { strict: false })) + }, + { + key: "window", + converter: webidl.converters.any + }, + { + key: "duplex", + converter: webidl.converters.DOMString, + allowedValues: requestDuplex + }, + { + key: "dispatcher", + converter: webidl.converters.any + } + ]); + module.exports = { + Request, + makeRequest, + fromInnerRequest, + cloneRequest + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fetch/index.js +var require_fetch = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { makeNetworkError, makeAppropriateNetworkError, filterResponse, makeResponse, fromInnerResponse } = require_response(); + const { HeadersList } = require_headers(); + const { Request, cloneRequest } = require_request(); + const zlib = __require("node:zlib"); + const { bytesMatch, makePolicyContainer, clonePolicyContainer, requestBadPort, TAOCheck, appendRequestOriginHeader, responseLocationURL, requestCurrentURL, setRequestReferrerPolicyOnRedirect, tryUpgradeRequestToAPotentiallyTrustworthyURL, createOpaqueTimingInfo, appendFetchMetadata, corsCheck, crossOriginResourcePolicyCheck, determineRequestsReferrer, coarsenedSharedCurrentTime, createDeferredPromise, isBlobLike, sameOrigin, isCancelled, isAborted, isErrorLike, fullyReadBody, readableStreamClose, isomorphicEncode, urlIsLocal, urlIsHttpHttpsScheme, urlHasHttpsScheme, clampAndCoarsenConnectionTimingInfo, simpleRangeHeaderValue, buildContentRange, createInflate, extractMimeType } = require_util$6(); + const { kState, kDispatcher } = require_symbols$3(); + const assert$4 = __require("node:assert"); + const { safelyExtractBody, extractBody } = require_body(); + const { redirectStatusSet, nullBodyStatus, safeMethodsSet, requestBodyHeader, subresourceSet } = require_constants$2(); + const EE = __require("node:events"); + const { Readable, pipeline: pipeline$1, finished } = __require("node:stream"); + const { addAbortListener, isErrored, isReadable, bufferToLowerCasedHeaderName } = require_util$7(); + const { dataURLProcessor, serializeAMimeType, minimizeSupportedMimeType } = require_data_url(); + const { getGlobalDispatcher } = require_global(); + const { webidl } = require_webidl(); + const { STATUS_CODES } = __require("node:http"); + const GET_OR_HEAD = ["GET", "HEAD"]; + const defaultUserAgent = typeof __UNDICI_IS_NODE__ !== "undefined" || typeof esbuildDetection !== "undefined" ? "node" : "undici"; + /** @type {import('buffer').resolveObjectURL} */ + let resolveObjectURL; + var Fetch = class extends EE { + constructor(dispatcher) { + super(); + this.dispatcher = dispatcher; + this.connection = null; + this.dump = false; + this.state = "ongoing"; + } + terminate(reason) { + if (this.state !== "ongoing") return; + this.state = "terminated"; + this.connection?.destroy(reason); + this.emit("terminated", reason); + } + abort(error) { + if (this.state !== "ongoing") return; + this.state = "aborted"; + if (!error) error = new DOMException("The operation was aborted.", "AbortError"); + this.serializedAbortReason = error; + this.connection?.destroy(error); + this.emit("terminated", error); + } + }; + function handleFetchDone(response) { + finalizeAndReportTiming(response, "fetch"); + } + function fetch(input, init = void 0) { + webidl.argumentLengthCheck(arguments, 1, "globalThis.fetch"); + let p = createDeferredPromise(); + let requestObject; + try { + requestObject = new Request(input, init); + } catch (e) { + p.reject(e); + return p.promise; + } + const request = requestObject[kState]; + if (requestObject.signal.aborted) { + abortFetch(p, request, null, requestObject.signal.reason); + return p.promise; + } + if (request.client.globalObject?.constructor?.name === "ServiceWorkerGlobalScope") request.serviceWorkers = "none"; + let responseObject = null; + let locallyAborted = false; + let controller = null; + addAbortListener(requestObject.signal, () => { + locallyAborted = true; + assert$4(controller != null); + controller.abort(requestObject.signal.reason); + const realResponse = responseObject?.deref(); + abortFetch(p, request, realResponse, requestObject.signal.reason); + }); + const processResponse = (response) => { + if (locallyAborted) return; + if (response.aborted) { + abortFetch(p, request, responseObject, controller.serializedAbortReason); + return; + } + if (response.type === "error") { + p.reject(new TypeError("fetch failed", { cause: response.error })); + return; + } + responseObject = new WeakRef(fromInnerResponse(response, "immutable")); + p.resolve(responseObject.deref()); + p = null; + }; + controller = fetching({ + request, + processResponseEndOfBody: handleFetchDone, + processResponse, + dispatcher: requestObject[kDispatcher] + }); + return p.promise; + } + function finalizeAndReportTiming(response, initiatorType = "other") { + if (response.type === "error" && response.aborted) return; + if (!response.urlList?.length) return; + const originalURL = response.urlList[0]; + let timingInfo = response.timingInfo; + let cacheState = response.cacheState; + if (!urlIsHttpHttpsScheme(originalURL)) return; + if (timingInfo === null) return; + if (!response.timingAllowPassed) { + timingInfo = createOpaqueTimingInfo({ startTime: timingInfo.startTime }); + cacheState = ""; + } + timingInfo.endTime = coarsenedSharedCurrentTime(); + response.timingInfo = timingInfo; + markResourceTiming(timingInfo, originalURL.href, initiatorType, globalThis, cacheState); + } + const markResourceTiming = performance.markResourceTiming; + function abortFetch(p, request, responseObject, error) { + if (p) p.reject(error); + if (request.body != null && isReadable(request.body?.stream)) request.body.stream.cancel(error).catch((err) => { + if (err.code === "ERR_INVALID_STATE") return; + throw err; + }); + if (responseObject == null) return; + const response = responseObject[kState]; + if (response.body != null && isReadable(response.body?.stream)) response.body.stream.cancel(error).catch((err) => { + if (err.code === "ERR_INVALID_STATE") return; + throw err; + }); + } + function fetching({ request, processRequestBodyChunkLength, processRequestEndOfBody, processResponse, processResponseEndOfBody, processResponseConsumeBody, useParallelQueue = false, dispatcher = getGlobalDispatcher() }) { + assert$4(dispatcher); + let taskDestination = null; + let crossOriginIsolatedCapability = false; + if (request.client != null) { + taskDestination = request.client.globalObject; + crossOriginIsolatedCapability = request.client.crossOriginIsolatedCapability; + } + const currentTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability); + const timingInfo = createOpaqueTimingInfo({ startTime: currentTime }); + const fetchParams = { + controller: new Fetch(dispatcher), + request, + timingInfo, + processRequestBodyChunkLength, + processRequestEndOfBody, + processResponse, + processResponseConsumeBody, + processResponseEndOfBody, + taskDestination, + crossOriginIsolatedCapability + }; + assert$4(!request.body || request.body.stream); + if (request.window === "client") request.window = request.client?.globalObject?.constructor?.name === "Window" ? request.client : "no-window"; + if (request.origin === "client") request.origin = request.client.origin; + if (request.policyContainer === "client") { + if (request.client != null) request.policyContainer = clonePolicyContainer(request.client.policyContainer); + else request.policyContainer = makePolicyContainer(); + } + if (!request.headersList.contains("accept", true)) request.headersList.append("accept", "*/*", true); + if (!request.headersList.contains("accept-language", true)) request.headersList.append("accept-language", "*", true); + if (request.priority === null) {} + if (subresourceSet.has(request.destination)) {} + mainFetch(fetchParams).catch((err) => { + fetchParams.controller.terminate(err); + }); + return fetchParams.controller; + } + async function mainFetch(fetchParams, recursive = false) { + const request = fetchParams.request; + let response = null; + if (request.localURLsOnly && !urlIsLocal(requestCurrentURL(request))) response = makeNetworkError("local URLs only"); + tryUpgradeRequestToAPotentiallyTrustworthyURL(request); + if (requestBadPort(request) === "blocked") response = makeNetworkError("bad port"); + if (request.referrerPolicy === "") request.referrerPolicy = request.policyContainer.referrerPolicy; + if (request.referrer !== "no-referrer") request.referrer = determineRequestsReferrer(request); + if (response === null) response = await (async () => { + const currentURL = requestCurrentURL(request); + if (sameOrigin(currentURL, request.url) && request.responseTainting === "basic" || currentURL.protocol === "data:" || request.mode === "navigate" || request.mode === "websocket") { + request.responseTainting = "basic"; + return await schemeFetch(fetchParams); + } + if (request.mode === "same-origin") return makeNetworkError("request mode cannot be \"same-origin\""); + if (request.mode === "no-cors") { + if (request.redirect !== "follow") return makeNetworkError("redirect mode cannot be \"follow\" for \"no-cors\" request"); + request.responseTainting = "opaque"; + return await schemeFetch(fetchParams); + } + if (!urlIsHttpHttpsScheme(requestCurrentURL(request))) return makeNetworkError("URL scheme must be a HTTP(S) scheme"); + request.responseTainting = "cors"; + return await httpFetch(fetchParams); + })(); + if (recursive) return response; + if (response.status !== 0 && !response.internalResponse) { + if (request.responseTainting === "cors") {} + if (request.responseTainting === "basic") response = filterResponse(response, "basic"); + else if (request.responseTainting === "cors") response = filterResponse(response, "cors"); + else if (request.responseTainting === "opaque") response = filterResponse(response, "opaque"); + else assert$4(false); + } + let internalResponse = response.status === 0 ? response : response.internalResponse; + if (internalResponse.urlList.length === 0) internalResponse.urlList.push(...request.urlList); + if (!request.timingAllowFailed) response.timingAllowPassed = true; + if (response.type === "opaque" && internalResponse.status === 206 && internalResponse.rangeRequested && !request.headers.contains("range", true)) response = internalResponse = makeNetworkError(); + if (response.status !== 0 && (request.method === "HEAD" || request.method === "CONNECT" || nullBodyStatus.includes(internalResponse.status))) { + internalResponse.body = null; + fetchParams.controller.dump = true; + } + if (request.integrity) { + const processBodyError = (reason) => fetchFinale(fetchParams, makeNetworkError(reason)); + if (request.responseTainting === "opaque" || response.body == null) { + processBodyError(response.error); + return; + } + const processBody = (bytes) => { + if (!bytesMatch(bytes, request.integrity)) { + processBodyError("integrity mismatch"); + return; + } + response.body = safelyExtractBody(bytes)[0]; + fetchFinale(fetchParams, response); + }; + await fullyReadBody(response.body, processBody, processBodyError); + } else fetchFinale(fetchParams, response); + } + function schemeFetch(fetchParams) { + if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) return Promise.resolve(makeAppropriateNetworkError(fetchParams)); + const { request } = fetchParams; + const { protocol: scheme } = requestCurrentURL(request); + switch (scheme) { + case "about:": return Promise.resolve(makeNetworkError("about scheme is not supported")); + case "blob:": { + if (!resolveObjectURL) resolveObjectURL = __require("node:buffer").resolveObjectURL; + const blobURLEntry = requestCurrentURL(request); + if (blobURLEntry.search.length !== 0) return Promise.resolve(makeNetworkError("NetworkError when attempting to fetch resource.")); + const blob = resolveObjectURL(blobURLEntry.toString()); + if (request.method !== "GET" || !isBlobLike(blob)) return Promise.resolve(makeNetworkError("invalid method")); + const response = makeResponse(); + const fullLength = blob.size; + const serializedFullLength = isomorphicEncode(`${fullLength}`); + const type = blob.type; + if (!request.headersList.contains("range", true)) { + const bodyWithType = extractBody(blob); + response.statusText = "OK"; + response.body = bodyWithType[0]; + response.headersList.set("content-length", serializedFullLength, true); + response.headersList.set("content-type", type, true); + } else { + response.rangeRequested = true; + const rangeHeader = request.headersList.get("range", true); + const rangeValue = simpleRangeHeaderValue(rangeHeader, true); + if (rangeValue === "failure") return Promise.resolve(makeNetworkError("failed to fetch the data URL")); + let { rangeStartValue: rangeStart, rangeEndValue: rangeEnd } = rangeValue; + if (rangeStart === null) { + rangeStart = fullLength - rangeEnd; + rangeEnd = rangeStart + rangeEnd - 1; + } else { + if (rangeStart >= fullLength) return Promise.resolve(makeNetworkError("Range start is greater than the blob's size.")); + if (rangeEnd === null || rangeEnd >= fullLength) rangeEnd = fullLength - 1; + } + const slicedBlob = blob.slice(rangeStart, rangeEnd, type); + response.body = extractBody(slicedBlob)[0]; + const serializedSlicedLength = isomorphicEncode(`${slicedBlob.size}`); + const contentRange = buildContentRange(rangeStart, rangeEnd, fullLength); + response.status = 206; + response.statusText = "Partial Content"; + response.headersList.set("content-length", serializedSlicedLength, true); + response.headersList.set("content-type", type, true); + response.headersList.set("content-range", contentRange, true); + } + return Promise.resolve(response); + } + case "data:": { + const currentURL = requestCurrentURL(request); + const dataURLStruct = dataURLProcessor(currentURL); + if (dataURLStruct === "failure") return Promise.resolve(makeNetworkError("failed to fetch the data URL")); + const mimeType = serializeAMimeType(dataURLStruct.mimeType); + return Promise.resolve(makeResponse({ + statusText: "OK", + headersList: [["content-type", { + name: "Content-Type", + value: mimeType + }]], + body: safelyExtractBody(dataURLStruct.body)[0] + })); + } + case "file:": return Promise.resolve(makeNetworkError("not implemented... yet...")); + case "http:": + case "https:": return httpFetch(fetchParams).catch((err) => makeNetworkError(err)); + default: return Promise.resolve(makeNetworkError("unknown scheme")); + } + } + function finalizeResponse(fetchParams, response) { + fetchParams.request.done = true; + if (fetchParams.processResponseDone != null) queueMicrotask(() => fetchParams.processResponseDone(response)); + } + function fetchFinale(fetchParams, response) { + let timingInfo = fetchParams.timingInfo; + const processResponseEndOfBody = () => { + const unsafeEndTime = Date.now(); + if (fetchParams.request.destination === "document") fetchParams.controller.fullTimingInfo = timingInfo; + fetchParams.controller.reportTimingSteps = () => { + if (fetchParams.request.url.protocol !== "https:") return; + timingInfo.endTime = unsafeEndTime; + let cacheState = response.cacheState; + const bodyInfo = response.bodyInfo; + if (!response.timingAllowPassed) { + timingInfo = createOpaqueTimingInfo(timingInfo); + cacheState = ""; + } + let responseStatus = 0; + if (fetchParams.request.mode !== "navigator" || !response.hasCrossOriginRedirects) { + responseStatus = response.status; + const mimeType = extractMimeType(response.headersList); + if (mimeType !== "failure") bodyInfo.contentType = minimizeSupportedMimeType(mimeType); + } + if (fetchParams.request.initiatorType != null) markResourceTiming(timingInfo, fetchParams.request.url.href, fetchParams.request.initiatorType, globalThis, cacheState, bodyInfo, responseStatus); + }; + const processResponseEndOfBodyTask = () => { + fetchParams.request.done = true; + if (fetchParams.processResponseEndOfBody != null) queueMicrotask(() => fetchParams.processResponseEndOfBody(response)); + if (fetchParams.request.initiatorType != null) fetchParams.controller.reportTimingSteps(); + }; + queueMicrotask(() => processResponseEndOfBodyTask()); + }; + if (fetchParams.processResponse != null) queueMicrotask(() => { + fetchParams.processResponse(response); + fetchParams.processResponse = null; + }); + const internalResponse = response.type === "error" ? response : response.internalResponse ?? response; + if (internalResponse.body == null) processResponseEndOfBody(); + else finished(internalResponse.body.stream, () => { + processResponseEndOfBody(); + }); + } + async function httpFetch(fetchParams) { + const request = fetchParams.request; + let response = null; + let actualResponse = null; + const timingInfo = fetchParams.timingInfo; + if (request.serviceWorkers === "all") {} + if (response === null) { + if (request.redirect === "follow") request.serviceWorkers = "none"; + actualResponse = response = await httpNetworkOrCacheFetch(fetchParams); + if (request.responseTainting === "cors" && corsCheck(request, response) === "failure") return makeNetworkError("cors failure"); + if (TAOCheck(request, response) === "failure") request.timingAllowFailed = true; + } + if ((request.responseTainting === "opaque" || response.type === "opaque") && crossOriginResourcePolicyCheck(request.origin, request.client, request.destination, actualResponse) === "blocked") return makeNetworkError("blocked"); + if (redirectStatusSet.has(actualResponse.status)) { + if (request.redirect !== "manual") fetchParams.controller.connection.destroy(void 0, false); + if (request.redirect === "error") response = makeNetworkError("unexpected redirect"); + else if (request.redirect === "manual") response = actualResponse; + else if (request.redirect === "follow") response = await httpRedirectFetch(fetchParams, response); + else assert$4(false); + } + response.timingInfo = timingInfo; + return response; + } + function httpRedirectFetch(fetchParams, response) { + const request = fetchParams.request; + const actualResponse = response.internalResponse ? response.internalResponse : response; + let locationURL; + try { + locationURL = responseLocationURL(actualResponse, requestCurrentURL(request).hash); + if (locationURL == null) return response; + } catch (err) { + return Promise.resolve(makeNetworkError(err)); + } + if (!urlIsHttpHttpsScheme(locationURL)) return Promise.resolve(makeNetworkError("URL scheme must be a HTTP(S) scheme")); + if (request.redirectCount === 20) return Promise.resolve(makeNetworkError("redirect count exceeded")); + request.redirectCount += 1; + if (request.mode === "cors" && (locationURL.username || locationURL.password) && !sameOrigin(request, locationURL)) return Promise.resolve(makeNetworkError("cross origin not allowed for request mode \"cors\"")); + if (request.responseTainting === "cors" && (locationURL.username || locationURL.password)) return Promise.resolve(makeNetworkError("URL cannot contain credentials for request mode \"cors\"")); + if (actualResponse.status !== 303 && request.body != null && request.body.source == null) return Promise.resolve(makeNetworkError()); + if ([301, 302].includes(actualResponse.status) && request.method === "POST" || actualResponse.status === 303 && !GET_OR_HEAD.includes(request.method)) { + request.method = "GET"; + request.body = null; + for (const headerName of requestBodyHeader) request.headersList.delete(headerName); + } + if (!sameOrigin(requestCurrentURL(request), locationURL)) { + request.headersList.delete("authorization", true); + request.headersList.delete("proxy-authorization", true); + request.headersList.delete("cookie", true); + request.headersList.delete("host", true); + } + if (request.body != null) { + assert$4(request.body.source != null); + request.body = safelyExtractBody(request.body.source)[0]; + } + const timingInfo = fetchParams.timingInfo; + timingInfo.redirectEndTime = timingInfo.postRedirectStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability); + if (timingInfo.redirectStartTime === 0) timingInfo.redirectStartTime = timingInfo.startTime; + request.urlList.push(locationURL); + setRequestReferrerPolicyOnRedirect(request, actualResponse); + return mainFetch(fetchParams, true); + } + async function httpNetworkOrCacheFetch(fetchParams, isAuthenticationFetch = false, isNewConnectionFetch = false) { + const request = fetchParams.request; + let httpFetchParams = null; + let httpRequest = null; + let response = null; + if (request.window === "no-window" && request.redirect === "error") { + httpFetchParams = fetchParams; + httpRequest = request; + } else { + httpRequest = cloneRequest(request); + httpFetchParams = { ...fetchParams }; + httpFetchParams.request = httpRequest; + } + const includeCredentials = request.credentials === "include" || request.credentials === "same-origin" && request.responseTainting === "basic"; + const contentLength = httpRequest.body ? httpRequest.body.length : null; + let contentLengthHeaderValue = null; + if (httpRequest.body == null && ["POST", "PUT"].includes(httpRequest.method)) contentLengthHeaderValue = "0"; + if (contentLength != null) contentLengthHeaderValue = isomorphicEncode(`${contentLength}`); + if (contentLengthHeaderValue != null) httpRequest.headersList.append("content-length", contentLengthHeaderValue, true); + if (contentLength != null && httpRequest.keepalive) {} + if (httpRequest.referrer instanceof URL) httpRequest.headersList.append("referer", isomorphicEncode(httpRequest.referrer.href), true); + appendRequestOriginHeader(httpRequest); + appendFetchMetadata(httpRequest); + if (!httpRequest.headersList.contains("user-agent", true)) httpRequest.headersList.append("user-agent", defaultUserAgent); + if (httpRequest.cache === "default" && (httpRequest.headersList.contains("if-modified-since", true) || httpRequest.headersList.contains("if-none-match", true) || httpRequest.headersList.contains("if-unmodified-since", true) || httpRequest.headersList.contains("if-match", true) || httpRequest.headersList.contains("if-range", true))) httpRequest.cache = "no-store"; + if (httpRequest.cache === "no-cache" && !httpRequest.preventNoCacheCacheControlHeaderModification && !httpRequest.headersList.contains("cache-control", true)) httpRequest.headersList.append("cache-control", "max-age=0", true); + if (httpRequest.cache === "no-store" || httpRequest.cache === "reload") { + if (!httpRequest.headersList.contains("pragma", true)) httpRequest.headersList.append("pragma", "no-cache", true); + if (!httpRequest.headersList.contains("cache-control", true)) httpRequest.headersList.append("cache-control", "no-cache", true); + } + if (httpRequest.headersList.contains("range", true)) httpRequest.headersList.append("accept-encoding", "identity", true); + if (!httpRequest.headersList.contains("accept-encoding", true)) { + if (urlHasHttpsScheme(requestCurrentURL(httpRequest))) httpRequest.headersList.append("accept-encoding", "br, gzip, deflate", true); + else httpRequest.headersList.append("accept-encoding", "gzip, deflate", true); + } + httpRequest.headersList.delete("host", true); + if (includeCredentials) {} + httpRequest.cache = "no-store"; + if (httpRequest.cache !== "no-store" && httpRequest.cache !== "reload") {} + if (response == null) { + if (httpRequest.cache === "only-if-cached") return makeNetworkError("only if cached"); + const forwardResponse = await httpNetworkFetch(httpFetchParams, includeCredentials, isNewConnectionFetch); + if (!safeMethodsSet.has(httpRequest.method) && forwardResponse.status >= 200 && forwardResponse.status <= 399) {} + if (response == null) response = forwardResponse; + } + response.urlList = [...httpRequest.urlList]; + if (httpRequest.headersList.contains("range", true)) response.rangeRequested = true; + response.requestIncludesCredentials = includeCredentials; + if (response.status === 407) { + if (request.window === "no-window") return makeNetworkError(); + if (isCancelled(fetchParams)) return makeAppropriateNetworkError(fetchParams); + return makeNetworkError("proxy authentication required"); + } + if (response.status === 421 && !isNewConnectionFetch && (request.body == null || request.body.source != null)) { + if (isCancelled(fetchParams)) return makeAppropriateNetworkError(fetchParams); + fetchParams.controller.connection.destroy(); + response = await httpNetworkOrCacheFetch(fetchParams, isAuthenticationFetch, true); + } + if (isAuthenticationFetch) {} + return response; + } + async function httpNetworkFetch(fetchParams, includeCredentials = false, forceNewConnection = false) { + assert$4(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed); + fetchParams.controller.connection = { + abort: null, + destroyed: false, + destroy(err, abort = true) { + if (!this.destroyed) { + this.destroyed = true; + if (abort) this.abort?.(err ?? new DOMException("The operation was aborted.", "AbortError")); + } + } + }; + const request = fetchParams.request; + let response = null; + const timingInfo = fetchParams.timingInfo; + request.cache = "no-store"; + if (request.mode === "websocket") {} + let requestBody = null; + if (request.body == null && fetchParams.processRequestEndOfBody) queueMicrotask(() => fetchParams.processRequestEndOfBody()); + else if (request.body != null) { + const processBodyChunk = async function* (bytes) { + if (isCancelled(fetchParams)) return; + yield bytes; + fetchParams.processRequestBodyChunkLength?.(bytes.byteLength); + }; + const processEndOfBody = () => { + if (isCancelled(fetchParams)) return; + if (fetchParams.processRequestEndOfBody) fetchParams.processRequestEndOfBody(); + }; + const processBodyError = (e) => { + if (isCancelled(fetchParams)) return; + if (e.name === "AbortError") fetchParams.controller.abort(); + else fetchParams.controller.terminate(e); + }; + requestBody = (async function* () { + try { + for await (const bytes of request.body.stream) yield* processBodyChunk(bytes); + processEndOfBody(); + } catch (err) { + processBodyError(err); + } + })(); + } + try { + const { body, status, statusText, headersList, socket } = await dispatch({ body: requestBody }); + if (socket) response = makeResponse({ + status, + statusText, + headersList, + socket + }); + else { + const iterator = body[Symbol.asyncIterator](); + fetchParams.controller.next = () => iterator.next(); + response = makeResponse({ + status, + statusText, + headersList + }); + } + } catch (err) { + if (err.name === "AbortError") { + fetchParams.controller.connection.destroy(); + return makeAppropriateNetworkError(fetchParams, err); + } + return makeNetworkError(err); + } + const pullAlgorithm = async () => { + await fetchParams.controller.resume(); + }; + const cancelAlgorithm = (reason) => { + if (!isCancelled(fetchParams)) fetchParams.controller.abort(reason); + }; + const stream = new ReadableStream({ + async start(controller) { + fetchParams.controller.controller = controller; + }, + async pull(controller) { + await pullAlgorithm(controller); + }, + async cancel(reason) { + await cancelAlgorithm(reason); + }, + type: "bytes" + }); + response.body = { + stream, + source: null, + length: null + }; + fetchParams.controller.onAborted = onAborted; + fetchParams.controller.on("terminated", onAborted); + fetchParams.controller.resume = async () => { + while (true) { + let bytes; + let isFailure; + try { + const { done, value } = await fetchParams.controller.next(); + if (isAborted(fetchParams)) break; + bytes = done ? void 0 : value; + } catch (err) { + if (fetchParams.controller.ended && !timingInfo.encodedBodySize) bytes = void 0; + else { + bytes = err; + isFailure = true; + } + } + if (bytes === void 0) { + readableStreamClose(fetchParams.controller.controller); + finalizeResponse(fetchParams, response); + return; + } + timingInfo.decodedBodySize += bytes?.byteLength ?? 0; + if (isFailure) { + fetchParams.controller.terminate(bytes); + return; + } + const buffer = new Uint8Array(bytes); + if (buffer.byteLength) fetchParams.controller.controller.enqueue(buffer); + if (isErrored(stream)) { + fetchParams.controller.terminate(); + return; + } + if (fetchParams.controller.controller.desiredSize <= 0) return; + } + }; + function onAborted(reason) { + if (isAborted(fetchParams)) { + response.aborted = true; + if (isReadable(stream)) fetchParams.controller.controller.error(fetchParams.controller.serializedAbortReason); + } else if (isReadable(stream)) fetchParams.controller.controller.error(new TypeError("terminated", { cause: isErrorLike(reason) ? reason : void 0 })); + fetchParams.controller.connection.destroy(); + } + return response; + function dispatch({ body }) { + const url = requestCurrentURL(request); + /** @type {import('../..').Agent} */ + const agent = fetchParams.controller.dispatcher; + return new Promise((resolve, reject) => agent.dispatch({ + path: url.pathname + url.search, + origin: url.origin, + method: request.method, + body: agent.isMockActive ? request.body && (request.body.source || request.body.stream) : body, + headers: request.headersList.entries, + maxRedirections: 0, + upgrade: request.mode === "websocket" ? "websocket" : void 0 + }, { + body: null, + abort: null, + onConnect(abort) { + const { connection } = fetchParams.controller; + timingInfo.finalConnectionTimingInfo = clampAndCoarsenConnectionTimingInfo(void 0, timingInfo.postRedirectStartTime, fetchParams.crossOriginIsolatedCapability); + if (connection.destroyed) abort(new DOMException("The operation was aborted.", "AbortError")); + else { + fetchParams.controller.on("terminated", abort); + this.abort = connection.abort = abort; + } + timingInfo.finalNetworkRequestStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability); + }, + onResponseStarted() { + timingInfo.finalNetworkResponseStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability); + }, + onHeaders(status, rawHeaders, resume, statusText) { + if (status < 200) return; + let location = ""; + const headersList = new HeadersList(); + for (let i = 0; i < rawHeaders.length; i += 2) headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString("latin1"), true); + location = headersList.get("location", true); + this.body = new Readable({ read: resume }); + const decoders = []; + const willFollow = location && request.redirect === "follow" && redirectStatusSet.has(status); + if (request.method !== "HEAD" && request.method !== "CONNECT" && !nullBodyStatus.includes(status) && !willFollow) { + const contentEncoding = headersList.get("content-encoding", true); + /** @type {string[]} */ + const codings = contentEncoding ? contentEncoding.toLowerCase().split(",") : []; + const maxContentEncodings = 5; + if (codings.length > maxContentEncodings) { + reject(/* @__PURE__ */ new Error(`too many content-encodings in response: ${codings.length}, maximum allowed is ${maxContentEncodings}`)); + return true; + } + for (let i = codings.length - 1; i >= 0; --i) { + const coding = codings[i].trim(); + if (coding === "x-gzip" || coding === "gzip") decoders.push(zlib.createGunzip({ + flush: zlib.constants.Z_SYNC_FLUSH, + finishFlush: zlib.constants.Z_SYNC_FLUSH + })); + else if (coding === "deflate") decoders.push(createInflate({ + flush: zlib.constants.Z_SYNC_FLUSH, + finishFlush: zlib.constants.Z_SYNC_FLUSH + })); + else if (coding === "br") decoders.push(zlib.createBrotliDecompress({ + flush: zlib.constants.BROTLI_OPERATION_FLUSH, + finishFlush: zlib.constants.BROTLI_OPERATION_FLUSH + })); + else { + decoders.length = 0; + break; + } + } + } + const onError = this.onError.bind(this); + resolve({ + status, + statusText, + headersList, + body: decoders.length ? pipeline$1(this.body, ...decoders, (err) => { + if (err) this.onError(err); + }).on("error", onError) : this.body.on("error", onError) + }); + return true; + }, + onData(chunk) { + if (fetchParams.controller.dump) return; + const bytes = chunk; + timingInfo.encodedBodySize += bytes.byteLength; + return this.body.push(bytes); + }, + onComplete() { + if (this.abort) fetchParams.controller.off("terminated", this.abort); + if (fetchParams.controller.onAborted) fetchParams.controller.off("terminated", fetchParams.controller.onAborted); + fetchParams.controller.ended = true; + this.body.push(null); + }, + onError(error) { + if (this.abort) fetchParams.controller.off("terminated", this.abort); + this.body?.destroy(error); + fetchParams.controller.terminate(error); + reject(error); + }, + onUpgrade(status, rawHeaders, socket) { + if (status !== 101) return; + const headersList = new HeadersList(); + for (let i = 0; i < rawHeaders.length; i += 2) headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString("latin1"), true); + resolve({ + status, + statusText: STATUS_CODES[status], + headersList, + socket + }); + return true; + } + })); + } + } + module.exports = { + fetch, + Fetch, + fetching, + finalizeAndReportTiming + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fileapi/symbols.js +var require_symbols$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => { + module.exports = { + kState: Symbol("FileReader state"), + kResult: Symbol("FileReader result"), + kError: Symbol("FileReader error"), + kLastProgressEventFired: Symbol("FileReader last progress event fired timestamp"), + kEvents: Symbol("FileReader events"), + kAborted: Symbol("FileReader aborted") + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fileapi/progressevent.js +var require_progressevent = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { webidl } = require_webidl(); + const kState = Symbol("ProgressEvent state"); + /** + * @see https://xhr.spec.whatwg.org/#progressevent + */ + var ProgressEvent = class ProgressEvent extends Event { + constructor(type, eventInitDict = {}) { + type = webidl.converters.DOMString(type, "ProgressEvent constructor", "type"); + eventInitDict = webidl.converters.ProgressEventInit(eventInitDict ?? {}); + super(type, eventInitDict); + this[kState] = { + lengthComputable: eventInitDict.lengthComputable, + loaded: eventInitDict.loaded, + total: eventInitDict.total + }; + } + get lengthComputable() { + webidl.brandCheck(this, ProgressEvent); + return this[kState].lengthComputable; + } + get loaded() { + webidl.brandCheck(this, ProgressEvent); + return this[kState].loaded; + } + get total() { + webidl.brandCheck(this, ProgressEvent); + return this[kState].total; + } + }; + webidl.converters.ProgressEventInit = webidl.dictionaryConverter([ + { + key: "lengthComputable", + converter: webidl.converters.boolean, + defaultValue: () => false + }, + { + key: "loaded", + converter: webidl.converters["unsigned long long"], + defaultValue: () => 0 + }, + { + key: "total", + converter: webidl.converters["unsigned long long"], + defaultValue: () => 0 + }, + { + key: "bubbles", + converter: webidl.converters.boolean, + defaultValue: () => false + }, + { + key: "cancelable", + converter: webidl.converters.boolean, + defaultValue: () => false + }, + { + key: "composed", + converter: webidl.converters.boolean, + defaultValue: () => false + } + ]); + module.exports = { ProgressEvent }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fileapi/encoding.js +var require_encoding = /* @__PURE__ */ __commonJSMin(((exports, module) => { + /** + * @see https://encoding.spec.whatwg.org/#concept-encoding-get + * @param {string|undefined} label + */ + function getEncoding(label) { + if (!label) return "failure"; + switch (label.trim().toLowerCase()) { + case "unicode-1-1-utf-8": + case "unicode11utf8": + case "unicode20utf8": + case "utf-8": + case "utf8": + case "x-unicode20utf8": return "UTF-8"; + case "866": + case "cp866": + case "csibm866": + case "ibm866": return "IBM866"; + case "csisolatin2": + case "iso-8859-2": + case "iso-ir-101": + case "iso8859-2": + case "iso88592": + case "iso_8859-2": + case "iso_8859-2:1987": + case "l2": + case "latin2": return "ISO-8859-2"; + case "csisolatin3": + case "iso-8859-3": + case "iso-ir-109": + case "iso8859-3": + case "iso88593": + case "iso_8859-3": + case "iso_8859-3:1988": + case "l3": + case "latin3": return "ISO-8859-3"; + case "csisolatin4": + case "iso-8859-4": + case "iso-ir-110": + case "iso8859-4": + case "iso88594": + case "iso_8859-4": + case "iso_8859-4:1988": + case "l4": + case "latin4": return "ISO-8859-4"; + case "csisolatincyrillic": + case "cyrillic": + case "iso-8859-5": + case "iso-ir-144": + case "iso8859-5": + case "iso88595": + case "iso_8859-5": + case "iso_8859-5:1988": return "ISO-8859-5"; + case "arabic": + case "asmo-708": + case "csiso88596e": + case "csiso88596i": + case "csisolatinarabic": + case "ecma-114": + case "iso-8859-6": + case "iso-8859-6-e": + case "iso-8859-6-i": + case "iso-ir-127": + case "iso8859-6": + case "iso88596": + case "iso_8859-6": + case "iso_8859-6:1987": return "ISO-8859-6"; + case "csisolatingreek": + case "ecma-118": + case "elot_928": + case "greek": + case "greek8": + case "iso-8859-7": + case "iso-ir-126": + case "iso8859-7": + case "iso88597": + case "iso_8859-7": + case "iso_8859-7:1987": + case "sun_eu_greek": return "ISO-8859-7"; + case "csiso88598e": + case "csisolatinhebrew": + case "hebrew": + case "iso-8859-8": + case "iso-8859-8-e": + case "iso-ir-138": + case "iso8859-8": + case "iso88598": + case "iso_8859-8": + case "iso_8859-8:1988": + case "visual": return "ISO-8859-8"; + case "csiso88598i": + case "iso-8859-8-i": + case "logical": return "ISO-8859-8-I"; + case "csisolatin6": + case "iso-8859-10": + case "iso-ir-157": + case "iso8859-10": + case "iso885910": + case "l6": + case "latin6": return "ISO-8859-10"; + case "iso-8859-13": + case "iso8859-13": + case "iso885913": return "ISO-8859-13"; + case "iso-8859-14": + case "iso8859-14": + case "iso885914": return "ISO-8859-14"; + case "csisolatin9": + case "iso-8859-15": + case "iso8859-15": + case "iso885915": + case "iso_8859-15": + case "l9": return "ISO-8859-15"; + case "iso-8859-16": return "ISO-8859-16"; + case "cskoi8r": + case "koi": + case "koi8": + case "koi8-r": + case "koi8_r": return "KOI8-R"; + case "koi8-ru": + case "koi8-u": return "KOI8-U"; + case "csmacintosh": + case "mac": + case "macintosh": + case "x-mac-roman": return "macintosh"; + case "iso-8859-11": + case "iso8859-11": + case "iso885911": + case "tis-620": + case "windows-874": return "windows-874"; + case "cp1250": + case "windows-1250": + case "x-cp1250": return "windows-1250"; + case "cp1251": + case "windows-1251": + case "x-cp1251": return "windows-1251"; + case "ansi_x3.4-1968": + case "ascii": + case "cp1252": + case "cp819": + case "csisolatin1": + case "ibm819": + case "iso-8859-1": + case "iso-ir-100": + case "iso8859-1": + case "iso88591": + case "iso_8859-1": + case "iso_8859-1:1987": + case "l1": + case "latin1": + case "us-ascii": + case "windows-1252": + case "x-cp1252": return "windows-1252"; + case "cp1253": + case "windows-1253": + case "x-cp1253": return "windows-1253"; + case "cp1254": + case "csisolatin5": + case "iso-8859-9": + case "iso-ir-148": + case "iso8859-9": + case "iso88599": + case "iso_8859-9": + case "iso_8859-9:1989": + case "l5": + case "latin5": + case "windows-1254": + case "x-cp1254": return "windows-1254"; + case "cp1255": + case "windows-1255": + case "x-cp1255": return "windows-1255"; + case "cp1256": + case "windows-1256": + case "x-cp1256": return "windows-1256"; + case "cp1257": + case "windows-1257": + case "x-cp1257": return "windows-1257"; + case "cp1258": + case "windows-1258": + case "x-cp1258": return "windows-1258"; + case "x-mac-cyrillic": + case "x-mac-ukrainian": return "x-mac-cyrillic"; + case "chinese": + case "csgb2312": + case "csiso58gb231280": + case "gb2312": + case "gb_2312": + case "gb_2312-80": + case "gbk": + case "iso-ir-58": + case "x-gbk": return "GBK"; + case "gb18030": return "gb18030"; + case "big5": + case "big5-hkscs": + case "cn-big5": + case "csbig5": + case "x-x-big5": return "Big5"; + case "cseucpkdfmtjapanese": + case "euc-jp": + case "x-euc-jp": return "EUC-JP"; + case "csiso2022jp": + case "iso-2022-jp": return "ISO-2022-JP"; + case "csshiftjis": + case "ms932": + case "ms_kanji": + case "shift-jis": + case "shift_jis": + case "sjis": + case "windows-31j": + case "x-sjis": return "Shift_JIS"; + case "cseuckr": + case "csksc56011987": + case "euc-kr": + case "iso-ir-149": + case "korean": + case "ks_c_5601-1987": + case "ks_c_5601-1989": + case "ksc5601": + case "ksc_5601": + case "windows-949": return "EUC-KR"; + case "csiso2022kr": + case "hz-gb-2312": + case "iso-2022-cn": + case "iso-2022-cn-ext": + case "iso-2022-kr": + case "replacement": return "replacement"; + case "unicodefffe": + case "utf-16be": return "UTF-16BE"; + case "csunicode": + case "iso-10646-ucs-2": + case "ucs-2": + case "unicode": + case "unicodefeff": + case "utf-16": + case "utf-16le": return "UTF-16LE"; + case "x-user-defined": return "x-user-defined"; + default: return "failure"; + } + } + module.exports = { getEncoding }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fileapi/util.js +var require_util$4 = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { kState, kError, kResult, kAborted, kLastProgressEventFired } = require_symbols$2(); + const { ProgressEvent } = require_progressevent(); + const { getEncoding } = require_encoding(); + const { serializeAMimeType, parseMIMEType } = require_data_url(); + const { types: types$1 } = __require("node:util"); + const { StringDecoder } = __require("string_decoder"); + const { btoa: btoa$1 } = __require("node:buffer"); + /** @type {PropertyDescriptor} */ + const staticPropertyDescriptors = { + enumerable: true, + writable: false, + configurable: false + }; + /** + * @see https://w3c.github.io/FileAPI/#readOperation + * @param {import('./filereader').FileReader} fr + * @param {import('buffer').Blob} blob + * @param {string} type + * @param {string?} encodingName + */ + function readOperation(fr, blob, type, encodingName) { + if (fr[kState] === "loading") throw new DOMException("Invalid state", "InvalidStateError"); + fr[kState] = "loading"; + fr[kResult] = null; + fr[kError] = null; + const reader = blob.stream().getReader(); + /** @type {Uint8Array[]} */ + const bytes = []; + let chunkPromise = reader.read(); + let isFirstChunk = true; + (async () => { + while (!fr[kAborted]) try { + const { done, value } = await chunkPromise; + if (isFirstChunk && !fr[kAborted]) queueMicrotask(() => { + fireAProgressEvent("loadstart", fr); + }); + isFirstChunk = false; + if (!done && types$1.isUint8Array(value)) { + bytes.push(value); + if ((fr[kLastProgressEventFired] === void 0 || Date.now() - fr[kLastProgressEventFired] >= 50) && !fr[kAborted]) { + fr[kLastProgressEventFired] = Date.now(); + queueMicrotask(() => { + fireAProgressEvent("progress", fr); + }); + } + chunkPromise = reader.read(); + } else if (done) { + queueMicrotask(() => { + fr[kState] = "done"; + try { + const result = packageData(bytes, type, blob.type, encodingName); + if (fr[kAborted]) return; + fr[kResult] = result; + fireAProgressEvent("load", fr); + } catch (error) { + fr[kError] = error; + fireAProgressEvent("error", fr); + } + if (fr[kState] !== "loading") fireAProgressEvent("loadend", fr); + }); + break; + } + } catch (error) { + if (fr[kAborted]) return; + queueMicrotask(() => { + fr[kState] = "done"; + fr[kError] = error; + fireAProgressEvent("error", fr); + if (fr[kState] !== "loading") fireAProgressEvent("loadend", fr); + }); + break; + } + })(); + } + /** + * @see https://w3c.github.io/FileAPI/#fire-a-progress-event + * @see https://dom.spec.whatwg.org/#concept-event-fire + * @param {string} e The name of the event + * @param {import('./filereader').FileReader} reader + */ + function fireAProgressEvent(e, reader) { + const event = new ProgressEvent(e, { + bubbles: false, + cancelable: false + }); + reader.dispatchEvent(event); + } + /** + * @see https://w3c.github.io/FileAPI/#blob-package-data + * @param {Uint8Array[]} bytes + * @param {string} type + * @param {string?} mimeType + * @param {string?} encodingName + */ + function packageData(bytes, type, mimeType, encodingName) { + switch (type) { + case "DataURL": { + let dataURL = "data:"; + const parsed = parseMIMEType(mimeType || "application/octet-stream"); + if (parsed !== "failure") dataURL += serializeAMimeType(parsed); + dataURL += ";base64,"; + const decoder = new StringDecoder("latin1"); + for (const chunk of bytes) dataURL += btoa$1(decoder.write(chunk)); + dataURL += btoa$1(decoder.end()); + return dataURL; + } + case "Text": { + let encoding = "failure"; + if (encodingName) encoding = getEncoding(encodingName); + if (encoding === "failure" && mimeType) { + const type = parseMIMEType(mimeType); + if (type !== "failure") encoding = getEncoding(type.parameters.get("charset")); + } + if (encoding === "failure") encoding = "UTF-8"; + return decode(bytes, encoding); + } + case "ArrayBuffer": return combineByteSequences(bytes).buffer; + case "BinaryString": { + let binaryString = ""; + const decoder = new StringDecoder("latin1"); + for (const chunk of bytes) binaryString += decoder.write(chunk); + binaryString += decoder.end(); + return binaryString; + } + } + } + /** + * @see https://encoding.spec.whatwg.org/#decode + * @param {Uint8Array[]} ioQueue + * @param {string} encoding + */ + function decode(ioQueue, encoding) { + const bytes = combineByteSequences(ioQueue); + const BOMEncoding = BOMSniffing(bytes); + let slice = 0; + if (BOMEncoding !== null) { + encoding = BOMEncoding; + slice = BOMEncoding === "UTF-8" ? 3 : 2; + } + const sliced = bytes.slice(slice); + return new TextDecoder(encoding).decode(sliced); + } + /** + * @see https://encoding.spec.whatwg.org/#bom-sniff + * @param {Uint8Array} ioQueue + */ + function BOMSniffing(ioQueue) { + const [a, b, c] = ioQueue; + if (a === 239 && b === 187 && c === 191) return "UTF-8"; + else if (a === 254 && b === 255) return "UTF-16BE"; + else if (a === 255 && b === 254) return "UTF-16LE"; + return null; + } + /** + * @param {Uint8Array[]} sequences + */ + function combineByteSequences(sequences) { + const size = sequences.reduce((a, b) => { + return a + b.byteLength; + }, 0); + let offset = 0; + return sequences.reduce((a, b) => { + a.set(b, offset); + offset += b.byteLength; + return a; + }, new Uint8Array(size)); + } + module.exports = { + staticPropertyDescriptors, + readOperation, + fireAProgressEvent + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/fileapi/filereader.js +var require_filereader = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { staticPropertyDescriptors, readOperation, fireAProgressEvent } = require_util$4(); + const { kState, kError, kResult, kEvents, kAborted } = require_symbols$2(); + const { webidl } = require_webidl(); + const { kEnumerableProperty } = require_util$7(); + var FileReader = class FileReader extends EventTarget { + constructor() { + super(); + this[kState] = "empty"; + this[kResult] = null; + this[kError] = null; + this[kEvents] = { + loadend: null, + error: null, + abort: null, + load: null, + progress: null, + loadstart: null + }; + } + /** + * @see https://w3c.github.io/FileAPI/#dfn-readAsArrayBuffer + * @param {import('buffer').Blob} blob + */ + readAsArrayBuffer(blob) { + webidl.brandCheck(this, FileReader); + webidl.argumentLengthCheck(arguments, 1, "FileReader.readAsArrayBuffer"); + blob = webidl.converters.Blob(blob, { strict: false }); + readOperation(this, blob, "ArrayBuffer"); + } + /** + * @see https://w3c.github.io/FileAPI/#readAsBinaryString + * @param {import('buffer').Blob} blob + */ + readAsBinaryString(blob) { + webidl.brandCheck(this, FileReader); + webidl.argumentLengthCheck(arguments, 1, "FileReader.readAsBinaryString"); + blob = webidl.converters.Blob(blob, { strict: false }); + readOperation(this, blob, "BinaryString"); + } + /** + * @see https://w3c.github.io/FileAPI/#readAsDataText + * @param {import('buffer').Blob} blob + * @param {string?} encoding + */ + readAsText(blob, encoding = void 0) { + webidl.brandCheck(this, FileReader); + webidl.argumentLengthCheck(arguments, 1, "FileReader.readAsText"); + blob = webidl.converters.Blob(blob, { strict: false }); + if (encoding !== void 0) encoding = webidl.converters.DOMString(encoding, "FileReader.readAsText", "encoding"); + readOperation(this, blob, "Text", encoding); + } + /** + * @see https://w3c.github.io/FileAPI/#dfn-readAsDataURL + * @param {import('buffer').Blob} blob + */ + readAsDataURL(blob) { + webidl.brandCheck(this, FileReader); + webidl.argumentLengthCheck(arguments, 1, "FileReader.readAsDataURL"); + blob = webidl.converters.Blob(blob, { strict: false }); + readOperation(this, blob, "DataURL"); + } + /** + * @see https://w3c.github.io/FileAPI/#dfn-abort + */ + abort() { + if (this[kState] === "empty" || this[kState] === "done") { + this[kResult] = null; + return; + } + if (this[kState] === "loading") { + this[kState] = "done"; + this[kResult] = null; + } + this[kAborted] = true; + fireAProgressEvent("abort", this); + if (this[kState] !== "loading") fireAProgressEvent("loadend", this); + } + /** + * @see https://w3c.github.io/FileAPI/#dom-filereader-readystate + */ + get readyState() { + webidl.brandCheck(this, FileReader); + switch (this[kState]) { + case "empty": return this.EMPTY; + case "loading": return this.LOADING; + case "done": return this.DONE; + } + } + /** + * @see https://w3c.github.io/FileAPI/#dom-filereader-result + */ + get result() { + webidl.brandCheck(this, FileReader); + return this[kResult]; + } + /** + * @see https://w3c.github.io/FileAPI/#dom-filereader-error + */ + get error() { + webidl.brandCheck(this, FileReader); + return this[kError]; + } + get onloadend() { + webidl.brandCheck(this, FileReader); + return this[kEvents].loadend; + } + set onloadend(fn) { + webidl.brandCheck(this, FileReader); + if (this[kEvents].loadend) this.removeEventListener("loadend", this[kEvents].loadend); + if (typeof fn === "function") { + this[kEvents].loadend = fn; + this.addEventListener("loadend", fn); + } else this[kEvents].loadend = null; + } + get onerror() { + webidl.brandCheck(this, FileReader); + return this[kEvents].error; + } + set onerror(fn) { + webidl.brandCheck(this, FileReader); + if (this[kEvents].error) this.removeEventListener("error", this[kEvents].error); + if (typeof fn === "function") { + this[kEvents].error = fn; + this.addEventListener("error", fn); + } else this[kEvents].error = null; + } + get onloadstart() { + webidl.brandCheck(this, FileReader); + return this[kEvents].loadstart; + } + set onloadstart(fn) { + webidl.brandCheck(this, FileReader); + if (this[kEvents].loadstart) this.removeEventListener("loadstart", this[kEvents].loadstart); + if (typeof fn === "function") { + this[kEvents].loadstart = fn; + this.addEventListener("loadstart", fn); + } else this[kEvents].loadstart = null; + } + get onprogress() { + webidl.brandCheck(this, FileReader); + return this[kEvents].progress; + } + set onprogress(fn) { + webidl.brandCheck(this, FileReader); + if (this[kEvents].progress) this.removeEventListener("progress", this[kEvents].progress); + if (typeof fn === "function") { + this[kEvents].progress = fn; + this.addEventListener("progress", fn); + } else this[kEvents].progress = null; + } + get onload() { + webidl.brandCheck(this, FileReader); + return this[kEvents].load; + } + set onload(fn) { + webidl.brandCheck(this, FileReader); + if (this[kEvents].load) this.removeEventListener("load", this[kEvents].load); + if (typeof fn === "function") { + this[kEvents].load = fn; + this.addEventListener("load", fn); + } else this[kEvents].load = null; + } + get onabort() { + webidl.brandCheck(this, FileReader); + return this[kEvents].abort; + } + set onabort(fn) { + webidl.brandCheck(this, FileReader); + if (this[kEvents].abort) this.removeEventListener("abort", this[kEvents].abort); + if (typeof fn === "function") { + this[kEvents].abort = fn; + this.addEventListener("abort", fn); + } else this[kEvents].abort = null; + } + }; + FileReader.EMPTY = FileReader.prototype.EMPTY = 0; + FileReader.LOADING = FileReader.prototype.LOADING = 1; + FileReader.DONE = FileReader.prototype.DONE = 2; + Object.defineProperties(FileReader.prototype, { + EMPTY: staticPropertyDescriptors, + LOADING: staticPropertyDescriptors, + DONE: staticPropertyDescriptors, + readAsArrayBuffer: kEnumerableProperty, + readAsBinaryString: kEnumerableProperty, + readAsText: kEnumerableProperty, + readAsDataURL: kEnumerableProperty, + abort: kEnumerableProperty, + readyState: kEnumerableProperty, + result: kEnumerableProperty, + error: kEnumerableProperty, + onloadstart: kEnumerableProperty, + onprogress: kEnumerableProperty, + onload: kEnumerableProperty, + onabort: kEnumerableProperty, + onerror: kEnumerableProperty, + onloadend: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "FileReader", + writable: false, + enumerable: false, + configurable: true + } + }); + Object.defineProperties(FileReader, { + EMPTY: staticPropertyDescriptors, + LOADING: staticPropertyDescriptors, + DONE: staticPropertyDescriptors + }); + module.exports = { FileReader }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/cache/symbols.js +var require_symbols$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => { + module.exports = { kConstruct: require_symbols$4().kConstruct }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/cache/util.js +var require_util$3 = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const assert$3 = __require("node:assert"); + const { URLSerializer } = require_data_url(); + const { isValidHeaderName } = require_util$6(); + /** + * @see https://url.spec.whatwg.org/#concept-url-equals + * @param {URL} A + * @param {URL} B + * @param {boolean | undefined} excludeFragment + * @returns {boolean} + */ + function urlEquals(A, B, excludeFragment = false) { + return URLSerializer(A, excludeFragment) === URLSerializer(B, excludeFragment); + } + /** + * @see https://github.com/chromium/chromium/blob/694d20d134cb553d8d89e5500b9148012b1ba299/content/browser/cache_storage/cache_storage_cache.cc#L260-L262 + * @param {string} header + */ + function getFieldValues(header) { + assert$3(header !== null); + const values = []; + for (let value of header.split(",")) { + value = value.trim(); + if (isValidHeaderName(value)) values.push(value); + } + return values; + } + module.exports = { + urlEquals, + getFieldValues + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/cache/cache.js +var require_cache = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { kConstruct } = require_symbols$1(); + const { urlEquals, getFieldValues } = require_util$3(); + const { kEnumerableProperty, isDisturbed } = require_util$7(); + const { webidl } = require_webidl(); + const { Response, cloneResponse, fromInnerResponse } = require_response(); + const { Request, fromInnerRequest } = require_request(); + const { kState } = require_symbols$3(); + const { fetching } = require_fetch(); + const { urlIsHttpHttpsScheme, createDeferredPromise, readAllBytes } = require_util$6(); + const assert$2 = __require("node:assert"); + /** + * @see https://w3c.github.io/ServiceWorker/#dfn-cache-batch-operation + * @typedef {Object} CacheBatchOperation + * @property {'delete' | 'put'} type + * @property {any} request + * @property {any} response + * @property {import('../../types/cache').CacheQueryOptions} options + */ + /** + * @see https://w3c.github.io/ServiceWorker/#dfn-request-response-list + * @typedef {[any, any][]} requestResponseList + */ + var Cache = class Cache { + /** + * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-request-response-list + * @type {requestResponseList} + */ + #relevantRequestResponseList; + constructor() { + if (arguments[0] !== kConstruct) webidl.illegalConstructor(); + webidl.util.markAsUncloneable(this); + this.#relevantRequestResponseList = arguments[1]; + } + async match(request, options = {}) { + webidl.brandCheck(this, Cache); + const prefix = "Cache.match"; + webidl.argumentLengthCheck(arguments, 1, prefix); + request = webidl.converters.RequestInfo(request, prefix, "request"); + options = webidl.converters.CacheQueryOptions(options, prefix, "options"); + const p = this.#internalMatchAll(request, options, 1); + if (p.length === 0) return; + return p[0]; + } + async matchAll(request = void 0, options = {}) { + webidl.brandCheck(this, Cache); + const prefix = "Cache.matchAll"; + if (request !== void 0) request = webidl.converters.RequestInfo(request, prefix, "request"); + options = webidl.converters.CacheQueryOptions(options, prefix, "options"); + return this.#internalMatchAll(request, options); + } + async add(request) { + webidl.brandCheck(this, Cache); + const prefix = "Cache.add"; + webidl.argumentLengthCheck(arguments, 1, prefix); + request = webidl.converters.RequestInfo(request, prefix, "request"); + const requests = [request]; + return await this.addAll(requests); + } + async addAll(requests) { + webidl.brandCheck(this, Cache); + const prefix = "Cache.addAll"; + webidl.argumentLengthCheck(arguments, 1, prefix); + const responsePromises = []; + const requestList = []; + for (let request of requests) { + if (request === void 0) throw webidl.errors.conversionFailed({ + prefix, + argument: "Argument 1", + types: ["undefined is not allowed"] + }); + request = webidl.converters.RequestInfo(request); + if (typeof request === "string") continue; + const r = request[kState]; + if (!urlIsHttpHttpsScheme(r.url) || r.method !== "GET") throw webidl.errors.exception({ + header: prefix, + message: "Expected http/s scheme when method is not GET." + }); + } + /** @type {ReturnType[]} */ + const fetchControllers = []; + for (const request of requests) { + const r = new Request(request)[kState]; + if (!urlIsHttpHttpsScheme(r.url)) throw webidl.errors.exception({ + header: prefix, + message: "Expected http/s scheme." + }); + r.initiator = "fetch"; + r.destination = "subresource"; + requestList.push(r); + const responsePromise = createDeferredPromise(); + fetchControllers.push(fetching({ + request: r, + processResponse(response) { + if (response.type === "error" || response.status === 206 || response.status < 200 || response.status > 299) responsePromise.reject(webidl.errors.exception({ + header: "Cache.addAll", + message: "Received an invalid status code or the request failed." + })); + else if (response.headersList.contains("vary")) { + const fieldValues = getFieldValues(response.headersList.get("vary")); + for (const fieldValue of fieldValues) if (fieldValue === "*") { + responsePromise.reject(webidl.errors.exception({ + header: "Cache.addAll", + message: "invalid vary field value" + })); + for (const controller of fetchControllers) controller.abort(); + return; + } + } + }, + processResponseEndOfBody(response) { + if (response.aborted) { + responsePromise.reject(new DOMException("aborted", "AbortError")); + return; + } + responsePromise.resolve(response); + } + })); + responsePromises.push(responsePromise.promise); + } + const responses = await Promise.all(responsePromises); + const operations = []; + let index = 0; + for (const response of responses) { + /** @type {CacheBatchOperation} */ + const operation = { + type: "put", + request: requestList[index], + response + }; + operations.push(operation); + index++; + } + const cacheJobPromise = createDeferredPromise(); + let errorData = null; + try { + this.#batchCacheOperations(operations); + } catch (e) { + errorData = e; + } + queueMicrotask(() => { + if (errorData === null) cacheJobPromise.resolve(void 0); + else cacheJobPromise.reject(errorData); + }); + return cacheJobPromise.promise; + } + async put(request, response) { + webidl.brandCheck(this, Cache); + const prefix = "Cache.put"; + webidl.argumentLengthCheck(arguments, 2, prefix); + request = webidl.converters.RequestInfo(request, prefix, "request"); + response = webidl.converters.Response(response, prefix, "response"); + let innerRequest = null; + if (request instanceof Request) innerRequest = request[kState]; + else innerRequest = new Request(request)[kState]; + if (!urlIsHttpHttpsScheme(innerRequest.url) || innerRequest.method !== "GET") throw webidl.errors.exception({ + header: prefix, + message: "Expected an http/s scheme when method is not GET" + }); + const innerResponse = response[kState]; + if (innerResponse.status === 206) throw webidl.errors.exception({ + header: prefix, + message: "Got 206 status" + }); + if (innerResponse.headersList.contains("vary")) { + const fieldValues = getFieldValues(innerResponse.headersList.get("vary")); + for (const fieldValue of fieldValues) if (fieldValue === "*") throw webidl.errors.exception({ + header: prefix, + message: "Got * vary field value" + }); + } + if (innerResponse.body && (isDisturbed(innerResponse.body.stream) || innerResponse.body.stream.locked)) throw webidl.errors.exception({ + header: prefix, + message: "Response body is locked or disturbed" + }); + const clonedResponse = cloneResponse(innerResponse); + const bodyReadPromise = createDeferredPromise(); + if (innerResponse.body != null) { + const reader = innerResponse.body.stream.getReader(); + readAllBytes(reader).then(bodyReadPromise.resolve, bodyReadPromise.reject); + } else bodyReadPromise.resolve(void 0); + /** @type {CacheBatchOperation[]} */ + const operations = []; + /** @type {CacheBatchOperation} */ + const operation = { + type: "put", + request: innerRequest, + response: clonedResponse + }; + operations.push(operation); + const bytes = await bodyReadPromise.promise; + if (clonedResponse.body != null) clonedResponse.body.source = bytes; + const cacheJobPromise = createDeferredPromise(); + let errorData = null; + try { + this.#batchCacheOperations(operations); + } catch (e) { + errorData = e; + } + queueMicrotask(() => { + if (errorData === null) cacheJobPromise.resolve(); + else cacheJobPromise.reject(errorData); + }); + return cacheJobPromise.promise; + } + async delete(request, options = {}) { + webidl.brandCheck(this, Cache); + const prefix = "Cache.delete"; + webidl.argumentLengthCheck(arguments, 1, prefix); + request = webidl.converters.RequestInfo(request, prefix, "request"); + options = webidl.converters.CacheQueryOptions(options, prefix, "options"); + /** + * @type {Request} + */ + let r = null; + if (request instanceof Request) { + r = request[kState]; + if (r.method !== "GET" && !options.ignoreMethod) return false; + } else { + assert$2(typeof request === "string"); + r = new Request(request)[kState]; + } + /** @type {CacheBatchOperation[]} */ + const operations = []; + /** @type {CacheBatchOperation} */ + const operation = { + type: "delete", + request: r, + options + }; + operations.push(operation); + const cacheJobPromise = createDeferredPromise(); + let errorData = null; + let requestResponses; + try { + requestResponses = this.#batchCacheOperations(operations); + } catch (e) { + errorData = e; + } + queueMicrotask(() => { + if (errorData === null) cacheJobPromise.resolve(!!requestResponses?.length); + else cacheJobPromise.reject(errorData); + }); + return cacheJobPromise.promise; + } + /** + * @see https://w3c.github.io/ServiceWorker/#dom-cache-keys + * @param {any} request + * @param {import('../../types/cache').CacheQueryOptions} options + * @returns {Promise} + */ + async keys(request = void 0, options = {}) { + webidl.brandCheck(this, Cache); + const prefix = "Cache.keys"; + if (request !== void 0) request = webidl.converters.RequestInfo(request, prefix, "request"); + options = webidl.converters.CacheQueryOptions(options, prefix, "options"); + let r = null; + if (request !== void 0) { + if (request instanceof Request) { + r = request[kState]; + if (r.method !== "GET" && !options.ignoreMethod) return []; + } else if (typeof request === "string") r = new Request(request)[kState]; + } + const promise = createDeferredPromise(); + const requests = []; + if (request === void 0) for (const requestResponse of this.#relevantRequestResponseList) requests.push(requestResponse[0]); + else { + const requestResponses = this.#queryCache(r, options); + for (const requestResponse of requestResponses) requests.push(requestResponse[0]); + } + queueMicrotask(() => { + const requestList = []; + for (const request of requests) { + const requestObject = fromInnerRequest(request, new AbortController().signal, "immutable"); + requestList.push(requestObject); + } + promise.resolve(Object.freeze(requestList)); + }); + return promise.promise; + } + /** + * @see https://w3c.github.io/ServiceWorker/#batch-cache-operations-algorithm + * @param {CacheBatchOperation[]} operations + * @returns {requestResponseList} + */ + #batchCacheOperations(operations) { + const cache = this.#relevantRequestResponseList; + const backupCache = [...cache]; + const addedItems = []; + const resultList = []; + try { + for (const operation of operations) { + if (operation.type !== "delete" && operation.type !== "put") throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "operation type does not match \"delete\" or \"put\"" + }); + if (operation.type === "delete" && operation.response != null) throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "delete operation should not have an associated response" + }); + if (this.#queryCache(operation.request, operation.options, addedItems).length) throw new DOMException("???", "InvalidStateError"); + let requestResponses; + if (operation.type === "delete") { + requestResponses = this.#queryCache(operation.request, operation.options); + if (requestResponses.length === 0) return []; + for (const requestResponse of requestResponses) { + const idx = cache.indexOf(requestResponse); + assert$2(idx !== -1); + cache.splice(idx, 1); + } + } else if (operation.type === "put") { + if (operation.response == null) throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "put operation should have an associated response" + }); + const r = operation.request; + if (!urlIsHttpHttpsScheme(r.url)) throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "expected http or https scheme" + }); + if (r.method !== "GET") throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "not get method" + }); + if (operation.options != null) throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "options must not be defined" + }); + requestResponses = this.#queryCache(operation.request); + for (const requestResponse of requestResponses) { + const idx = cache.indexOf(requestResponse); + assert$2(idx !== -1); + cache.splice(idx, 1); + } + cache.push([operation.request, operation.response]); + addedItems.push([operation.request, operation.response]); + } + resultList.push([operation.request, operation.response]); + } + return resultList; + } catch (e) { + this.#relevantRequestResponseList.length = 0; + this.#relevantRequestResponseList = backupCache; + throw e; + } + } + /** + * @see https://w3c.github.io/ServiceWorker/#query-cache + * @param {any} requestQuery + * @param {import('../../types/cache').CacheQueryOptions} options + * @param {requestResponseList} targetStorage + * @returns {requestResponseList} + */ + #queryCache(requestQuery, options, targetStorage) { + /** @type {requestResponseList} */ + const resultList = []; + const storage = targetStorage ?? this.#relevantRequestResponseList; + for (const requestResponse of storage) { + const [cachedRequest, cachedResponse] = requestResponse; + if (this.#requestMatchesCachedItem(requestQuery, cachedRequest, cachedResponse, options)) resultList.push(requestResponse); + } + return resultList; + } + /** + * @see https://w3c.github.io/ServiceWorker/#request-matches-cached-item-algorithm + * @param {any} requestQuery + * @param {any} request + * @param {any | null} response + * @param {import('../../types/cache').CacheQueryOptions | undefined} options + * @returns {boolean} + */ + #requestMatchesCachedItem(requestQuery, request, response = null, options) { + const queryURL = new URL(requestQuery.url); + const cachedURL = new URL(request.url); + if (options?.ignoreSearch) { + cachedURL.search = ""; + queryURL.search = ""; + } + if (!urlEquals(queryURL, cachedURL, true)) return false; + if (response == null || options?.ignoreVary || !response.headersList.contains("vary")) return true; + const fieldValues = getFieldValues(response.headersList.get("vary")); + for (const fieldValue of fieldValues) { + if (fieldValue === "*") return false; + if (request.headersList.get(fieldValue) !== requestQuery.headersList.get(fieldValue)) return false; + } + return true; + } + #internalMatchAll(request, options, maxResponses = Infinity) { + let r = null; + if (request !== void 0) { + if (request instanceof Request) { + r = request[kState]; + if (r.method !== "GET" && !options.ignoreMethod) return []; + } else if (typeof request === "string") r = new Request(request)[kState]; + } + const responses = []; + if (request === void 0) for (const requestResponse of this.#relevantRequestResponseList) responses.push(requestResponse[1]); + else { + const requestResponses = this.#queryCache(r, options); + for (const requestResponse of requestResponses) responses.push(requestResponse[1]); + } + const responseList = []; + for (const response of responses) { + const responseObject = fromInnerResponse(response, "immutable"); + responseList.push(responseObject.clone()); + if (responseList.length >= maxResponses) break; + } + return Object.freeze(responseList); + } + }; + Object.defineProperties(Cache.prototype, { + [Symbol.toStringTag]: { + value: "Cache", + configurable: true + }, + match: kEnumerableProperty, + matchAll: kEnumerableProperty, + add: kEnumerableProperty, + addAll: kEnumerableProperty, + put: kEnumerableProperty, + delete: kEnumerableProperty, + keys: kEnumerableProperty + }); + const cacheQueryOptionConverters = [ + { + key: "ignoreSearch", + converter: webidl.converters.boolean, + defaultValue: () => false + }, + { + key: "ignoreMethod", + converter: webidl.converters.boolean, + defaultValue: () => false + }, + { + key: "ignoreVary", + converter: webidl.converters.boolean, + defaultValue: () => false + } + ]; + webidl.converters.CacheQueryOptions = webidl.dictionaryConverter(cacheQueryOptionConverters); + webidl.converters.MultiCacheQueryOptions = webidl.dictionaryConverter([...cacheQueryOptionConverters, { + key: "cacheName", + converter: webidl.converters.DOMString + }]); + webidl.converters.Response = webidl.interfaceConverter(Response); + webidl.converters["sequence"] = webidl.sequenceConverter(webidl.converters.RequestInfo); + module.exports = { Cache }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/cache/cachestorage.js +var require_cachestorage = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { kConstruct } = require_symbols$1(); + const { Cache } = require_cache(); + const { webidl } = require_webidl(); + const { kEnumerableProperty } = require_util$7(); + var CacheStorage = class CacheStorage { + /** + * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-name-to-cache-map + * @type {Map} + */ + async has(cacheName) { + webidl.brandCheck(this, CacheStorage); + const prefix = "CacheStorage.has"; + webidl.argumentLengthCheck(arguments, 1, prefix); + cacheName = webidl.converters.DOMString(cacheName, prefix, "cacheName"); + return this.#caches.has(cacheName); + } + /** + * @see https://w3c.github.io/ServiceWorker/#dom-cachestorage-open + * @param {string} cacheName + * @returns {Promise} + */ + async open(cacheName) { + webidl.brandCheck(this, CacheStorage); + const prefix = "CacheStorage.open"; + webidl.argumentLengthCheck(arguments, 1, prefix); + cacheName = webidl.converters.DOMString(cacheName, prefix, "cacheName"); + if (this.#caches.has(cacheName)) { + const cache = this.#caches.get(cacheName); + return new Cache(kConstruct, cache); + } + const cache = []; + this.#caches.set(cacheName, cache); + return new Cache(kConstruct, cache); + } + /** + * @see https://w3c.github.io/ServiceWorker/#cache-storage-delete + * @param {string} cacheName + * @returns {Promise} + */ + async delete(cacheName) { + webidl.brandCheck(this, CacheStorage); + const prefix = "CacheStorage.delete"; + webidl.argumentLengthCheck(arguments, 1, prefix); + cacheName = webidl.converters.DOMString(cacheName, prefix, "cacheName"); + return this.#caches.delete(cacheName); + } + /** + * @see https://w3c.github.io/ServiceWorker/#cache-storage-keys + * @returns {Promise} + */ + async keys() { + webidl.brandCheck(this, CacheStorage); + return [...this.#caches.keys()]; + } + }; + Object.defineProperties(CacheStorage.prototype, { + [Symbol.toStringTag]: { + value: "CacheStorage", + configurable: true + }, + match: kEnumerableProperty, + has: kEnumerableProperty, + open: kEnumerableProperty, + delete: kEnumerableProperty, + keys: kEnumerableProperty + }); + module.exports = { CacheStorage }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/cookies/constants.js +var require_constants$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => { + module.exports = { + maxAttributeValueSize: 1024, + maxNameValuePairSize: 4096 + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/cookies/util.js +var require_util$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => { + /** + * @param {string} value + * @returns {boolean} + */ + function isCTLExcludingHtab(value) { + for (let i = 0; i < value.length; ++i) { + const code = value.charCodeAt(i); + if (code >= 0 && code <= 8 || code >= 10 && code <= 31 || code === 127) return true; + } + return false; + } + /** + CHAR = + token = 1* + separators = "(" | ")" | "<" | ">" | "@" + | "," | ";" | ":" | "\" | <"> + | "/" | "[" | "]" | "?" | "=" + | "{" | "}" | SP | HT + * @param {string} name + */ + function validateCookieName(name) { + for (let i = 0; i < name.length; ++i) { + const code = name.charCodeAt(i); + if (code < 33 || code > 126 || code === 34 || code === 40 || code === 41 || code === 60 || code === 62 || code === 64 || code === 44 || code === 59 || code === 58 || code === 92 || code === 47 || code === 91 || code === 93 || code === 63 || code === 61 || code === 123 || code === 125) throw new Error("Invalid cookie name"); + } + } + /** + cookie-value = *cookie-octet / ( DQUOTE *cookie-octet DQUOTE ) + cookie-octet = %x21 / %x23-2B / %x2D-3A / %x3C-5B / %x5D-7E + ; US-ASCII characters excluding CTLs, + ; whitespace DQUOTE, comma, semicolon, + ; and backslash + * @param {string} value + */ + function validateCookieValue(value) { + let len = value.length; + let i = 0; + if (value[0] === "\"") { + if (len === 1 || value[len - 1] !== "\"") throw new Error("Invalid cookie value"); + --len; + ++i; + } + while (i < len) { + const code = value.charCodeAt(i++); + if (code < 33 || code > 126 || code === 34 || code === 44 || code === 59 || code === 92) throw new Error("Invalid cookie value"); + } + } + /** + * path-value = + * @param {string} path + */ + function validateCookiePath(path) { + for (let i = 0; i < path.length; ++i) { + const code = path.charCodeAt(i); + if (code < 32 || code === 127 || code === 59) throw new Error("Invalid cookie path"); + } + } + /** + * I have no idea why these values aren't allowed to be honest, + * but Deno tests these. - Khafra + * @param {string} domain + */ + function validateCookieDomain(domain) { + if (domain.startsWith("-") || domain.endsWith(".") || domain.endsWith("-")) throw new Error("Invalid cookie domain"); + } + const IMFDays = [ + "Sun", + "Mon", + "Tue", + "Wed", + "Thu", + "Fri", + "Sat" + ]; + const IMFMonths = [ + "Jan", + "Feb", + "Mar", + "Apr", + "May", + "Jun", + "Jul", + "Aug", + "Sep", + "Oct", + "Nov", + "Dec" + ]; + const IMFPaddedNumbers = Array(61).fill(0).map((_, i) => i.toString().padStart(2, "0")); + /** + * @see https://www.rfc-editor.org/rfc/rfc7231#section-7.1.1.1 + * @param {number|Date} date + IMF-fixdate = day-name "," SP date1 SP time-of-day SP GMT + ; fixed length/zone/capitalization subset of the format + ; see Section 3.3 of [RFC5322] + + day-name = %x4D.6F.6E ; "Mon", case-sensitive + / %x54.75.65 ; "Tue", case-sensitive + / %x57.65.64 ; "Wed", case-sensitive + / %x54.68.75 ; "Thu", case-sensitive + / %x46.72.69 ; "Fri", case-sensitive + / %x53.61.74 ; "Sat", case-sensitive + / %x53.75.6E ; "Sun", case-sensitive + date1 = day SP month SP year + ; e.g., 02 Jun 1982 + + day = 2DIGIT + month = %x4A.61.6E ; "Jan", case-sensitive + / %x46.65.62 ; "Feb", case-sensitive + / %x4D.61.72 ; "Mar", case-sensitive + / %x41.70.72 ; "Apr", case-sensitive + / %x4D.61.79 ; "May", case-sensitive + / %x4A.75.6E ; "Jun", case-sensitive + / %x4A.75.6C ; "Jul", case-sensitive + / %x41.75.67 ; "Aug", case-sensitive + / %x53.65.70 ; "Sep", case-sensitive + / %x4F.63.74 ; "Oct", case-sensitive + / %x4E.6F.76 ; "Nov", case-sensitive + / %x44.65.63 ; "Dec", case-sensitive + year = 4DIGIT + + GMT = %x47.4D.54 ; "GMT", case-sensitive + + time-of-day = hour ":" minute ":" second + ; 00:00:00 - 23:59:60 (leap second) + + hour = 2DIGIT + minute = 2DIGIT + second = 2DIGIT + */ + function toIMFDate(date) { + if (typeof date === "number") date = new Date(date); + return `${IMFDays[date.getUTCDay()]}, ${IMFPaddedNumbers[date.getUTCDate()]} ${IMFMonths[date.getUTCMonth()]} ${date.getUTCFullYear()} ${IMFPaddedNumbers[date.getUTCHours()]}:${IMFPaddedNumbers[date.getUTCMinutes()]}:${IMFPaddedNumbers[date.getUTCSeconds()]} GMT`; + } + /** + max-age-av = "Max-Age=" non-zero-digit *DIGIT + ; In practice, both expires-av and max-age-av + ; are limited to dates representable by the + ; user agent. + * @param {number} maxAge + */ + function validateCookieMaxAge(maxAge) { + if (maxAge < 0) throw new Error("Invalid cookie max-age"); + } + /** + * @see https://www.rfc-editor.org/rfc/rfc6265#section-4.1.1 + * @param {import('./index').Cookie} cookie + */ + function stringify(cookie) { + if (cookie.name.length === 0) return null; + validateCookieName(cookie.name); + validateCookieValue(cookie.value); + const out = [`${cookie.name}=${cookie.value}`]; + if (cookie.name.startsWith("__Secure-")) cookie.secure = true; + if (cookie.name.startsWith("__Host-")) { + cookie.secure = true; + cookie.domain = null; + cookie.path = "/"; + } + if (cookie.secure) out.push("Secure"); + if (cookie.httpOnly) out.push("HttpOnly"); + if (typeof cookie.maxAge === "number") { + validateCookieMaxAge(cookie.maxAge); + out.push(`Max-Age=${cookie.maxAge}`); + } + if (cookie.domain) { + validateCookieDomain(cookie.domain); + out.push(`Domain=${cookie.domain}`); + } + if (cookie.path) { + validateCookiePath(cookie.path); + out.push(`Path=${cookie.path}`); + } + if (cookie.expires && cookie.expires.toString() !== "Invalid Date") out.push(`Expires=${toIMFDate(cookie.expires)}`); + if (cookie.sameSite) out.push(`SameSite=${cookie.sameSite}`); + for (const part of cookie.unparsed) { + if (!part.includes("=")) throw new Error("Invalid unparsed"); + const [key, ...value] = part.split("="); + out.push(`${key.trim()}=${value.join("=")}`); + } + return out.join("; "); + } + module.exports = { + isCTLExcludingHtab, + validateCookieName, + validateCookiePath, + validateCookieValue, + toIMFDate, + stringify + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/cookies/parse.js +var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { maxNameValuePairSize, maxAttributeValueSize } = require_constants$1(); + const { isCTLExcludingHtab } = require_util$2(); + const { collectASequenceOfCodePointsFast } = require_data_url(); + const assert$1 = __require("node:assert"); + /** + * @description Parses the field-value attributes of a set-cookie header string. + * @see https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4 + * @param {string} header + * @returns if the header is invalid, null will be returned + */ + function parseSetCookie(header) { + if (isCTLExcludingHtab(header)) return null; + let nameValuePair = ""; + let unparsedAttributes = ""; + let name = ""; + let value = ""; + if (header.includes(";")) { + const position = { position: 0 }; + nameValuePair = collectASequenceOfCodePointsFast(";", header, position); + unparsedAttributes = header.slice(position.position); + } else nameValuePair = header; + if (!nameValuePair.includes("=")) value = nameValuePair; + else { + const position = { position: 0 }; + name = collectASequenceOfCodePointsFast("=", nameValuePair, position); + value = nameValuePair.slice(position.position + 1); + } + name = name.trim(); + value = value.trim(); + if (name.length + value.length > maxNameValuePairSize) return null; + return { + name, + value, + ...parseUnparsedAttributes(unparsedAttributes) + }; + } + /** + * Parses the remaining attributes of a set-cookie header + * @see https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4 + * @param {string} unparsedAttributes + * @param {[Object.]={}} cookieAttributeList + */ + function parseUnparsedAttributes(unparsedAttributes, cookieAttributeList = {}) { + if (unparsedAttributes.length === 0) return cookieAttributeList; + assert$1(unparsedAttributes[0] === ";"); + unparsedAttributes = unparsedAttributes.slice(1); + let cookieAv = ""; + if (unparsedAttributes.includes(";")) { + cookieAv = collectASequenceOfCodePointsFast(";", unparsedAttributes, { position: 0 }); + unparsedAttributes = unparsedAttributes.slice(cookieAv.length); + } else { + cookieAv = unparsedAttributes; + unparsedAttributes = ""; + } + let attributeName = ""; + let attributeValue = ""; + if (cookieAv.includes("=")) { + const position = { position: 0 }; + attributeName = collectASequenceOfCodePointsFast("=", cookieAv, position); + attributeValue = cookieAv.slice(position.position + 1); + } else attributeName = cookieAv; + attributeName = attributeName.trim(); + attributeValue = attributeValue.trim(); + if (attributeValue.length > maxAttributeValueSize) return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + const attributeNameLowercase = attributeName.toLowerCase(); + if (attributeNameLowercase === "expires") cookieAttributeList.expires = new Date(attributeValue); + else if (attributeNameLowercase === "max-age") { + const charCode = attributeValue.charCodeAt(0); + if ((charCode < 48 || charCode > 57) && attributeValue[0] !== "-") return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + if (!/^\d+$/.test(attributeValue)) return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + cookieAttributeList.maxAge = Number(attributeValue); + } else if (attributeNameLowercase === "domain") { + let cookieDomain = attributeValue; + if (cookieDomain[0] === ".") cookieDomain = cookieDomain.slice(1); + cookieDomain = cookieDomain.toLowerCase(); + cookieAttributeList.domain = cookieDomain; + } else if (attributeNameLowercase === "path") { + let cookiePath = ""; + if (attributeValue.length === 0 || attributeValue[0] !== "/") cookiePath = "/"; + else cookiePath = attributeValue; + cookieAttributeList.path = cookiePath; + } else if (attributeNameLowercase === "secure") cookieAttributeList.secure = true; + else if (attributeNameLowercase === "httponly") cookieAttributeList.httpOnly = true; + else if (attributeNameLowercase === "samesite") { + let enforcement = "Default"; + const attributeValueLowercase = attributeValue.toLowerCase(); + if (attributeValueLowercase.includes("none")) enforcement = "None"; + if (attributeValueLowercase.includes("strict")) enforcement = "Strict"; + if (attributeValueLowercase.includes("lax")) enforcement = "Lax"; + cookieAttributeList.sameSite = enforcement; + } else { + cookieAttributeList.unparsed ??= []; + cookieAttributeList.unparsed.push(`${attributeName}=${attributeValue}`); + } + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + module.exports = { + parseSetCookie, + parseUnparsedAttributes + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/cookies/index.js +var require_cookies = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { parseSetCookie } = require_parse(); + const { stringify } = require_util$2(); + const { webidl } = require_webidl(); + const { Headers } = require_headers(); + /** + * @typedef {Object} Cookie + * @property {string} name + * @property {string} value + * @property {Date|number|undefined} expires + * @property {number|undefined} maxAge + * @property {string|undefined} domain + * @property {string|undefined} path + * @property {boolean|undefined} secure + * @property {boolean|undefined} httpOnly + * @property {'Strict'|'Lax'|'None'} sameSite + * @property {string[]} unparsed + */ + /** + * @param {Headers} headers + * @returns {Record} + */ + function getCookies(headers) { + webidl.argumentLengthCheck(arguments, 1, "getCookies"); + webidl.brandCheck(headers, Headers, { strict: false }); + const cookie = headers.get("cookie"); + const out = {}; + if (!cookie) return out; + for (const piece of cookie.split(";")) { + const [name, ...value] = piece.split("="); + out[name.trim()] = value.join("="); + } + return out; + } + /** + * @param {Headers} headers + * @param {string} name + * @param {{ path?: string, domain?: string }|undefined} attributes + * @returns {void} + */ + function deleteCookie(headers, name, attributes) { + webidl.brandCheck(headers, Headers, { strict: false }); + const prefix = "deleteCookie"; + webidl.argumentLengthCheck(arguments, 2, prefix); + name = webidl.converters.DOMString(name, prefix, "name"); + attributes = webidl.converters.DeleteCookieAttributes(attributes); + setCookie(headers, { + name, + value: "", + expires: /* @__PURE__ */ new Date(0), + ...attributes + }); + } + /** + * @param {Headers} headers + * @returns {Cookie[]} + */ + function getSetCookies(headers) { + webidl.argumentLengthCheck(arguments, 1, "getSetCookies"); + webidl.brandCheck(headers, Headers, { strict: false }); + const cookies = headers.getSetCookie(); + if (!cookies) return []; + return cookies.map((pair) => parseSetCookie(pair)); + } + /** + * @param {Headers} headers + * @param {Cookie} cookie + * @returns {void} + */ + function setCookie(headers, cookie) { + webidl.argumentLengthCheck(arguments, 2, "setCookie"); + webidl.brandCheck(headers, Headers, { strict: false }); + cookie = webidl.converters.Cookie(cookie); + const str = stringify(cookie); + if (str) headers.append("Set-Cookie", str); + } + webidl.converters.DeleteCookieAttributes = webidl.dictionaryConverter([{ + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "path", + defaultValue: () => null + }, { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "domain", + defaultValue: () => null + }]); + webidl.converters.Cookie = webidl.dictionaryConverter([ + { + converter: webidl.converters.DOMString, + key: "name" + }, + { + converter: webidl.converters.DOMString, + key: "value" + }, + { + converter: webidl.nullableConverter((value) => { + if (typeof value === "number") return webidl.converters["unsigned long long"](value); + return new Date(value); + }), + key: "expires", + defaultValue: () => null + }, + { + converter: webidl.nullableConverter(webidl.converters["long long"]), + key: "maxAge", + defaultValue: () => null + }, + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "domain", + defaultValue: () => null + }, + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "path", + defaultValue: () => null + }, + { + converter: webidl.nullableConverter(webidl.converters.boolean), + key: "secure", + defaultValue: () => null + }, + { + converter: webidl.nullableConverter(webidl.converters.boolean), + key: "httpOnly", + defaultValue: () => null + }, + { + converter: webidl.converters.USVString, + key: "sameSite", + allowedValues: [ + "Strict", + "Lax", + "None" + ] + }, + { + converter: webidl.sequenceConverter(webidl.converters.DOMString), + key: "unparsed", + defaultValue: () => new Array(0) + } + ]); + module.exports = { + getCookies, + deleteCookie, + getSetCookies, + setCookie + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/websocket/events.js +var require_events = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { webidl } = require_webidl(); + const { kEnumerableProperty } = require_util$7(); + const { kConstruct } = require_symbols$4(); + const { MessagePort } = __require("node:worker_threads"); + /** + * @see https://html.spec.whatwg.org/multipage/comms.html#messageevent + */ + var MessageEvent = class MessageEvent extends Event { + #eventInit; + constructor(type, eventInitDict = {}) { + if (type === kConstruct) { + super(arguments[1], arguments[2]); + webidl.util.markAsUncloneable(this); + return; + } + const prefix = "MessageEvent constructor"; + webidl.argumentLengthCheck(arguments, 1, prefix); + type = webidl.converters.DOMString(type, prefix, "type"); + eventInitDict = webidl.converters.MessageEventInit(eventInitDict, prefix, "eventInitDict"); + super(type, eventInitDict); + this.#eventInit = eventInitDict; + webidl.util.markAsUncloneable(this); + } + get data() { + webidl.brandCheck(this, MessageEvent); + return this.#eventInit.data; + } + get origin() { + webidl.brandCheck(this, MessageEvent); + return this.#eventInit.origin; + } + get lastEventId() { + webidl.brandCheck(this, MessageEvent); + return this.#eventInit.lastEventId; + } + get source() { + webidl.brandCheck(this, MessageEvent); + return this.#eventInit.source; + } + get ports() { + webidl.brandCheck(this, MessageEvent); + if (!Object.isFrozen(this.#eventInit.ports)) Object.freeze(this.#eventInit.ports); + return this.#eventInit.ports; + } + initMessageEvent(type, bubbles = false, cancelable = false, data = null, origin = "", lastEventId = "", source = null, ports = []) { + webidl.brandCheck(this, MessageEvent); + webidl.argumentLengthCheck(arguments, 1, "MessageEvent.initMessageEvent"); + return new MessageEvent(type, { + bubbles, + cancelable, + data, + origin, + lastEventId, + source, + ports + }); + } + static createFastMessageEvent(type, init) { + const messageEvent = new MessageEvent(kConstruct, type, init); + messageEvent.#eventInit = init; + messageEvent.#eventInit.data ??= null; + messageEvent.#eventInit.origin ??= ""; + messageEvent.#eventInit.lastEventId ??= ""; + messageEvent.#eventInit.source ??= null; + messageEvent.#eventInit.ports ??= []; + return messageEvent; + } + }; + const { createFastMessageEvent } = MessageEvent; + delete MessageEvent.createFastMessageEvent; + /** + * @see https://websockets.spec.whatwg.org/#the-closeevent-interface + */ + var CloseEvent = class CloseEvent extends Event { + #eventInit; + constructor(type, eventInitDict = {}) { + const prefix = "CloseEvent constructor"; + webidl.argumentLengthCheck(arguments, 1, prefix); + type = webidl.converters.DOMString(type, prefix, "type"); + eventInitDict = webidl.converters.CloseEventInit(eventInitDict); + super(type, eventInitDict); + this.#eventInit = eventInitDict; + webidl.util.markAsUncloneable(this); + } + get wasClean() { + webidl.brandCheck(this, CloseEvent); + return this.#eventInit.wasClean; + } + get code() { + webidl.brandCheck(this, CloseEvent); + return this.#eventInit.code; + } + get reason() { + webidl.brandCheck(this, CloseEvent); + return this.#eventInit.reason; + } + }; + var ErrorEvent = class ErrorEvent extends Event { + #eventInit; + constructor(type, eventInitDict) { + const prefix = "ErrorEvent constructor"; + webidl.argumentLengthCheck(arguments, 1, prefix); + super(type, eventInitDict); + webidl.util.markAsUncloneable(this); + type = webidl.converters.DOMString(type, prefix, "type"); + eventInitDict = webidl.converters.ErrorEventInit(eventInitDict ?? {}); + this.#eventInit = eventInitDict; + } + get message() { + webidl.brandCheck(this, ErrorEvent); + return this.#eventInit.message; + } + get filename() { + webidl.brandCheck(this, ErrorEvent); + return this.#eventInit.filename; + } + get lineno() { + webidl.brandCheck(this, ErrorEvent); + return this.#eventInit.lineno; + } + get colno() { + webidl.brandCheck(this, ErrorEvent); + return this.#eventInit.colno; + } + get error() { + webidl.brandCheck(this, ErrorEvent); + return this.#eventInit.error; + } + }; + Object.defineProperties(MessageEvent.prototype, { + [Symbol.toStringTag]: { + value: "MessageEvent", + configurable: true + }, + data: kEnumerableProperty, + origin: kEnumerableProperty, + lastEventId: kEnumerableProperty, + source: kEnumerableProperty, + ports: kEnumerableProperty, + initMessageEvent: kEnumerableProperty + }); + Object.defineProperties(CloseEvent.prototype, { + [Symbol.toStringTag]: { + value: "CloseEvent", + configurable: true + }, + reason: kEnumerableProperty, + code: kEnumerableProperty, + wasClean: kEnumerableProperty + }); + Object.defineProperties(ErrorEvent.prototype, { + [Symbol.toStringTag]: { + value: "ErrorEvent", + configurable: true + }, + message: kEnumerableProperty, + filename: kEnumerableProperty, + lineno: kEnumerableProperty, + colno: kEnumerableProperty, + error: kEnumerableProperty + }); + webidl.converters.MessagePort = webidl.interfaceConverter(MessagePort); + webidl.converters["sequence"] = webidl.sequenceConverter(webidl.converters.MessagePort); + const eventInit = [ + { + key: "bubbles", + converter: webidl.converters.boolean, + defaultValue: () => false + }, + { + key: "cancelable", + converter: webidl.converters.boolean, + defaultValue: () => false + }, + { + key: "composed", + converter: webidl.converters.boolean, + defaultValue: () => false + } + ]; + webidl.converters.MessageEventInit = webidl.dictionaryConverter([ + ...eventInit, + { + key: "data", + converter: webidl.converters.any, + defaultValue: () => null + }, + { + key: "origin", + converter: webidl.converters.USVString, + defaultValue: () => "" + }, + { + key: "lastEventId", + converter: webidl.converters.DOMString, + defaultValue: () => "" + }, + { + key: "source", + converter: webidl.nullableConverter(webidl.converters.MessagePort), + defaultValue: () => null + }, + { + key: "ports", + converter: webidl.converters["sequence"], + defaultValue: () => new Array(0) + } + ]); + webidl.converters.CloseEventInit = webidl.dictionaryConverter([ + ...eventInit, + { + key: "wasClean", + converter: webidl.converters.boolean, + defaultValue: () => false + }, + { + key: "code", + converter: webidl.converters["unsigned short"], + defaultValue: () => 0 + }, + { + key: "reason", + converter: webidl.converters.USVString, + defaultValue: () => "" + } + ]); + webidl.converters.ErrorEventInit = webidl.dictionaryConverter([ + ...eventInit, + { + key: "message", + converter: webidl.converters.DOMString, + defaultValue: () => "" + }, + { + key: "filename", + converter: webidl.converters.USVString, + defaultValue: () => "" + }, + { + key: "lineno", + converter: webidl.converters["unsigned long"], + defaultValue: () => 0 + }, + { + key: "colno", + converter: webidl.converters["unsigned long"], + defaultValue: () => 0 + }, + { + key: "error", + converter: webidl.converters.any + } + ]); + module.exports = { + MessageEvent, + CloseEvent, + ErrorEvent, + createFastMessageEvent + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/websocket/constants.js +var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => { + module.exports = { + uid: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11", + sentCloseFrameState: { + NOT_SENT: 0, + PROCESSING: 1, + SENT: 2 + }, + staticPropertyDescriptors: { + enumerable: true, + writable: false, + configurable: false + }, + states: { + CONNECTING: 0, + OPEN: 1, + CLOSING: 2, + CLOSED: 3 + }, + opcodes: { + CONTINUATION: 0, + TEXT: 1, + BINARY: 2, + CLOSE: 8, + PING: 9, + PONG: 10 + }, + maxUnsigned16Bit: 2 ** 16 - 1, + parserStates: { + INFO: 0, + PAYLOADLENGTH_16: 2, + PAYLOADLENGTH_64: 3, + READ_DATA: 4 + }, + emptyBuffer: Buffer.allocUnsafe(0), + sendHints: { + string: 1, + typedArray: 2, + arrayBuffer: 3, + blob: 4 + } + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/websocket/symbols.js +var require_symbols = /* @__PURE__ */ __commonJSMin(((exports, module) => { + module.exports = { + kWebSocketURL: Symbol("url"), + kReadyState: Symbol("ready state"), + kController: Symbol("controller"), + kResponse: Symbol("response"), + kBinaryType: Symbol("binary type"), + kSentClose: Symbol("sent close"), + kReceivedClose: Symbol("received close"), + kByteParser: Symbol("byte parser") + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/websocket/util.js +var require_util$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = require_symbols(); + const { states, opcodes } = require_constants(); + const { ErrorEvent, createFastMessageEvent } = require_events(); + const { isUtf8 } = __require("node:buffer"); + const { collectASequenceOfCodePointsFast, removeHTTPWhitespace } = require_data_url(); + /** + * @param {import('./websocket').WebSocket} ws + * @returns {boolean} + */ + function isConnecting(ws) { + return ws[kReadyState] === states.CONNECTING; + } + /** + * @param {import('./websocket').WebSocket} ws + * @returns {boolean} + */ + function isEstablished(ws) { + return ws[kReadyState] === states.OPEN; + } + /** + * @param {import('./websocket').WebSocket} ws + * @returns {boolean} + */ + function isClosing(ws) { + return ws[kReadyState] === states.CLOSING; + } + /** + * @param {import('./websocket').WebSocket} ws + * @returns {boolean} + */ + function isClosed(ws) { + return ws[kReadyState] === states.CLOSED; + } + /** + * @see https://dom.spec.whatwg.org/#concept-event-fire + * @param {string} e + * @param {EventTarget} target + * @param {(...args: ConstructorParameters) => Event} eventFactory + * @param {EventInit | undefined} eventInitDict + */ + function fireEvent(e, target, eventFactory = (type, init) => new Event(type, init), eventInitDict = {}) { + const event = eventFactory(e, eventInitDict); + target.dispatchEvent(event); + } + /** + * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol + * @param {import('./websocket').WebSocket} ws + * @param {number} type Opcode + * @param {Buffer} data application data + */ + function websocketMessageReceived(ws, type, data) { + if (ws[kReadyState] !== states.OPEN) return; + let dataForEvent; + if (type === opcodes.TEXT) try { + dataForEvent = utf8Decode(data); + } catch { + failWebsocketConnection(ws, "Received invalid UTF-8 in text frame."); + return; + } + else if (type === opcodes.BINARY) { + if (ws[kBinaryType] === "blob") dataForEvent = new Blob([data]); + else dataForEvent = toArrayBuffer(data); + } + fireEvent("message", ws, createFastMessageEvent, { + origin: ws[kWebSocketURL].origin, + data: dataForEvent + }); + } + function toArrayBuffer(buffer) { + if (buffer.byteLength === buffer.buffer.byteLength) return buffer.buffer; + return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength); + } + /** + * @see https://datatracker.ietf.org/doc/html/rfc6455 + * @see https://datatracker.ietf.org/doc/html/rfc2616 + * @see https://bugs.chromium.org/p/chromium/issues/detail?id=398407 + * @param {string} protocol + */ + function isValidSubprotocol(protocol) { + if (protocol.length === 0) return false; + for (let i = 0; i < protocol.length; ++i) { + const code = protocol.charCodeAt(i); + if (code < 33 || code > 126 || code === 34 || code === 40 || code === 41 || code === 44 || code === 47 || code === 58 || code === 59 || code === 60 || code === 61 || code === 62 || code === 63 || code === 64 || code === 91 || code === 92 || code === 93 || code === 123 || code === 125) return false; + } + return true; + } + /** + * @see https://datatracker.ietf.org/doc/html/rfc6455#section-7-4 + * @param {number} code + */ + function isValidStatusCode(code) { + if (code >= 1e3 && code < 1015) return code !== 1004 && code !== 1005 && code !== 1006; + return code >= 3e3 && code <= 4999; + } + /** + * @param {import('./websocket').WebSocket} ws + * @param {string|undefined} reason + */ + function failWebsocketConnection(ws, reason) { + const { [kController]: controller, [kResponse]: response } = ws; + controller.abort(); + if (response?.socket && !response.socket.destroyed) response.socket.destroy(); + if (reason) fireEvent("error", ws, (type, init) => new ErrorEvent(type, init), { + error: new Error(reason), + message: reason + }); + } + /** + * @see https://datatracker.ietf.org/doc/html/rfc6455#section-5.5 + * @param {number} opcode + */ + function isControlFrame(opcode) { + return opcode === opcodes.CLOSE || opcode === opcodes.PING || opcode === opcodes.PONG; + } + function isContinuationFrame(opcode) { + return opcode === opcodes.CONTINUATION; + } + function isTextBinaryFrame(opcode) { + return opcode === opcodes.TEXT || opcode === opcodes.BINARY; + } + function isValidOpcode(opcode) { + return isTextBinaryFrame(opcode) || isContinuationFrame(opcode) || isControlFrame(opcode); + } + /** + * Parses a Sec-WebSocket-Extensions header value. + * @param {string} extensions + * @returns {Map} + */ + function parseExtensions(extensions) { + const position = { position: 0 }; + const extensionList = /* @__PURE__ */ new Map(); + while (position.position < extensions.length) { + const [name, value = ""] = collectASequenceOfCodePointsFast(";", extensions, position).split("="); + extensionList.set(removeHTTPWhitespace(name, true, false), removeHTTPWhitespace(value, false, true)); + position.position++; + } + return extensionList; + } + /** + * @see https://www.rfc-editor.org/rfc/rfc7692#section-7.1.2.2 + * @description "client-max-window-bits = 1*DIGIT" + * @param {string} value + */ + function isValidClientWindowBits(value) { + for (let i = 0; i < value.length; i++) { + const byte = value.charCodeAt(i); + if (byte < 48 || byte > 57) return false; + } + return true; + } + const hasIntl = typeof process.versions.icu === "string"; + const fatalDecoder = hasIntl ? new TextDecoder("utf-8", { fatal: true }) : void 0; + /** + * Converts a Buffer to utf-8, even on platforms without icu. + * @param {Buffer} buffer + */ + const utf8Decode = hasIntl ? fatalDecoder.decode.bind(fatalDecoder) : function(buffer) { + if (isUtf8(buffer)) return buffer.toString("utf-8"); + throw new TypeError("Invalid utf-8 received."); + }; + module.exports = { + isConnecting, + isEstablished, + isClosing, + isClosed, + fireEvent, + isValidSubprotocol, + isValidStatusCode, + failWebsocketConnection, + websocketMessageReceived, + utf8Decode, + isControlFrame, + isContinuationFrame, + isTextBinaryFrame, + isValidOpcode, + parseExtensions, + isValidClientWindowBits + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/websocket/frame.js +var require_frame = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { maxUnsigned16Bit } = require_constants(); + const BUFFER_SIZE = 16386; + /** @type {import('crypto')} */ + let crypto; + let buffer = null; + let bufIdx = BUFFER_SIZE; + try { + crypto = __require("node:crypto"); + } catch { + crypto = { randomFillSync: function randomFillSync(buffer, _offset, _size) { + for (let i = 0; i < buffer.length; ++i) buffer[i] = Math.random() * 255 | 0; + return buffer; + } }; + } + function generateMask() { + if (bufIdx === BUFFER_SIZE) { + bufIdx = 0; + crypto.randomFillSync(buffer ??= Buffer.allocUnsafe(BUFFER_SIZE), 0, BUFFER_SIZE); + } + return [ + buffer[bufIdx++], + buffer[bufIdx++], + buffer[bufIdx++], + buffer[bufIdx++] + ]; + } + var WebsocketFrameSend = class { + /** + * @param {Buffer|undefined} data + */ + constructor(data) { + this.frameData = data; + } + createFrame(opcode) { + const frameData = this.frameData; + const maskKey = generateMask(); + const bodyLength = frameData?.byteLength ?? 0; + /** @type {number} */ + let payloadLength = bodyLength; + let offset = 6; + if (bodyLength > maxUnsigned16Bit) { + offset += 8; + payloadLength = 127; + } else if (bodyLength > 125) { + offset += 2; + payloadLength = 126; + } + const buffer = Buffer.allocUnsafe(bodyLength + offset); + buffer[0] = buffer[1] = 0; + buffer[0] |= 128; + buffer[0] = (buffer[0] & 240) + opcode; + /*! ws. MIT License. Einar Otto Stangvik */ + buffer[offset - 4] = maskKey[0]; + buffer[offset - 3] = maskKey[1]; + buffer[offset - 2] = maskKey[2]; + buffer[offset - 1] = maskKey[3]; + buffer[1] = payloadLength; + if (payloadLength === 126) buffer.writeUInt16BE(bodyLength, 2); + else if (payloadLength === 127) { + buffer[2] = buffer[3] = 0; + buffer.writeUIntBE(bodyLength, 4, 6); + } + buffer[1] |= 128; + for (let i = 0; i < bodyLength; ++i) buffer[offset + i] = frameData[i] ^ maskKey[i & 3]; + return buffer; + } + }; + module.exports = { WebsocketFrameSend }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/websocket/connection.js +var require_connection = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { uid, states, sentCloseFrameState, emptyBuffer, opcodes } = require_constants(); + const { kReadyState, kSentClose, kByteParser, kReceivedClose, kResponse } = require_symbols(); + const { fireEvent, failWebsocketConnection, isClosing, isClosed, isEstablished, parseExtensions } = require_util$1(); + const { channels } = require_diagnostics(); + const { CloseEvent } = require_events(); + const { makeRequest } = require_request(); + const { fetching } = require_fetch(); + const { Headers, getHeadersList } = require_headers(); + const { getDecodeSplit } = require_util$6(); + const { WebsocketFrameSend } = require_frame(); + /** @type {import('crypto')} */ + let crypto; + try { + crypto = __require("node:crypto"); + } catch {} + /** + * @see https://websockets.spec.whatwg.org/#concept-websocket-establish + * @param {URL} url + * @param {string|string[]} protocols + * @param {import('./websocket').WebSocket} ws + * @param {(response: any, extensions: string[] | undefined) => void} onEstablish + * @param {Partial} options + */ + function establishWebSocketConnection(url, protocols, client, ws, onEstablish, options) { + const requestURL = url; + requestURL.protocol = url.protocol === "ws:" ? "http:" : "https:"; + const request = makeRequest({ + urlList: [requestURL], + client, + serviceWorkers: "none", + referrer: "no-referrer", + mode: "websocket", + credentials: "include", + cache: "no-store", + redirect: "error" + }); + if (options.headers) request.headersList = getHeadersList(new Headers(options.headers)); + const keyValue = crypto.randomBytes(16).toString("base64"); + request.headersList.append("sec-websocket-key", keyValue); + request.headersList.append("sec-websocket-version", "13"); + for (const protocol of protocols) request.headersList.append("sec-websocket-protocol", protocol); + request.headersList.append("sec-websocket-extensions", "permessage-deflate; client_max_window_bits"); + return fetching({ + request, + useParallelQueue: true, + dispatcher: options.dispatcher, + processResponse(response) { + if (response.type === "error" || response.status !== 101) { + failWebsocketConnection(ws, "Received network error or non-101 status code."); + return; + } + if (protocols.length !== 0 && !response.headersList.get("Sec-WebSocket-Protocol")) { + failWebsocketConnection(ws, "Server did not respond with sent protocols."); + return; + } + if (response.headersList.get("Upgrade")?.toLowerCase() !== "websocket") { + failWebsocketConnection(ws, "Server did not set Upgrade header to \"websocket\"."); + return; + } + if (response.headersList.get("Connection")?.toLowerCase() !== "upgrade") { + failWebsocketConnection(ws, "Server did not set Connection header to \"upgrade\"."); + return; + } + if (response.headersList.get("Sec-WebSocket-Accept") !== crypto.createHash("sha1").update(keyValue + uid).digest("base64")) { + failWebsocketConnection(ws, "Incorrect hash received in Sec-WebSocket-Accept header."); + return; + } + const secExtension = response.headersList.get("Sec-WebSocket-Extensions"); + let extensions; + if (secExtension !== null) { + extensions = parseExtensions(secExtension); + if (!extensions.has("permessage-deflate")) { + failWebsocketConnection(ws, "Sec-WebSocket-Extensions header does not match."); + return; + } + } + const secProtocol = response.headersList.get("Sec-WebSocket-Protocol"); + if (secProtocol !== null) { + if (!getDecodeSplit("sec-websocket-protocol", request.headersList).includes(secProtocol)) { + failWebsocketConnection(ws, "Protocol was not set in the opening handshake."); + return; + } + } + response.socket.on("data", onSocketData); + response.socket.on("close", onSocketClose); + response.socket.on("error", onSocketError); + if (channels.open.hasSubscribers) channels.open.publish({ + address: response.socket.address(), + protocol: secProtocol, + extensions: secExtension + }); + onEstablish(response, extensions); + } + }); + } + function closeWebSocketConnection(ws, code, reason, reasonByteLength) { + if (isClosing(ws) || isClosed(ws)) {} else if (!isEstablished(ws)) { + failWebsocketConnection(ws, "Connection was closed before it was established."); + ws[kReadyState] = states.CLOSING; + } else if (ws[kSentClose] === sentCloseFrameState.NOT_SENT) { + ws[kSentClose] = sentCloseFrameState.PROCESSING; + const frame = new WebsocketFrameSend(); + if (code !== void 0 && reason === void 0) { + frame.frameData = Buffer.allocUnsafe(2); + frame.frameData.writeUInt16BE(code, 0); + } else if (code !== void 0 && reason !== void 0) { + frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength); + frame.frameData.writeUInt16BE(code, 0); + frame.frameData.write(reason, 2, "utf-8"); + } else frame.frameData = emptyBuffer; + ws[kResponse].socket.write(frame.createFrame(opcodes.CLOSE)); + ws[kSentClose] = sentCloseFrameState.SENT; + ws[kReadyState] = states.CLOSING; + } else ws[kReadyState] = states.CLOSING; + } + /** + * @param {Buffer} chunk + */ + function onSocketData(chunk) { + if (!this.ws[kByteParser].write(chunk)) this.pause(); + } + /** + * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol + * @see https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.4 + */ + function onSocketClose() { + const { ws } = this; + const { [kResponse]: response } = ws; + response.socket.off("data", onSocketData); + response.socket.off("close", onSocketClose); + response.socket.off("error", onSocketError); + const wasClean = ws[kSentClose] === sentCloseFrameState.SENT && ws[kReceivedClose]; + let code = 1005; + let reason = ""; + const result = ws[kByteParser].closingInfo; + if (result && !result.error) { + code = result.code ?? 1005; + reason = result.reason; + } else if (!ws[kReceivedClose]) code = 1006; + ws[kReadyState] = states.CLOSED; + fireEvent("close", ws, (type, init) => new CloseEvent(type, init), { + wasClean, + code, + reason + }); + if (channels.close.hasSubscribers) channels.close.publish({ + websocket: ws, + code, + reason + }); + } + function onSocketError(error) { + const { ws } = this; + ws[kReadyState] = states.CLOSING; + if (channels.socketError.hasSubscribers) channels.socketError.publish(error); + this.destroy(); + } + module.exports = { + establishWebSocketConnection, + closeWebSocketConnection + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/websocket/permessage-deflate.js +var require_permessage_deflate = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { createInflateRaw, Z_DEFAULT_WINDOWBITS } = __require("node:zlib"); + const { isValidClientWindowBits } = require_util$1(); + const tail = Buffer.from([ + 0, + 0, + 255, + 255 + ]); + const kBuffer = Symbol("kBuffer"); + const kLength = Symbol("kLength"); + var PerMessageDeflate = class { + /** @type {import('node:zlib').InflateRaw} */ + #inflate; + #options = {}; + constructor(extensions) { + this.#options.serverNoContextTakeover = extensions.has("server_no_context_takeover"); + this.#options.serverMaxWindowBits = extensions.get("server_max_window_bits"); + } + decompress(chunk, fin, callback) { + if (!this.#inflate) { + let windowBits = Z_DEFAULT_WINDOWBITS; + if (this.#options.serverMaxWindowBits) { + if (!isValidClientWindowBits(this.#options.serverMaxWindowBits)) { + callback(/* @__PURE__ */ new Error("Invalid server_max_window_bits")); + return; + } + windowBits = Number.parseInt(this.#options.serverMaxWindowBits); + } + this.#inflate = createInflateRaw({ windowBits }); + this.#inflate[kBuffer] = []; + this.#inflate[kLength] = 0; + this.#inflate.on("data", (data) => { + this.#inflate[kBuffer].push(data); + this.#inflate[kLength] += data.length; + }); + this.#inflate.on("error", (err) => { + this.#inflate = null; + callback(err); + }); + } + this.#inflate.write(chunk); + if (fin) this.#inflate.write(tail); + this.#inflate.flush(() => { + const full = Buffer.concat(this.#inflate[kBuffer], this.#inflate[kLength]); + this.#inflate[kBuffer].length = 0; + this.#inflate[kLength] = 0; + callback(null, full); + }); + } + }; + module.exports = { PerMessageDeflate }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/websocket/receiver.js +var require_receiver = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { Writable } = __require("node:stream"); + const assert = __require("node:assert"); + const { parserStates, opcodes, states, emptyBuffer, sentCloseFrameState } = require_constants(); + const { kReadyState, kSentClose, kResponse, kReceivedClose } = require_symbols(); + const { channels } = require_diagnostics(); + const { isValidStatusCode, isValidOpcode, failWebsocketConnection, websocketMessageReceived, utf8Decode, isControlFrame, isTextBinaryFrame, isContinuationFrame } = require_util$1(); + const { WebsocketFrameSend } = require_frame(); + const { closeWebSocketConnection } = require_connection(); + const { PerMessageDeflate } = require_permessage_deflate(); + var ByteParser = class extends Writable { + #buffers = []; + #byteOffset = 0; + #loop = false; + #state = parserStates.INFO; + #info = {}; + #fragments = []; + /** @type {Map} */ + #extensions; + constructor(ws, extensions) { + super(); + this.ws = ws; + this.#extensions = extensions == null ? /* @__PURE__ */ new Map() : extensions; + if (this.#extensions.has("permessage-deflate")) this.#extensions.set("permessage-deflate", new PerMessageDeflate(extensions)); + } + /** + * @param {Buffer} chunk + * @param {() => void} callback + */ + _write(chunk, _, callback) { + this.#buffers.push(chunk); + this.#byteOffset += chunk.length; + this.#loop = true; + this.run(callback); + } + /** + * Runs whenever a new chunk is received. + * Callback is called whenever there are no more chunks buffering, + * or not enough bytes are buffered to parse. + */ + run(callback) { + while (this.#loop) if (this.#state === parserStates.INFO) { + if (this.#byteOffset < 2) return callback(); + const buffer = this.consume(2); + const fin = (buffer[0] & 128) !== 0; + const opcode = buffer[0] & 15; + const masked = (buffer[1] & 128) === 128; + const fragmented = !fin && opcode !== opcodes.CONTINUATION; + const payloadLength = buffer[1] & 127; + const rsv1 = buffer[0] & 64; + const rsv2 = buffer[0] & 32; + const rsv3 = buffer[0] & 16; + if (!isValidOpcode(opcode)) { + failWebsocketConnection(this.ws, "Invalid opcode received"); + return callback(); + } + if (masked) { + failWebsocketConnection(this.ws, "Frame cannot be masked"); + return callback(); + } + if (rsv1 !== 0 && !this.#extensions.has("permessage-deflate")) { + failWebsocketConnection(this.ws, "Expected RSV1 to be clear."); + return; + } + if (rsv2 !== 0 || rsv3 !== 0) { + failWebsocketConnection(this.ws, "RSV1, RSV2, RSV3 must be clear"); + return; + } + if (fragmented && !isTextBinaryFrame(opcode)) { + failWebsocketConnection(this.ws, "Invalid frame type was fragmented."); + return; + } + if (isTextBinaryFrame(opcode) && this.#fragments.length > 0) { + failWebsocketConnection(this.ws, "Expected continuation frame"); + return; + } + if (this.#info.fragmented && fragmented) { + failWebsocketConnection(this.ws, "Fragmented frame exceeded 125 bytes."); + return; + } + if ((payloadLength > 125 || fragmented) && isControlFrame(opcode)) { + failWebsocketConnection(this.ws, "Control frame either too large or fragmented"); + return; + } + if (isContinuationFrame(opcode) && this.#fragments.length === 0 && !this.#info.compressed) { + failWebsocketConnection(this.ws, "Unexpected continuation frame"); + return; + } + if (payloadLength <= 125) { + this.#info.payloadLength = payloadLength; + this.#state = parserStates.READ_DATA; + } else if (payloadLength === 126) this.#state = parserStates.PAYLOADLENGTH_16; + else if (payloadLength === 127) this.#state = parserStates.PAYLOADLENGTH_64; + if (isTextBinaryFrame(opcode)) { + this.#info.binaryType = opcode; + this.#info.compressed = rsv1 !== 0; + } + this.#info.opcode = opcode; + this.#info.masked = masked; + this.#info.fin = fin; + this.#info.fragmented = fragmented; + } else if (this.#state === parserStates.PAYLOADLENGTH_16) { + if (this.#byteOffset < 2) return callback(); + const buffer = this.consume(2); + this.#info.payloadLength = buffer.readUInt16BE(0); + this.#state = parserStates.READ_DATA; + } else if (this.#state === parserStates.PAYLOADLENGTH_64) { + if (this.#byteOffset < 8) return callback(); + const buffer = this.consume(8); + const upper = buffer.readUInt32BE(0); + if (upper > 2 ** 31 - 1) { + failWebsocketConnection(this.ws, "Received payload length > 2^31 bytes."); + return; + } + const lower = buffer.readUInt32BE(4); + this.#info.payloadLength = (upper << 8) + lower; + this.#state = parserStates.READ_DATA; + } else if (this.#state === parserStates.READ_DATA) { + if (this.#byteOffset < this.#info.payloadLength) return callback(); + const body = this.consume(this.#info.payloadLength); + if (isControlFrame(this.#info.opcode)) { + this.#loop = this.parseControlFrame(body); + this.#state = parserStates.INFO; + } else if (!this.#info.compressed) { + this.#fragments.push(body); + if (!this.#info.fragmented && this.#info.fin) { + const fullMessage = Buffer.concat(this.#fragments); + websocketMessageReceived(this.ws, this.#info.binaryType, fullMessage); + this.#fragments.length = 0; + } + this.#state = parserStates.INFO; + } else { + this.#extensions.get("permessage-deflate").decompress(body, this.#info.fin, (error, data) => { + if (error) { + closeWebSocketConnection(this.ws, 1007, error.message, error.message.length); + return; + } + this.#fragments.push(data); + if (!this.#info.fin) { + this.#state = parserStates.INFO; + this.#loop = true; + this.run(callback); + return; + } + websocketMessageReceived(this.ws, this.#info.binaryType, Buffer.concat(this.#fragments)); + this.#loop = true; + this.#state = parserStates.INFO; + this.#fragments.length = 0; + this.run(callback); + }); + this.#loop = false; + break; + } + } + } + /** + * Take n bytes from the buffered Buffers + * @param {number} n + * @returns {Buffer} + */ + consume(n) { + if (n > this.#byteOffset) throw new Error("Called consume() before buffers satiated."); + else if (n === 0) return emptyBuffer; + if (this.#buffers[0].length === n) { + this.#byteOffset -= this.#buffers[0].length; + return this.#buffers.shift(); + } + const buffer = Buffer.allocUnsafe(n); + let offset = 0; + while (offset !== n) { + const next = this.#buffers[0]; + const { length } = next; + if (length + offset === n) { + buffer.set(this.#buffers.shift(), offset); + break; + } else if (length + offset > n) { + buffer.set(next.subarray(0, n - offset), offset); + this.#buffers[0] = next.subarray(n - offset); + break; + } else { + buffer.set(this.#buffers.shift(), offset); + offset += next.length; + } + } + this.#byteOffset -= n; + return buffer; + } + parseCloseBody(data) { + assert(data.length !== 1); + /** @type {number|undefined} */ + let code; + if (data.length >= 2) code = data.readUInt16BE(0); + if (code !== void 0 && !isValidStatusCode(code)) return { + code: 1002, + reason: "Invalid status code", + error: true + }; + /** @type {Buffer} */ + let reason = data.subarray(2); + if (reason[0] === 239 && reason[1] === 187 && reason[2] === 191) reason = reason.subarray(3); + try { + reason = utf8Decode(reason); + } catch { + return { + code: 1007, + reason: "Invalid UTF-8", + error: true + }; + } + return { + code, + reason, + error: false + }; + } + /** + * Parses control frames. + * @param {Buffer} body + */ + parseControlFrame(body) { + const { opcode, payloadLength } = this.#info; + if (opcode === opcodes.CLOSE) { + if (payloadLength === 1) { + failWebsocketConnection(this.ws, "Received close frame with a 1-byte body."); + return false; + } + this.#info.closeInfo = this.parseCloseBody(body); + if (this.#info.closeInfo.error) { + const { code, reason } = this.#info.closeInfo; + closeWebSocketConnection(this.ws, code, reason, reason.length); + failWebsocketConnection(this.ws, reason); + return false; + } + if (this.ws[kSentClose] !== sentCloseFrameState.SENT) { + let body = emptyBuffer; + if (this.#info.closeInfo.code) { + body = Buffer.allocUnsafe(2); + body.writeUInt16BE(this.#info.closeInfo.code, 0); + } + const closeFrame = new WebsocketFrameSend(body); + this.ws[kResponse].socket.write(closeFrame.createFrame(opcodes.CLOSE), (err) => { + if (!err) this.ws[kSentClose] = sentCloseFrameState.SENT; + }); + } + this.ws[kReadyState] = states.CLOSING; + this.ws[kReceivedClose] = true; + return false; + } else if (opcode === opcodes.PING) { + if (!this.ws[kReceivedClose]) { + const frame = new WebsocketFrameSend(body); + this.ws[kResponse].socket.write(frame.createFrame(opcodes.PONG)); + if (channels.ping.hasSubscribers) channels.ping.publish({ payload: body }); + } + } else if (opcode === opcodes.PONG) { + if (channels.pong.hasSubscribers) channels.pong.publish({ payload: body }); + } + return true; + } + get closingInfo() { + return this.#info.closeInfo; + } + }; + module.exports = { ByteParser }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/websocket/sender.js +var require_sender = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { WebsocketFrameSend } = require_frame(); + const { opcodes, sendHints } = require_constants(); + const FixedQueue = require_fixed_queue(); + /** @type {typeof Uint8Array} */ + const FastBuffer = Buffer[Symbol.species]; + /** + * @typedef {object} SendQueueNode + * @property {Promise | null} promise + * @property {((...args: any[]) => any)} callback + * @property {Buffer | null} frame + */ + var SendQueue = class { + /** + * @type {FixedQueue} + */ + #queue = new FixedQueue(); + /** + * @type {boolean} + */ + #running = false; + /** @type {import('node:net').Socket} */ + #socket; + constructor(socket) { + this.#socket = socket; + } + add(item, cb, hint) { + if (hint !== sendHints.blob) { + const frame = createFrame(item, hint); + if (!this.#running) this.#socket.write(frame, cb); + else { + /** @type {SendQueueNode} */ + const node = { + promise: null, + callback: cb, + frame + }; + this.#queue.push(node); + } + return; + } + /** @type {SendQueueNode} */ + const node = { + promise: item.arrayBuffer().then((ab) => { + node.promise = null; + node.frame = createFrame(ab, hint); + }), + callback: cb, + frame: null + }; + this.#queue.push(node); + if (!this.#running) this.#run(); + } + async #run() { + this.#running = true; + const queue = this.#queue; + while (!queue.isEmpty()) { + const node = queue.shift(); + if (node.promise !== null) await node.promise; + this.#socket.write(node.frame, node.callback); + node.callback = node.frame = null; + } + this.#running = false; + } + }; + function createFrame(data, hint) { + return new WebsocketFrameSend(toBuffer(data, hint)).createFrame(hint === sendHints.string ? opcodes.TEXT : opcodes.BINARY); + } + function toBuffer(data, hint) { + switch (hint) { + case sendHints.string: return Buffer.from(data); + case sendHints.arrayBuffer: + case sendHints.blob: return new FastBuffer(data); + case sendHints.typedArray: return new FastBuffer(data.buffer, data.byteOffset, data.byteLength); + } + } + module.exports = { SendQueue }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/websocket/websocket.js +var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { webidl } = require_webidl(); + const { URLSerializer } = require_data_url(); + const { environmentSettingsObject } = require_util$6(); + const { staticPropertyDescriptors, states, sentCloseFrameState, sendHints } = require_constants(); + const { kWebSocketURL, kReadyState, kController, kBinaryType, kResponse, kSentClose, kByteParser } = require_symbols(); + const { isConnecting, isEstablished, isClosing, isValidSubprotocol, fireEvent } = require_util$1(); + const { establishWebSocketConnection, closeWebSocketConnection } = require_connection(); + const { ByteParser } = require_receiver(); + const { kEnumerableProperty, isBlobLike } = require_util$7(); + const { getGlobalDispatcher } = require_global(); + const { types } = __require("node:util"); + const { ErrorEvent, CloseEvent } = require_events(); + const { SendQueue } = require_sender(); + var WebSocket = class WebSocket extends EventTarget { + #events = { + open: null, + error: null, + close: null, + message: null + }; + #bufferedAmount = 0; + #protocol = ""; + #extensions = ""; + /** @type {SendQueue} */ + #sendQueue; + /** + * @param {string} url + * @param {string|string[]} protocols + */ + constructor(url, protocols = []) { + super(); + webidl.util.markAsUncloneable(this); + const prefix = "WebSocket constructor"; + webidl.argumentLengthCheck(arguments, 1, prefix); + const options = webidl.converters["DOMString or sequence or WebSocketInit"](protocols, prefix, "options"); + url = webidl.converters.USVString(url, prefix, "url"); + protocols = options.protocols; + const baseURL = environmentSettingsObject.settingsObject.baseUrl; + let urlRecord; + try { + urlRecord = new URL(url, baseURL); + } catch (e) { + throw new DOMException(e, "SyntaxError"); + } + if (urlRecord.protocol === "http:") urlRecord.protocol = "ws:"; + else if (urlRecord.protocol === "https:") urlRecord.protocol = "wss:"; + if (urlRecord.protocol !== "ws:" && urlRecord.protocol !== "wss:") throw new DOMException(`Expected a ws: or wss: protocol, got ${urlRecord.protocol}`, "SyntaxError"); + if (urlRecord.hash || urlRecord.href.endsWith("#")) throw new DOMException("Got fragment", "SyntaxError"); + if (typeof protocols === "string") protocols = [protocols]; + if (protocols.length !== new Set(protocols.map((p) => p.toLowerCase())).size) throw new DOMException("Invalid Sec-WebSocket-Protocol value", "SyntaxError"); + if (protocols.length > 0 && !protocols.every((p) => isValidSubprotocol(p))) throw new DOMException("Invalid Sec-WebSocket-Protocol value", "SyntaxError"); + this[kWebSocketURL] = new URL(urlRecord.href); + const client = environmentSettingsObject.settingsObject; + this[kController] = establishWebSocketConnection(urlRecord, protocols, client, this, (response, extensions) => this.#onConnectionEstablished(response, extensions), options); + this[kReadyState] = WebSocket.CONNECTING; + this[kSentClose] = sentCloseFrameState.NOT_SENT; + this[kBinaryType] = "blob"; + } + /** + * @see https://websockets.spec.whatwg.org/#dom-websocket-close + * @param {number|undefined} code + * @param {string|undefined} reason + */ + close(code = void 0, reason = void 0) { + webidl.brandCheck(this, WebSocket); + const prefix = "WebSocket.close"; + if (code !== void 0) code = webidl.converters["unsigned short"](code, prefix, "code", { clamp: true }); + if (reason !== void 0) reason = webidl.converters.USVString(reason, prefix, "reason"); + if (code !== void 0) { + if (code !== 1e3 && (code < 3e3 || code > 4999)) throw new DOMException("invalid code", "InvalidAccessError"); + } + let reasonByteLength = 0; + if (reason !== void 0) { + reasonByteLength = Buffer.byteLength(reason); + if (reasonByteLength > 123) throw new DOMException(`Reason must be less than 123 bytes; received ${reasonByteLength}`, "SyntaxError"); + } + closeWebSocketConnection(this, code, reason, reasonByteLength); + } + /** + * @see https://websockets.spec.whatwg.org/#dom-websocket-send + * @param {NodeJS.TypedArray|ArrayBuffer|Blob|string} data + */ + send(data) { + webidl.brandCheck(this, WebSocket); + const prefix = "WebSocket.send"; + webidl.argumentLengthCheck(arguments, 1, prefix); + data = webidl.converters.WebSocketSendData(data, prefix, "data"); + if (isConnecting(this)) throw new DOMException("Sent before connected.", "InvalidStateError"); + if (!isEstablished(this) || isClosing(this)) return; + if (typeof data === "string") { + const length = Buffer.byteLength(data); + this.#bufferedAmount += length; + this.#sendQueue.add(data, () => { + this.#bufferedAmount -= length; + }, sendHints.string); + } else if (types.isArrayBuffer(data)) { + this.#bufferedAmount += data.byteLength; + this.#sendQueue.add(data, () => { + this.#bufferedAmount -= data.byteLength; + }, sendHints.arrayBuffer); + } else if (ArrayBuffer.isView(data)) { + this.#bufferedAmount += data.byteLength; + this.#sendQueue.add(data, () => { + this.#bufferedAmount -= data.byteLength; + }, sendHints.typedArray); + } else if (isBlobLike(data)) { + this.#bufferedAmount += data.size; + this.#sendQueue.add(data, () => { + this.#bufferedAmount -= data.size; + }, sendHints.blob); + } + } + get readyState() { + webidl.brandCheck(this, WebSocket); + return this[kReadyState]; + } + get bufferedAmount() { + webidl.brandCheck(this, WebSocket); + return this.#bufferedAmount; + } + get url() { + webidl.brandCheck(this, WebSocket); + return URLSerializer(this[kWebSocketURL]); + } + get extensions() { + webidl.brandCheck(this, WebSocket); + return this.#extensions; + } + get protocol() { + webidl.brandCheck(this, WebSocket); + return this.#protocol; + } + get onopen() { + webidl.brandCheck(this, WebSocket); + return this.#events.open; + } + set onopen(fn) { + webidl.brandCheck(this, WebSocket); + if (this.#events.open) this.removeEventListener("open", this.#events.open); + if (typeof fn === "function") { + this.#events.open = fn; + this.addEventListener("open", fn); + } else this.#events.open = null; + } + get onerror() { + webidl.brandCheck(this, WebSocket); + return this.#events.error; + } + set onerror(fn) { + webidl.brandCheck(this, WebSocket); + if (this.#events.error) this.removeEventListener("error", this.#events.error); + if (typeof fn === "function") { + this.#events.error = fn; + this.addEventListener("error", fn); + } else this.#events.error = null; + } + get onclose() { + webidl.brandCheck(this, WebSocket); + return this.#events.close; + } + set onclose(fn) { + webidl.brandCheck(this, WebSocket); + if (this.#events.close) this.removeEventListener("close", this.#events.close); + if (typeof fn === "function") { + this.#events.close = fn; + this.addEventListener("close", fn); + } else this.#events.close = null; + } + get onmessage() { + webidl.brandCheck(this, WebSocket); + return this.#events.message; + } + set onmessage(fn) { + webidl.brandCheck(this, WebSocket); + if (this.#events.message) this.removeEventListener("message", this.#events.message); + if (typeof fn === "function") { + this.#events.message = fn; + this.addEventListener("message", fn); + } else this.#events.message = null; + } + get binaryType() { + webidl.brandCheck(this, WebSocket); + return this[kBinaryType]; + } + set binaryType(type) { + webidl.brandCheck(this, WebSocket); + if (type !== "blob" && type !== "arraybuffer") this[kBinaryType] = "blob"; + else this[kBinaryType] = type; + } + /** + * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol + */ + #onConnectionEstablished(response, parsedExtensions) { + this[kResponse] = response; + const parser = new ByteParser(this, parsedExtensions); + parser.on("drain", onParserDrain); + parser.on("error", onParserError.bind(this)); + response.socket.ws = this; + this[kByteParser] = parser; + this.#sendQueue = new SendQueue(response.socket); + this[kReadyState] = states.OPEN; + const extensions = response.headersList.get("sec-websocket-extensions"); + if (extensions !== null) this.#extensions = extensions; + const protocol = response.headersList.get("sec-websocket-protocol"); + if (protocol !== null) this.#protocol = protocol; + fireEvent("open", this); + } + }; + WebSocket.CONNECTING = WebSocket.prototype.CONNECTING = states.CONNECTING; + WebSocket.OPEN = WebSocket.prototype.OPEN = states.OPEN; + WebSocket.CLOSING = WebSocket.prototype.CLOSING = states.CLOSING; + WebSocket.CLOSED = WebSocket.prototype.CLOSED = states.CLOSED; + Object.defineProperties(WebSocket.prototype, { + CONNECTING: staticPropertyDescriptors, + OPEN: staticPropertyDescriptors, + CLOSING: staticPropertyDescriptors, + CLOSED: staticPropertyDescriptors, + url: kEnumerableProperty, + readyState: kEnumerableProperty, + bufferedAmount: kEnumerableProperty, + onopen: kEnumerableProperty, + onerror: kEnumerableProperty, + onclose: kEnumerableProperty, + close: kEnumerableProperty, + onmessage: kEnumerableProperty, + binaryType: kEnumerableProperty, + send: kEnumerableProperty, + extensions: kEnumerableProperty, + protocol: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "WebSocket", + writable: false, + enumerable: false, + configurable: true + } + }); + Object.defineProperties(WebSocket, { + CONNECTING: staticPropertyDescriptors, + OPEN: staticPropertyDescriptors, + CLOSING: staticPropertyDescriptors, + CLOSED: staticPropertyDescriptors + }); + webidl.converters["sequence"] = webidl.sequenceConverter(webidl.converters.DOMString); + webidl.converters["DOMString or sequence"] = function(V, prefix, argument) { + if (webidl.util.Type(V) === "Object" && Symbol.iterator in V) return webidl.converters["sequence"](V); + return webidl.converters.DOMString(V, prefix, argument); + }; + webidl.converters.WebSocketInit = webidl.dictionaryConverter([ + { + key: "protocols", + converter: webidl.converters["DOMString or sequence"], + defaultValue: () => new Array(0) + }, + { + key: "dispatcher", + converter: webidl.converters.any, + defaultValue: () => getGlobalDispatcher() + }, + { + key: "headers", + converter: webidl.nullableConverter(webidl.converters.HeadersInit) + } + ]); + webidl.converters["DOMString or sequence or WebSocketInit"] = function(V) { + if (webidl.util.Type(V) === "Object" && !(Symbol.iterator in V)) return webidl.converters.WebSocketInit(V); + return { protocols: webidl.converters["DOMString or sequence"](V) }; + }; + webidl.converters.WebSocketSendData = function(V) { + if (webidl.util.Type(V) === "Object") { + if (isBlobLike(V)) return webidl.converters.Blob(V, { strict: false }); + if (ArrayBuffer.isView(V) || types.isArrayBuffer(V)) return webidl.converters.BufferSource(V); + } + return webidl.converters.USVString(V); + }; + function onParserDrain() { + this.ws[kResponse].socket.resume(); + } + function onParserError(err) { + let message; + let code; + if (err instanceof CloseEvent) { + message = err.reason; + code = err.code; + } else message = err.message; + fireEvent("error", this, () => new ErrorEvent("error", { + error: err, + message + })); + closeWebSocketConnection(this, code); + } + module.exports = { WebSocket }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/eventsource/util.js +var require_util = /* @__PURE__ */ __commonJSMin(((exports, module) => { + /** + * Checks if the given value is a valid LastEventId. + * @param {string} value + * @returns {boolean} + */ + function isValidLastEventId(value) { + return value.indexOf("\0") === -1; + } + /** + * Checks if the given value is a base 10 digit. + * @param {string} value + * @returns {boolean} + */ + function isASCIINumber(value) { + if (value.length === 0) return false; + for (let i = 0; i < value.length; i++) if (value.charCodeAt(i) < 48 || value.charCodeAt(i) > 57) return false; + return true; + } + function delay(ms) { + return new Promise((resolve) => { + setTimeout(resolve, ms).unref(); + }); + } + module.exports = { + isValidLastEventId, + isASCIINumber, + delay + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/eventsource/eventsource-stream.js +var require_eventsource_stream = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { Transform } = __require("node:stream"); + const { isASCIINumber, isValidLastEventId } = require_util(); + /** + * @type {number[]} BOM + */ + const BOM = [ + 239, + 187, + 191 + ]; + /** + * @type {10} LF + */ + const LF = 10; + /** + * @type {13} CR + */ + const CR = 13; + /** + * @type {58} COLON + */ + const COLON = 58; + /** + * @type {32} SPACE + */ + const SPACE = 32; + /** + * @typedef {object} EventSourceStreamEvent + * @type {object} + * @property {string} [event] The event type. + * @property {string} [data] The data of the message. + * @property {string} [id] A unique ID for the event. + * @property {string} [retry] The reconnection time, in milliseconds. + */ + /** + * @typedef eventSourceSettings + * @type {object} + * @property {string} lastEventId The last event ID received from the server. + * @property {string} origin The origin of the event source. + * @property {number} reconnectionTime The reconnection time, in milliseconds. + */ + var EventSourceStream = class extends Transform { + /** + * @type {eventSourceSettings} + */ + state = null; + /** + * Leading byte-order-mark check. + * @type {boolean} + */ + checkBOM = true; + /** + * @type {boolean} + */ + crlfCheck = false; + /** + * @type {boolean} + */ + eventEndCheck = false; + /** + * @type {Buffer} + */ + buffer = null; + pos = 0; + event = { + data: void 0, + event: void 0, + id: void 0, + retry: void 0 + }; + /** + * @param {object} options + * @param {eventSourceSettings} options.eventSourceSettings + * @param {Function} [options.push] + */ + constructor(options = {}) { + options.readableObjectMode = true; + super(options); + this.state = options.eventSourceSettings || {}; + if (options.push) this.push = options.push; + } + /** + * @param {Buffer} chunk + * @param {string} _encoding + * @param {Function} callback + * @returns {void} + */ + _transform(chunk, _encoding, callback) { + if (chunk.length === 0) { + callback(); + return; + } + if (this.buffer) this.buffer = Buffer.concat([this.buffer, chunk]); + else this.buffer = chunk; + if (this.checkBOM) switch (this.buffer.length) { + case 1: + if (this.buffer[0] === BOM[0]) { + callback(); + return; + } + this.checkBOM = false; + callback(); + return; + case 2: + if (this.buffer[0] === BOM[0] && this.buffer[1] === BOM[1]) { + callback(); + return; + } + this.checkBOM = false; + break; + case 3: + if (this.buffer[0] === BOM[0] && this.buffer[1] === BOM[1] && this.buffer[2] === BOM[2]) { + this.buffer = Buffer.alloc(0); + this.checkBOM = false; + callback(); + return; + } + this.checkBOM = false; + break; + default: + if (this.buffer[0] === BOM[0] && this.buffer[1] === BOM[1] && this.buffer[2] === BOM[2]) this.buffer = this.buffer.subarray(3); + this.checkBOM = false; + } + while (this.pos < this.buffer.length) { + if (this.eventEndCheck) { + if (this.crlfCheck) { + if (this.buffer[this.pos] === LF) { + this.buffer = this.buffer.subarray(this.pos + 1); + this.pos = 0; + this.crlfCheck = false; + continue; + } + this.crlfCheck = false; + } + if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) { + if (this.buffer[this.pos] === CR) this.crlfCheck = true; + this.buffer = this.buffer.subarray(this.pos + 1); + this.pos = 0; + if (this.event.data !== void 0 || this.event.event || this.event.id || this.event.retry) this.processEvent(this.event); + this.clearEvent(); + continue; + } + this.eventEndCheck = false; + continue; + } + if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) { + if (this.buffer[this.pos] === CR) this.crlfCheck = true; + this.parseLine(this.buffer.subarray(0, this.pos), this.event); + this.buffer = this.buffer.subarray(this.pos + 1); + this.pos = 0; + this.eventEndCheck = true; + continue; + } + this.pos++; + } + callback(); + } + /** + * @param {Buffer} line + * @param {EventStreamEvent} event + */ + parseLine(line, event) { + if (line.length === 0) return; + const colonPosition = line.indexOf(COLON); + if (colonPosition === 0) return; + let field = ""; + let value = ""; + if (colonPosition !== -1) { + field = line.subarray(0, colonPosition).toString("utf8"); + let valueStart = colonPosition + 1; + if (line[valueStart] === SPACE) ++valueStart; + value = line.subarray(valueStart).toString("utf8"); + } else { + field = line.toString("utf8"); + value = ""; + } + switch (field) { + case "data": + if (event[field] === void 0) event[field] = value; + else event[field] += `\n${value}`; + break; + case "retry": + if (isASCIINumber(value)) event[field] = value; + break; + case "id": + if (isValidLastEventId(value)) event[field] = value; + break; + case "event": if (value.length > 0) event[field] = value; + } + } + /** + * @param {EventSourceStreamEvent} event + */ + processEvent(event) { + if (event.retry && isASCIINumber(event.retry)) this.state.reconnectionTime = parseInt(event.retry, 10); + if (event.id && isValidLastEventId(event.id)) this.state.lastEventId = event.id; + if (event.data !== void 0) this.push({ + type: event.event || "message", + options: { + data: event.data, + lastEventId: this.state.lastEventId, + origin: this.state.origin + } + }); + } + clearEvent() { + this.event = { + data: void 0, + event: void 0, + id: void 0, + retry: void 0 + }; + } + }; + module.exports = { EventSourceStream }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/lib/web/eventsource/eventsource.js +var require_eventsource = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { pipeline } = __require("node:stream"); + const { fetching } = require_fetch(); + const { makeRequest } = require_request(); + const { webidl } = require_webidl(); + const { EventSourceStream } = require_eventsource_stream(); + const { parseMIMEType } = require_data_url(); + const { createFastMessageEvent } = require_events(); + const { isNetworkError } = require_response(); + const { delay } = require_util(); + const { kEnumerableProperty } = require_util$7(); + const { environmentSettingsObject } = require_util$6(); + let experimentalWarned = false; + /** + * A reconnection time, in milliseconds. This must initially be an implementation-defined value, + * probably in the region of a few seconds. + * + * In Comparison: + * - Chrome uses 3000ms. + * - Deno uses 5000ms. + * + * @type {3000} + */ + const defaultReconnectionTime = 3e3; + /** + * The readyState attribute represents the state of the connection. + * @enum + * @readonly + * @see https://html.spec.whatwg.org/multipage/server-sent-events.html#dom-eventsource-readystate-dev + */ + /** + * The connection has not yet been established, or it was closed and the user + * agent is reconnecting. + * @type {0} + */ + const CONNECTING = 0; + /** + * The user agent has an open connection and is dispatching events as it + * receives them. + * @type {1} + */ + const OPEN = 1; + /** + * The connection is not open, and the user agent is not trying to reconnect. + * @type {2} + */ + const CLOSED = 2; + /** + * Requests for the element will have their mode set to "cors" and their credentials mode set to "same-origin". + * @type {'anonymous'} + */ + const ANONYMOUS = "anonymous"; + /** + * Requests for the element will have their mode set to "cors" and their credentials mode set to "include". + * @type {'use-credentials'} + */ + const USE_CREDENTIALS = "use-credentials"; + /** + * The EventSource interface is used to receive server-sent events. It + * connects to a server over HTTP and receives events in text/event-stream + * format without closing the connection. + * @extends {EventTarget} + * @see https://html.spec.whatwg.org/multipage/server-sent-events.html#server-sent-events + * @api public + */ + var EventSource = class EventSource extends EventTarget { + #events = { + open: null, + error: null, + message: null + }; + #url = null; + #withCredentials = false; + #readyState = CONNECTING; + #request = null; + #controller = null; + #dispatcher; + /** + * @type {import('./eventsource-stream').eventSourceSettings} + */ + #state; + /** + * Creates a new EventSource object. + * @param {string} url + * @param {EventSourceInit} [eventSourceInitDict] + * @see https://html.spec.whatwg.org/multipage/server-sent-events.html#the-eventsource-interface + */ + constructor(url, eventSourceInitDict = {}) { + super(); + webidl.util.markAsUncloneable(this); + const prefix = "EventSource constructor"; + webidl.argumentLengthCheck(arguments, 1, prefix); + if (!experimentalWarned) { + experimentalWarned = true; + process.emitWarning("EventSource is experimental, expect them to change at any time.", { code: "UNDICI-ES" }); + } + url = webidl.converters.USVString(url, prefix, "url"); + eventSourceInitDict = webidl.converters.EventSourceInitDict(eventSourceInitDict, prefix, "eventSourceInitDict"); + this.#dispatcher = eventSourceInitDict.dispatcher; + this.#state = { + lastEventId: "", + reconnectionTime: defaultReconnectionTime + }; + const settings = environmentSettingsObject; + let urlRecord; + try { + urlRecord = new URL(url, settings.settingsObject.baseUrl); + this.#state.origin = urlRecord.origin; + } catch (e) { + throw new DOMException(e, "SyntaxError"); + } + this.#url = urlRecord.href; + let corsAttributeState = ANONYMOUS; + if (eventSourceInitDict.withCredentials) { + corsAttributeState = USE_CREDENTIALS; + this.#withCredentials = true; + } + const initRequest = { + redirect: "follow", + keepalive: true, + mode: "cors", + credentials: corsAttributeState === "anonymous" ? "same-origin" : "omit", + referrer: "no-referrer" + }; + initRequest.client = environmentSettingsObject.settingsObject; + initRequest.headersList = [["accept", { + name: "accept", + value: "text/event-stream" + }]]; + initRequest.cache = "no-store"; + initRequest.initiator = "other"; + initRequest.urlList = [new URL(this.#url)]; + this.#request = makeRequest(initRequest); + this.#connect(); + } + /** + * Returns the state of this EventSource object's connection. It can have the + * values described below. + * @returns {0|1|2} + * @readonly + */ + get readyState() { + return this.#readyState; + } + /** + * Returns the URL providing the event stream. + * @readonly + * @returns {string} + */ + get url() { + return this.#url; + } + /** + * Returns a boolean indicating whether the EventSource object was + * instantiated with CORS credentials set (true), or not (false, the default). + */ + get withCredentials() { + return this.#withCredentials; + } + #connect() { + if (this.#readyState === CLOSED) return; + this.#readyState = CONNECTING; + const fetchParams = { + request: this.#request, + dispatcher: this.#dispatcher + }; + const processEventSourceEndOfBody = (response) => { + if (isNetworkError(response)) { + this.dispatchEvent(new Event("error")); + this.close(); + } + this.#reconnect(); + }; + fetchParams.processResponseEndOfBody = processEventSourceEndOfBody; + fetchParams.processResponse = (response) => { + if (isNetworkError(response)) { + if (response.aborted) { + this.close(); + this.dispatchEvent(new Event("error")); + return; + } else { + this.#reconnect(); + return; + } + } + const contentType = response.headersList.get("content-type", true); + const mimeType = contentType !== null ? parseMIMEType(contentType) : "failure"; + const contentTypeValid = mimeType !== "failure" && mimeType.essence === "text/event-stream"; + if (response.status !== 200 || contentTypeValid === false) { + this.close(); + this.dispatchEvent(new Event("error")); + return; + } + this.#readyState = OPEN; + this.dispatchEvent(new Event("open")); + this.#state.origin = response.urlList[response.urlList.length - 1].origin; + const eventSourceStream = new EventSourceStream({ + eventSourceSettings: this.#state, + push: (event) => { + this.dispatchEvent(createFastMessageEvent(event.type, event.options)); + } + }); + pipeline(response.body.stream, eventSourceStream, (error) => { + if (error?.aborted === false) { + this.close(); + this.dispatchEvent(new Event("error")); + } + }); + }; + this.#controller = fetching(fetchParams); + } + /** + * @see https://html.spec.whatwg.org/multipage/server-sent-events.html#sse-processing-model + * @returns {Promise} + */ + async #reconnect() { + if (this.#readyState === CLOSED) return; + this.#readyState = CONNECTING; + this.dispatchEvent(new Event("error")); + await delay(this.#state.reconnectionTime); + if (this.#readyState !== CONNECTING) return; + if (this.#state.lastEventId.length) this.#request.headersList.set("last-event-id", this.#state.lastEventId, true); + this.#connect(); + } + /** + * Closes the connection, if any, and sets the readyState attribute to + * CLOSED. + */ + close() { + webidl.brandCheck(this, EventSource); + if (this.#readyState === CLOSED) return; + this.#readyState = CLOSED; + this.#controller.abort(); + this.#request = null; + } + get onopen() { + return this.#events.open; + } + set onopen(fn) { + if (this.#events.open) this.removeEventListener("open", this.#events.open); + if (typeof fn === "function") { + this.#events.open = fn; + this.addEventListener("open", fn); + } else this.#events.open = null; + } + get onmessage() { + return this.#events.message; + } + set onmessage(fn) { + if (this.#events.message) this.removeEventListener("message", this.#events.message); + if (typeof fn === "function") { + this.#events.message = fn; + this.addEventListener("message", fn); + } else this.#events.message = null; + } + get onerror() { + return this.#events.error; + } + set onerror(fn) { + if (this.#events.error) this.removeEventListener("error", this.#events.error); + if (typeof fn === "function") { + this.#events.error = fn; + this.addEventListener("error", fn); + } else this.#events.error = null; + } + }; + const constantsPropertyDescriptors = { + CONNECTING: { + __proto__: null, + configurable: false, + enumerable: true, + value: CONNECTING, + writable: false + }, + OPEN: { + __proto__: null, + configurable: false, + enumerable: true, + value: OPEN, + writable: false + }, + CLOSED: { + __proto__: null, + configurable: false, + enumerable: true, + value: CLOSED, + writable: false + } + }; + Object.defineProperties(EventSource, constantsPropertyDescriptors); + Object.defineProperties(EventSource.prototype, constantsPropertyDescriptors); + Object.defineProperties(EventSource.prototype, { + close: kEnumerableProperty, + onerror: kEnumerableProperty, + onmessage: kEnumerableProperty, + onopen: kEnumerableProperty, + readyState: kEnumerableProperty, + url: kEnumerableProperty, + withCredentials: kEnumerableProperty + }); + webidl.converters.EventSourceInitDict = webidl.dictionaryConverter([{ + key: "withCredentials", + converter: webidl.converters.boolean, + defaultValue: () => false + }, { + key: "dispatcher", + converter: webidl.converters.any + }]); + module.exports = { + EventSource, + defaultReconnectionTime + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/undici@6.23.0/node_modules/undici/index.js +var require_undici = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const Client = require_client(); + const Dispatcher = require_dispatcher(); + const Pool = require_pool(); + const BalancedPool = require_balanced_pool(); + const Agent = require_agent(); + const ProxyAgent = require_proxy_agent(); + const EnvHttpProxyAgent = require_env_http_proxy_agent(); + const RetryAgent = require_retry_agent(); + const errors = require_errors(); + const util = require_util$7(); + const { InvalidArgumentError } = errors; + const api = require_api(); + const buildConnector = require_connect(); + const MockClient = require_mock_client(); + const MockAgent = require_mock_agent(); + const MockPool = require_mock_pool(); + const mockErrors = require_mock_errors(); + const RetryHandler = require_retry_handler(); + const { getGlobalDispatcher, setGlobalDispatcher } = require_global(); + const DecoratorHandler = require_decorator_handler(); + const RedirectHandler = require_redirect_handler(); + const createRedirectInterceptor = require_redirect_interceptor(); + Object.assign(Dispatcher.prototype, api); + module.exports.Dispatcher = Dispatcher; + module.exports.Client = Client; + module.exports.Pool = Pool; + module.exports.BalancedPool = BalancedPool; + module.exports.Agent = Agent; + module.exports.ProxyAgent = ProxyAgent; + module.exports.EnvHttpProxyAgent = EnvHttpProxyAgent; + module.exports.RetryAgent = RetryAgent; + module.exports.RetryHandler = RetryHandler; + module.exports.DecoratorHandler = DecoratorHandler; + module.exports.RedirectHandler = RedirectHandler; + module.exports.createRedirectInterceptor = createRedirectInterceptor; + module.exports.interceptors = { + redirect: require_redirect(), + retry: require_retry(), + dump: require_dump(), + dns: require_dns() + }; + module.exports.buildConnector = buildConnector; + module.exports.errors = errors; + module.exports.util = { + parseHeaders: util.parseHeaders, + headerNameToString: util.headerNameToString + }; + function makeDispatcher(fn) { + return (url, opts, handler) => { + if (typeof opts === "function") { + handler = opts; + opts = null; + } + if (!url || typeof url !== "string" && typeof url !== "object" && !(url instanceof URL)) throw new InvalidArgumentError("invalid url"); + if (opts != null && typeof opts !== "object") throw new InvalidArgumentError("invalid opts"); + if (opts && opts.path != null) { + if (typeof opts.path !== "string") throw new InvalidArgumentError("invalid opts.path"); + let path = opts.path; + if (!opts.path.startsWith("/")) path = `/${path}`; + url = new URL(util.parseOrigin(url).origin + path); + } else { + if (!opts) opts = typeof url === "object" ? url : {}; + url = util.parseURL(url); + } + const { agent, dispatcher = getGlobalDispatcher() } = opts; + if (agent) throw new InvalidArgumentError("unsupported opts.agent. Did you mean opts.client?"); + return fn.call(dispatcher, { + ...opts, + origin: url.origin, + path: url.search ? `${url.pathname}${url.search}` : url.pathname, + method: opts.method || (opts.body ? "PUT" : "GET") + }, handler); + }; + } + module.exports.setGlobalDispatcher = setGlobalDispatcher; + module.exports.getGlobalDispatcher = getGlobalDispatcher; + const fetchImpl = require_fetch().fetch; + module.exports.fetch = async function fetch(init, options = void 0) { + try { + return await fetchImpl(init, options); + } catch (err) { + if (err && typeof err === "object") Error.captureStackTrace(err); + throw err; + } + }; + module.exports.Headers = require_headers().Headers; + module.exports.Response = require_response().Response; + module.exports.Request = require_request().Request; + module.exports.FormData = require_formdata().FormData; + module.exports.File = globalThis.File ?? __require("node:buffer").File; + module.exports.FileReader = require_filereader().FileReader; + const { setGlobalOrigin, getGlobalOrigin } = require_global$1(); + module.exports.setGlobalOrigin = setGlobalOrigin; + module.exports.getGlobalOrigin = getGlobalOrigin; + const { CacheStorage } = require_cachestorage(); + const { kConstruct } = require_symbols$1(); + module.exports.caches = new CacheStorage(kConstruct); + const { deleteCookie, getCookies, getSetCookies, setCookie } = require_cookies(); + module.exports.deleteCookie = deleteCookie; + module.exports.getCookies = getCookies; + module.exports.getSetCookies = getSetCookies; + module.exports.setCookie = setCookie; + const { parseMIMEType, serializeAMimeType } = require_data_url(); + module.exports.parseMIMEType = parseMIMEType; + module.exports.serializeAMimeType = serializeAMimeType; + const { CloseEvent, ErrorEvent, MessageEvent } = require_events(); + module.exports.WebSocket = require_websocket().WebSocket; + module.exports.CloseEvent = CloseEvent; + module.exports.ErrorEvent = ErrorEvent; + module.exports.MessageEvent = MessageEvent; + module.exports.request = makeDispatcher(api.request); + module.exports.stream = makeDispatcher(api.stream); + module.exports.pipeline = makeDispatcher(api.pipeline); + module.exports.connect = makeDispatcher(api.connect); + module.exports.upgrade = makeDispatcher(api.upgrade); + module.exports.MockClient = MockClient; + module.exports.MockPool = MockPool; + module.exports.MockAgent = MockAgent; + module.exports.mockErrors = mockErrors; + const { EventSource } = require_eventsource(); + module.exports.EventSource = EventSource; +})); +require_tunnel(); +var import_undici = require_undici(); +var HttpCodes; +(function(HttpCodes) { + HttpCodes[HttpCodes["OK"] = 200] = "OK"; + HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices"; + HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently"; + HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved"; + HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther"; + HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified"; + HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy"; + HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy"; + HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect"; + HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect"; + HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest"; + HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized"; + HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired"; + HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden"; + HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound"; + HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed"; + HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable"; + HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired"; + HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout"; + HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict"; + HttpCodes[HttpCodes["Gone"] = 410] = "Gone"; + HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests"; + HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError"; + HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented"; + HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway"; + HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable"; + HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout"; +})(HttpCodes || (HttpCodes = {})); +var Headers$1; +(function(Headers) { + Headers["Accept"] = "accept"; + Headers["ContentType"] = "content-type"; +})(Headers$1 || (Headers$1 = {})); +var MediaTypes; +(function(MediaTypes) { + MediaTypes["ApplicationJson"] = "application/json"; +})(MediaTypes || (MediaTypes = {})); +HttpCodes.MovedPermanently, HttpCodes.ResourceMoved, HttpCodes.SeeOther, HttpCodes.TemporaryRedirect, HttpCodes.PermanentRedirect; +HttpCodes.BadGateway, HttpCodes.ServiceUnavailable, HttpCodes.GatewayTimeout; +//#endregion +//#region ../../node_modules/.pnpm/@actions+core@3.0.1/node_modules/@actions/core/lib/summary.js +var __awaiter$7 = function(thisArg, _arguments, P, generator) { + function adopt(value) { + return value instanceof P ? value : new P(function(resolve) { + resolve(value); + }); + } + return new (P || (P = Promise))(function(resolve, reject) { + function fulfilled(value) { + try { + step(generator.next(value)); + } catch (e) { + reject(e); + } + } + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e) { + reject(e); + } + } + function step(result) { + result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); + } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +const { access, appendFile, writeFile } = promises; +const SUMMARY_ENV_VAR = "GITHUB_STEP_SUMMARY"; +var Summary = class { + constructor() { + this._buffer = ""; + } + /** + * Finds the summary file path from the environment, rejects if env var is not found or file does not exist + * Also checks r/w permissions. + * + * @returns step summary file path + */ + filePath() { + return __awaiter$7(this, void 0, void 0, function* () { + if (this._filePath) return this._filePath; + const pathFromEnv = process.env[SUMMARY_ENV_VAR]; + if (!pathFromEnv) throw new Error(`Unable to find environment variable for $${SUMMARY_ENV_VAR}. Check if your runtime environment supports job summaries.`); + try { + yield access(pathFromEnv, constants.R_OK | constants.W_OK); + } catch (_a) { + throw new Error(`Unable to access summary file: '${pathFromEnv}'. Check if the file has correct read/write permissions.`); + } + this._filePath = pathFromEnv; + return this._filePath; + }); + } + /** + * Wraps content in an HTML tag, adding any HTML attributes + * + * @param {string} tag HTML tag to wrap + * @param {string | null} content content within the tag + * @param {[attribute: string]: string} attrs key-value list of HTML attributes to add + * + * @returns {string} content wrapped in HTML element + */ + wrap(tag, content, attrs = {}) { + const htmlAttrs = Object.entries(attrs).map(([key, value]) => ` ${key}="${value}"`).join(""); + if (!content) return `<${tag}${htmlAttrs}>`; + return `<${tag}${htmlAttrs}>${content}`; + } + /** + * Writes text in the buffer to the summary buffer file and empties buffer. Will append by default. + * + * @param {SummaryWriteOptions} [options] (optional) options for write operation + * + * @returns {Promise} summary instance + */ + write(options) { + return __awaiter$7(this, void 0, void 0, function* () { + const overwrite = !!(options === null || options === void 0 ? void 0 : options.overwrite); + const filePath = yield this.filePath(); + yield (overwrite ? writeFile : appendFile)(filePath, this._buffer, { encoding: "utf8" }); + return this.emptyBuffer(); + }); + } + /** + * Clears the summary buffer and wipes the summary file + * + * @returns {Summary} summary instance + */ + clear() { + return __awaiter$7(this, void 0, void 0, function* () { + return this.emptyBuffer().write({ overwrite: true }); + }); + } + /** + * Returns the current summary buffer as a string + * + * @returns {string} string of summary buffer + */ + stringify() { + return this._buffer; + } + /** + * If the summary buffer is empty + * + * @returns {boolen} true if the buffer is empty + */ + isEmptyBuffer() { + return this._buffer.length === 0; + } + /** + * Resets the summary buffer without writing to summary file + * + * @returns {Summary} summary instance + */ + emptyBuffer() { + this._buffer = ""; + return this; + } + /** + * Adds raw text to the summary buffer + * + * @param {string} text content to add + * @param {boolean} [addEOL=false] (optional) append an EOL to the raw text (default: false) + * + * @returns {Summary} summary instance + */ + addRaw(text, addEOL = false) { + this._buffer += text; + return addEOL ? this.addEOL() : this; + } + /** + * Adds the operating system-specific end-of-line marker to the buffer + * + * @returns {Summary} summary instance + */ + addEOL() { + return this.addRaw(EOL); + } + /** + * Adds an HTML codeblock to the summary buffer + * + * @param {string} code content to render within fenced code block + * @param {string} lang (optional) language to syntax highlight code + * + * @returns {Summary} summary instance + */ + addCodeBlock(code, lang) { + const attrs = Object.assign({}, lang && { lang }); + const element = this.wrap("pre", this.wrap("code", code), attrs); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML list to the summary buffer + * + * @param {string[]} items list of items to render + * @param {boolean} [ordered=false] (optional) if the rendered list should be ordered or not (default: false) + * + * @returns {Summary} summary instance + */ + addList(items, ordered = false) { + const tag = ordered ? "ol" : "ul"; + const listItems = items.map((item) => this.wrap("li", item)).join(""); + const element = this.wrap(tag, listItems); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML table to the summary buffer + * + * @param {SummaryTableCell[]} rows table rows + * + * @returns {Summary} summary instance + */ + addTable(rows) { + const tableBody = rows.map((row) => { + const cells = row.map((cell) => { + if (typeof cell === "string") return this.wrap("td", cell); + const { header, data, colspan, rowspan } = cell; + const tag = header ? "th" : "td"; + const attrs = Object.assign(Object.assign({}, colspan && { colspan }), rowspan && { rowspan }); + return this.wrap(tag, data, attrs); + }).join(""); + return this.wrap("tr", cells); + }).join(""); + const element = this.wrap("table", tableBody); + return this.addRaw(element).addEOL(); + } + /** + * Adds a collapsable HTML details element to the summary buffer + * + * @param {string} label text for the closed state + * @param {string} content collapsable content + * + * @returns {Summary} summary instance + */ + addDetails(label, content) { + const element = this.wrap("details", this.wrap("summary", label) + content); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML image tag to the summary buffer + * + * @param {string} src path to the image you to embed + * @param {string} alt text description of the image + * @param {SummaryImageOptions} options (optional) addition image attributes + * + * @returns {Summary} summary instance + */ + addImage(src, alt, options) { + const { width, height } = options || {}; + const attrs = Object.assign(Object.assign({}, width && { width }), height && { height }); + const element = this.wrap("img", null, Object.assign({ + src, + alt + }, attrs)); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML section heading element + * + * @param {string} text heading text + * @param {number | string} [level=1] (optional) the heading level, default: 1 + * + * @returns {Summary} summary instance + */ + addHeading(text, level) { + const tag = `h${level}`; + const allowedTag = [ + "h1", + "h2", + "h3", + "h4", + "h5", + "h6" + ].includes(tag) ? tag : "h1"; + const element = this.wrap(allowedTag, text); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML thematic break (
) to the summary buffer + * + * @returns {Summary} summary instance + */ + addSeparator() { + const element = this.wrap("hr", null); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML line break (
) to the summary buffer + * + * @returns {Summary} summary instance + */ + addBreak() { + const element = this.wrap("br", null); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML blockquote to the summary buffer + * + * @param {string} text quote text + * @param {string} cite (optional) citation url + * + * @returns {Summary} summary instance + */ + addQuote(text, cite) { + const attrs = Object.assign({}, cite && { cite }); + const element = this.wrap("blockquote", text, attrs); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML anchor tag to the summary buffer + * + * @param {string} text link text/content + * @param {string} href hyperlink + * + * @returns {Summary} summary instance + */ + addLink(text, href) { + const element = this.wrap("a", text, { href }); + return this.addRaw(element).addEOL(); + } +}; +new Summary(); +const { chmod, copyFile, lstat, mkdir, open, readdir, rename, rm, rmdir, stat, symlink, unlink } = fs.promises; +process.platform; +fs.constants.O_RDONLY; +process.platform; +events.EventEmitter; +events.EventEmitter; +os.platform(); +os.arch(); +/** +* The code to exit an action +*/ +var ExitCode; +(function(ExitCode) { + /** + * A code indicating that the action was successful + */ + ExitCode[ExitCode["Success"] = 0] = "Success"; + /** + * A code indicating that the action was a failure + */ + ExitCode[ExitCode["Failure"] = 1] = "Failure"; +})(ExitCode || (ExitCode = {})); +/** +* Gets the value of an input. +* Unless trimWhitespace is set to false in InputOptions, the value is also trimmed. +* Returns an empty string if the value is not defined. +* +* @param name name of the input to get +* @param options optional. See InputOptions. +* @returns string +*/ +function getInput(name, options) { + const val = process.env[`INPUT_${name.replace(/ /g, "_").toUpperCase()}`] || ""; + if (options && options.required && !val) throw new Error(`Input required and not supplied: ${name}`); + if (options && options.trimWhitespace === false) return val; + return val.trim(); +} +/** +* Sets the value of an output. +* +* @param name name of the output to set +* @param value value to store. Non-string values will be converted to a string via JSON.stringify +*/ +function setOutput(name, value) { + if (process.env["GITHUB_OUTPUT"] || "") return issueFileCommand("OUTPUT", prepareKeyValueMessage(name, value)); + process.stdout.write(os$1.EOL); + issueCommand("set-output", { name }, toCommandValue(value)); +} +/** +* Sets the action status to failed. +* When the action exits it will be with an exit code of 1 +* @param message add error issue message +*/ +function setFailed(message) { + process.exitCode = ExitCode.Failure; + error(message); +} +/** +* Adds an error issue +* @param message error issue message. Errors will be converted to string via toString() +* @param properties optional properties to add to the annotation. +*/ +function error(message, properties = {}) { + issueCommand("error", toCommandProperties(properties), message instanceof Error ? message.toString() : message); +} +/** +* Writes info to log with console.log. +* @param message info message +*/ +function info(message) { + process.stdout.write(message + os$1.EOL); +} +/** +* Begin an output group. +* +* Output until the next `groupEnd` will be foldable in this group +* +* @param name The name of the output group +*/ +function startGroup(name) { + issue("group", name); +} +/** +* End an output group. +*/ +function endGroup() { + issue("endgroup"); +} +//#endregion +//#region ../../node_modules/.pnpm/@actions+github@9.1.1/node_modules/@actions/github/lib/context.js +var Context = class { + /** + * Hydrate the context from the environment + */ + constructor() { + var _a, _b, _c; + this.payload = {}; + if (process.env.GITHUB_EVENT_PATH) { + if (existsSync(process.env.GITHUB_EVENT_PATH)) this.payload = JSON.parse(readFileSync(process.env.GITHUB_EVENT_PATH, { encoding: "utf8" })); + else { + const path = process.env.GITHUB_EVENT_PATH; + process.stdout.write(`GITHUB_EVENT_PATH ${path} does not exist${EOL}`); + } + } + this.eventName = process.env.GITHUB_EVENT_NAME; + this.sha = process.env.GITHUB_SHA; + this.ref = process.env.GITHUB_REF; + this.workflow = process.env.GITHUB_WORKFLOW; + this.action = process.env.GITHUB_ACTION; + this.actor = process.env.GITHUB_ACTOR; + this.job = process.env.GITHUB_JOB; + this.runAttempt = parseInt(process.env.GITHUB_RUN_ATTEMPT, 10); + this.runNumber = parseInt(process.env.GITHUB_RUN_NUMBER, 10); + this.runId = parseInt(process.env.GITHUB_RUN_ID, 10); + this.apiUrl = (_a = process.env.GITHUB_API_URL) !== null && _a !== void 0 ? _a : `https://api.github.com`; + this.serverUrl = (_b = process.env.GITHUB_SERVER_URL) !== null && _b !== void 0 ? _b : `https://github.com`; + this.graphqlUrl = (_c = process.env.GITHUB_GRAPHQL_URL) !== null && _c !== void 0 ? _c : `https://api.github.com/graphql`; + } + get issue() { + const payload = this.payload; + return Object.assign(Object.assign({}, this.repo), { number: (payload.issue || payload.pull_request || payload).number }); + } + get repo() { + if (process.env.GITHUB_REPOSITORY) { + const [owner, repo] = process.env.GITHUB_REPOSITORY.split("/"); + return { + owner, + repo + }; + } + if (this.payload.repository) return { + owner: this.payload.repository.owner.login, + repo: this.payload.repository.name + }; + throw new Error("context.repo requires a GITHUB_REPOSITORY environment variable like 'owner/repo'"); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/@actions+http-client@3.0.2/node_modules/@actions/http-client/lib/proxy.js +var require_proxy = /* @__PURE__ */ __commonJSMin(((exports) => { + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getProxyUrl = getProxyUrl; + exports.checkBypass = checkBypass; + function getProxyUrl(reqUrl) { + const usingSsl = reqUrl.protocol === "https:"; + if (checkBypass(reqUrl)) return; + const proxyVar = (() => { + if (usingSsl) return process.env["https_proxy"] || process.env["HTTPS_PROXY"]; + else return process.env["http_proxy"] || process.env["HTTP_PROXY"]; + })(); + if (proxyVar) try { + return new DecodedURL(proxyVar); + } catch (_a) { + if (!proxyVar.startsWith("http://") && !proxyVar.startsWith("https://")) return new DecodedURL(`http://${proxyVar}`); + } + else return; + } + function checkBypass(reqUrl) { + if (!reqUrl.hostname) return false; + const reqHost = reqUrl.hostname; + if (isLoopbackAddress(reqHost)) return true; + const noProxy = process.env["no_proxy"] || process.env["NO_PROXY"] || ""; + if (!noProxy) return false; + let reqPort; + if (reqUrl.port) reqPort = Number(reqUrl.port); + else if (reqUrl.protocol === "http:") reqPort = 80; + else if (reqUrl.protocol === "https:") reqPort = 443; + const upperReqHosts = [reqUrl.hostname.toUpperCase()]; + if (typeof reqPort === "number") upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`); + for (const upperNoProxyItem of noProxy.split(",").map((x) => x.trim().toUpperCase()).filter((x) => x)) if (upperNoProxyItem === "*" || upperReqHosts.some((x) => x === upperNoProxyItem || x.endsWith(`.${upperNoProxyItem}`) || upperNoProxyItem.startsWith(".") && x.endsWith(`${upperNoProxyItem}`))) return true; + return false; + } + function isLoopbackAddress(host) { + const hostLower = host.toLowerCase(); + return hostLower === "localhost" || hostLower.startsWith("127.") || hostLower.startsWith("[::1]") || hostLower.startsWith("[0:0:0:0:0:0:0:1]"); + } + var DecodedURL = class extends URL { + constructor(url, base) { + super(url, base); + this._decodedUsername = decodeURIComponent(super.username); + this._decodedPassword = decodeURIComponent(super.password); + } + get username() { + return this._decodedUsername; + } + get password() { + return this._decodedPassword; + } + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/@actions+github@9.1.1/node_modules/@actions/github/lib/internal/utils.js +var import_lib = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports) => { + var __createBinding = exports && exports.__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]; + })); + var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { + enumerable: true, + value: v + }); + }) : function(o, v) { + o["default"] = v; + }); + var __importStar = exports && exports.__importStar || (function() { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function(o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function(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; + }; + })(); + var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) { + function adopt(value) { + return value instanceof P ? value : new P(function(resolve) { + resolve(value); + }); + } + return new (P || (P = Promise))(function(resolve, reject) { + function fulfilled(value) { + try { + step(generator.next(value)); + } catch (e) { + reject(e); + } + } + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e) { + reject(e); + } + } + function step(result) { + result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); + } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.HttpClient = exports.HttpClientResponse = exports.HttpClientError = exports.MediaTypes = exports.Headers = exports.HttpCodes = void 0; + exports.getProxyUrl = getProxyUrl; + exports.isHttps = isHttps; + const http = __importStar(__require("http")); + const https = __importStar(__require("https")); + const pm = __importStar(require_proxy()); + const tunnel = __importStar(require_tunnel()); + const undici_1 = require_undici(); + var HttpCodes; + (function(HttpCodes) { + HttpCodes[HttpCodes["OK"] = 200] = "OK"; + HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices"; + HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently"; + HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved"; + HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther"; + HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified"; + HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy"; + HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy"; + HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect"; + HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect"; + HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest"; + HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized"; + HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired"; + HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden"; + HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound"; + HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed"; + HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable"; + HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired"; + HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout"; + HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict"; + HttpCodes[HttpCodes["Gone"] = 410] = "Gone"; + HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests"; + HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError"; + HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented"; + HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway"; + HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable"; + HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout"; + })(HttpCodes || (exports.HttpCodes = HttpCodes = {})); + var Headers; + (function(Headers) { + Headers["Accept"] = "accept"; + Headers["ContentType"] = "content-type"; + })(Headers || (exports.Headers = Headers = {})); + var MediaTypes; + (function(MediaTypes) { + MediaTypes["ApplicationJson"] = "application/json"; + })(MediaTypes || (exports.MediaTypes = MediaTypes = {})); + /** + * Returns the proxy URL, depending upon the supplied url and proxy environment variables. + * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com + */ + function getProxyUrl(serverUrl) { + const proxyUrl = pm.getProxyUrl(new URL(serverUrl)); + return proxyUrl ? proxyUrl.href : ""; + } + const HttpRedirectCodes = [ + HttpCodes.MovedPermanently, + HttpCodes.ResourceMoved, + HttpCodes.SeeOther, + HttpCodes.TemporaryRedirect, + HttpCodes.PermanentRedirect + ]; + const HttpResponseRetryCodes = [ + HttpCodes.BadGateway, + HttpCodes.ServiceUnavailable, + HttpCodes.GatewayTimeout + ]; + const RetryableHttpVerbs = [ + "OPTIONS", + "GET", + "DELETE", + "HEAD" + ]; + const ExponentialBackoffCeiling = 10; + const ExponentialBackoffTimeSlice = 5; + var HttpClientError = class HttpClientError extends Error { + constructor(message, statusCode) { + super(message); + this.name = "HttpClientError"; + this.statusCode = statusCode; + Object.setPrototypeOf(this, HttpClientError.prototype); + } + }; + exports.HttpClientError = HttpClientError; + var HttpClientResponse = class { + constructor(message) { + this.message = message; + } + readBody() { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () { + let output = Buffer.alloc(0); + this.message.on("data", (chunk) => { + output = Buffer.concat([output, chunk]); + }); + this.message.on("end", () => { + resolve(output.toString()); + }); + })); + }); + } + readBodyBuffer() { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () { + const chunks = []; + this.message.on("data", (chunk) => { + chunks.push(chunk); + }); + this.message.on("end", () => { + resolve(Buffer.concat(chunks)); + }); + })); + }); + } + }; + exports.HttpClientResponse = HttpClientResponse; + function isHttps(requestUrl) { + return new URL(requestUrl).protocol === "https:"; + } + var HttpClient = class { + constructor(userAgent, handlers, requestOptions) { + this._ignoreSslError = false; + this._allowRedirects = true; + this._allowRedirectDowngrade = false; + this._maxRedirects = 50; + this._allowRetries = false; + this._maxRetries = 1; + this._keepAlive = false; + this._disposed = false; + this.userAgent = this._getUserAgentWithOrchestrationId(userAgent); + this.handlers = handlers || []; + this.requestOptions = requestOptions; + if (requestOptions) { + if (requestOptions.ignoreSslError != null) this._ignoreSslError = requestOptions.ignoreSslError; + this._socketTimeout = requestOptions.socketTimeout; + if (requestOptions.allowRedirects != null) this._allowRedirects = requestOptions.allowRedirects; + if (requestOptions.allowRedirectDowngrade != null) this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade; + if (requestOptions.maxRedirects != null) this._maxRedirects = Math.max(requestOptions.maxRedirects, 0); + if (requestOptions.keepAlive != null) this._keepAlive = requestOptions.keepAlive; + if (requestOptions.allowRetries != null) this._allowRetries = requestOptions.allowRetries; + if (requestOptions.maxRetries != null) this._maxRetries = requestOptions.maxRetries; + } + } + options(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("OPTIONS", requestUrl, null, additionalHeaders || {}); + }); + } + get(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("GET", requestUrl, null, additionalHeaders || {}); + }); + } + del(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("DELETE", requestUrl, null, additionalHeaders || {}); + }); + } + post(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("POST", requestUrl, data, additionalHeaders || {}); + }); + } + patch(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("PATCH", requestUrl, data, additionalHeaders || {}); + }); + } + put(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("PUT", requestUrl, data, additionalHeaders || {}); + }); + } + head(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("HEAD", requestUrl, null, additionalHeaders || {}); + }); + } + sendStream(verb, requestUrl, stream, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request(verb, requestUrl, stream, additionalHeaders); + }); + } + /** + * Gets a typed object from an endpoint + * Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise + */ + getJson(requestUrl_1) { + return __awaiter(this, arguments, void 0, function* (requestUrl, additionalHeaders = {}) { + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + const res = yield this.get(requestUrl, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + postJson(requestUrl_1, obj_1) { + return __awaiter(this, arguments, void 0, function* (requestUrl, obj, additionalHeaders = {}) { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultContentTypeHeader(additionalHeaders, MediaTypes.ApplicationJson); + const res = yield this.post(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + putJson(requestUrl_1, obj_1) { + return __awaiter(this, arguments, void 0, function* (requestUrl, obj, additionalHeaders = {}) { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultContentTypeHeader(additionalHeaders, MediaTypes.ApplicationJson); + const res = yield this.put(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + patchJson(requestUrl_1, obj_1) { + return __awaiter(this, arguments, void 0, function* (requestUrl, obj, additionalHeaders = {}) { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultContentTypeHeader(additionalHeaders, MediaTypes.ApplicationJson); + const res = yield this.patch(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + /** + * Makes a raw http request. + * All other methods such as get, post, patch, and request ultimately call this. + * Prefer get, del, post and patch + */ + request(verb, requestUrl, data, headers) { + return __awaiter(this, void 0, void 0, function* () { + if (this._disposed) throw new Error("Client has already been disposed."); + const parsedUrl = new URL(requestUrl); + let info = this._prepareRequest(verb, parsedUrl, headers); + const maxTries = this._allowRetries && RetryableHttpVerbs.includes(verb) ? this._maxRetries + 1 : 1; + let numTries = 0; + let response; + do { + response = yield this.requestRaw(info, data); + if (response && response.message && response.message.statusCode === HttpCodes.Unauthorized) { + let authenticationHandler; + for (const handler of this.handlers) if (handler.canHandleAuthentication(response)) { + authenticationHandler = handler; + break; + } + if (authenticationHandler) return authenticationHandler.handleAuthentication(this, info, data); + else return response; + } + let redirectsRemaining = this._maxRedirects; + while (response.message.statusCode && HttpRedirectCodes.includes(response.message.statusCode) && this._allowRedirects && redirectsRemaining > 0) { + const redirectUrl = response.message.headers["location"]; + if (!redirectUrl) break; + const parsedRedirectUrl = new URL(redirectUrl); + if (parsedUrl.protocol === "https:" && parsedUrl.protocol !== parsedRedirectUrl.protocol && !this._allowRedirectDowngrade) throw new Error("Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true."); + yield response.readBody(); + if (parsedRedirectUrl.hostname !== parsedUrl.hostname) { + for (const header in headers) if (header.toLowerCase() === "authorization") delete headers[header]; + } + info = this._prepareRequest(verb, parsedRedirectUrl, headers); + response = yield this.requestRaw(info, data); + redirectsRemaining--; + } + if (!response.message.statusCode || !HttpResponseRetryCodes.includes(response.message.statusCode)) return response; + numTries += 1; + if (numTries < maxTries) { + yield response.readBody(); + yield this._performExponentialBackoff(numTries); + } + } while (numTries < maxTries); + return response; + }); + } + /** + * Needs to be called if keepAlive is set to true in request options. + */ + dispose() { + if (this._agent) this._agent.destroy(); + this._disposed = true; + } + /** + * Raw request. + * @param info + * @param data + */ + requestRaw(info, data) { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve, reject) => { + function callbackForResult(err, res) { + if (err) reject(err); + else if (!res) reject(/* @__PURE__ */ new Error("Unknown error")); + else resolve(res); + } + this.requestRawWithCallback(info, data, callbackForResult); + }); + }); + } + /** + * Raw request with callback. + * @param info + * @param data + * @param onResult + */ + requestRawWithCallback(info, data, onResult) { + if (typeof data === "string") { + if (!info.options.headers) info.options.headers = {}; + info.options.headers["Content-Length"] = Buffer.byteLength(data, "utf8"); + } + let callbackCalled = false; + function handleResult(err, res) { + if (!callbackCalled) { + callbackCalled = true; + onResult(err, res); + } + } + const req = info.httpModule.request(info.options, (msg) => { + handleResult(void 0, new HttpClientResponse(msg)); + }); + let socket; + req.on("socket", (sock) => { + socket = sock; + }); + req.setTimeout(this._socketTimeout || 18e4, () => { + if (socket) socket.end(); + handleResult(/* @__PURE__ */ new Error(`Request timeout: ${info.options.path}`)); + }); + req.on("error", function(err) { + handleResult(err); + }); + if (data && typeof data === "string") req.write(data, "utf8"); + if (data && typeof data !== "string") { + data.on("close", function() { + req.end(); + }); + data.pipe(req); + } else req.end(); + } + /** + * Gets an http agent. This function is useful when you need an http agent that handles + * routing through a proxy server - depending upon the url and proxy environment variables. + * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com + */ + getAgent(serverUrl) { + const parsedUrl = new URL(serverUrl); + return this._getAgent(parsedUrl); + } + getAgentDispatcher(serverUrl) { + const parsedUrl = new URL(serverUrl); + const proxyUrl = pm.getProxyUrl(parsedUrl); + if (!(proxyUrl && proxyUrl.hostname)) return; + return this._getProxyAgentDispatcher(parsedUrl, proxyUrl); + } + _prepareRequest(method, requestUrl, headers) { + const info = {}; + info.parsedUrl = requestUrl; + const usingSsl = info.parsedUrl.protocol === "https:"; + info.httpModule = usingSsl ? https : http; + const defaultPort = usingSsl ? 443 : 80; + info.options = {}; + info.options.host = info.parsedUrl.hostname; + info.options.port = info.parsedUrl.port ? parseInt(info.parsedUrl.port) : defaultPort; + info.options.path = (info.parsedUrl.pathname || "") + (info.parsedUrl.search || ""); + info.options.method = method; + info.options.headers = this._mergeHeaders(headers); + if (this.userAgent != null) info.options.headers["user-agent"] = this.userAgent; + info.options.agent = this._getAgent(info.parsedUrl); + if (this.handlers) for (const handler of this.handlers) handler.prepareRequest(info.options); + return info; + } + _mergeHeaders(headers) { + if (this.requestOptions && this.requestOptions.headers) return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers || {})); + return lowercaseKeys(headers || {}); + } + /** + * Gets an existing header value or returns a default. + * Handles converting number header values to strings since HTTP headers must be strings. + * Note: This returns string | string[] since some headers can have multiple values. + * For headers that must always be a single string (like Content-Type), use the + * specialized _getExistingOrDefaultContentTypeHeader method instead. + */ + _getExistingOrDefaultHeader(additionalHeaders, header, _default) { + let clientHeader; + if (this.requestOptions && this.requestOptions.headers) { + const headerValue = lowercaseKeys(this.requestOptions.headers)[header]; + if (headerValue) clientHeader = typeof headerValue === "number" ? headerValue.toString() : headerValue; + } + const additionalValue = additionalHeaders[header]; + if (additionalValue !== void 0) return typeof additionalValue === "number" ? additionalValue.toString() : additionalValue; + if (clientHeader !== void 0) return clientHeader; + return _default; + } + /** + * Specialized version of _getExistingOrDefaultHeader for Content-Type header. + * Always returns a single string (not an array) since Content-Type should be a single value. + * Converts arrays to comma-separated strings and numbers to strings to ensure type safety. + * This was split from _getExistingOrDefaultHeader to provide stricter typing for callers + * that assign the result to places expecting a string (e.g., additionalHeaders[Headers.ContentType]). + */ + _getExistingOrDefaultContentTypeHeader(additionalHeaders, _default) { + let clientHeader; + if (this.requestOptions && this.requestOptions.headers) { + const headerValue = lowercaseKeys(this.requestOptions.headers)[Headers.ContentType]; + if (headerValue) { + if (typeof headerValue === "number") clientHeader = String(headerValue); + else if (Array.isArray(headerValue)) clientHeader = headerValue.join(", "); + else clientHeader = headerValue; + } + } + const additionalValue = additionalHeaders[Headers.ContentType]; + if (additionalValue !== void 0) { + if (typeof additionalValue === "number") return String(additionalValue); + else if (Array.isArray(additionalValue)) return additionalValue.join(", "); + else return additionalValue; + } + if (clientHeader !== void 0) return clientHeader; + return _default; + } + _getAgent(parsedUrl) { + let agent; + const proxyUrl = pm.getProxyUrl(parsedUrl); + const useProxy = proxyUrl && proxyUrl.hostname; + if (this._keepAlive && useProxy) agent = this._proxyAgent; + if (!useProxy) agent = this._agent; + if (agent) return agent; + const usingSsl = parsedUrl.protocol === "https:"; + let maxSockets = 100; + if (this.requestOptions) maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets; + if (proxyUrl && proxyUrl.hostname) { + const agentOptions = { + maxSockets, + keepAlive: this._keepAlive, + proxy: Object.assign(Object.assign({}, (proxyUrl.username || proxyUrl.password) && { proxyAuth: `${proxyUrl.username}:${proxyUrl.password}` }), { + host: proxyUrl.hostname, + port: proxyUrl.port + }) + }; + let tunnelAgent; + const overHttps = proxyUrl.protocol === "https:"; + if (usingSsl) tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp; + else tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp; + agent = tunnelAgent(agentOptions); + this._proxyAgent = agent; + } + if (!agent) { + const options = { + keepAlive: this._keepAlive, + maxSockets + }; + agent = usingSsl ? new https.Agent(options) : new http.Agent(options); + this._agent = agent; + } + if (usingSsl && this._ignoreSslError) agent.options = Object.assign(agent.options || {}, { rejectUnauthorized: false }); + return agent; + } + _getProxyAgentDispatcher(parsedUrl, proxyUrl) { + let proxyAgent; + if (this._keepAlive) proxyAgent = this._proxyAgentDispatcher; + if (proxyAgent) return proxyAgent; + const usingSsl = parsedUrl.protocol === "https:"; + proxyAgent = new undici_1.ProxyAgent(Object.assign({ + uri: proxyUrl.href, + pipelining: !this._keepAlive ? 0 : 1 + }, (proxyUrl.username || proxyUrl.password) && { token: `Basic ${Buffer.from(`${proxyUrl.username}:${proxyUrl.password}`).toString("base64")}` })); + this._proxyAgentDispatcher = proxyAgent; + if (usingSsl && this._ignoreSslError) proxyAgent.options = Object.assign(proxyAgent.options.requestTls || {}, { rejectUnauthorized: false }); + return proxyAgent; + } + _getUserAgentWithOrchestrationId(userAgent) { + const baseUserAgent = userAgent || "actions/http-client"; + const orchId = process.env["ACTIONS_ORCHESTRATION_ID"]; + if (orchId) return `${baseUserAgent} actions_orchestration_id/${orchId.replace(/[^a-z0-9_.-]/gi, "_")}`; + return baseUserAgent; + } + _performExponentialBackoff(retryNumber) { + return __awaiter(this, void 0, void 0, function* () { + retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber); + const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber); + return new Promise((resolve) => setTimeout(() => resolve(), ms)); + }); + } + _processResponse(res, options) { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () { + const statusCode = res.message.statusCode || 0; + const response = { + statusCode, + result: null, + headers: {} + }; + if (statusCode === HttpCodes.NotFound) resolve(response); + function dateTimeDeserializer(key, value) { + if (typeof value === "string") { + const a = new Date(value); + if (!isNaN(a.valueOf())) return a; + } + return value; + } + let obj; + let contents; + try { + contents = yield res.readBody(); + if (contents && contents.length > 0) { + if (options && options.deserializeDates) obj = JSON.parse(contents, dateTimeDeserializer); + else obj = JSON.parse(contents); + response.result = obj; + } + response.headers = res.message.headers; + } catch (err) {} + if (statusCode > 299) { + let msg; + if (obj && obj.message) msg = obj.message; + else if (contents && contents.length > 0) msg = contents; + else msg = `Failed request: (${statusCode})`; + const err = new HttpClientError(msg, statusCode); + err.result = response.result; + reject(err); + } else resolve(response); + })); + }); + } + }; + exports.HttpClient = HttpClient; + const lowercaseKeys = (obj) => Object.keys(obj).reduce((c, k) => (c[k.toLowerCase()] = obj[k], c), {}); +})))(), 1); +var __awaiter = function(thisArg, _arguments, P, generator) { + function adopt(value) { + return value instanceof P ? value : new P(function(resolve) { + resolve(value); + }); + } + return new (P || (P = Promise))(function(resolve, reject) { + function fulfilled(value) { + try { + step(generator.next(value)); + } catch (e) { + reject(e); + } + } + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e) { + reject(e); + } + } + function step(result) { + result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); + } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +function getAuthString(token, options) { + if (!token && !options.auth) throw new Error("Parameter token or opts.auth is required"); + else if (token && options.auth) throw new Error("Parameters token and opts.auth may not both be specified"); + return typeof options.auth === "string" ? options.auth : `token ${token}`; +} +function getProxyAgent(destinationUrl) { + return new import_lib.HttpClient().getAgent(destinationUrl); +} +function getProxyAgentDispatcher(destinationUrl) { + return new import_lib.HttpClient().getAgentDispatcher(destinationUrl); +} +function getProxyFetch(destinationUrl) { + const httpDispatcher = getProxyAgentDispatcher(destinationUrl); + const proxyFetch = (url, opts) => __awaiter(this, void 0, void 0, function* () { + return (0, import_undici.fetch)(url, Object.assign(Object.assign({}, opts), { dispatcher: httpDispatcher })); + }); + return proxyFetch; +} +function getApiBaseUrl() { + return process.env["GITHUB_API_URL"] || "https://api.github.com"; +} +function getUserAgentWithOrchestrationId(baseUserAgent) { + var _a; + const orchId = (_a = process.env["ACTIONS_ORCHESTRATION_ID"]) === null || _a === void 0 ? void 0 : _a.trim(); + if (orchId) { + const tag = `actions_orchestration_id/${orchId.replace(/[^a-z0-9_.-]/gi, "_")}`; + if (baseUserAgent === null || baseUserAgent === void 0 ? void 0 : baseUserAgent.includes(tag)) return baseUserAgent; + return `${baseUserAgent ? `${baseUserAgent} ` : ""}${tag}`; + } + return baseUserAgent; +} +//#endregion +//#region ../../node_modules/.pnpm/universal-user-agent@7.0.3/node_modules/universal-user-agent/index.js +function getUserAgent() { + if (typeof navigator === "object" && "userAgent" in navigator) return navigator.userAgent; + if (typeof process === "object" && process.version !== void 0) return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`; + return ""; +} +//#endregion +//#region ../../node_modules/.pnpm/before-after-hook@4.0.0/node_modules/before-after-hook/lib/register.js +function register(state, name, method, options) { + if (typeof method !== "function") throw new Error("method for before hook must be a function"); + if (!options) options = {}; + if (Array.isArray(name)) return name.reverse().reduce((callback, name) => { + return register.bind(null, state, name, callback, options); + }, method)(); + return Promise.resolve().then(() => { + if (!state.registry[name]) return method(options); + return state.registry[name].reduce((method, registered) => { + return registered.hook.bind(null, method, options); + }, method)(); + }); +} +//#endregion +//#region ../../node_modules/.pnpm/before-after-hook@4.0.0/node_modules/before-after-hook/lib/add.js +function addHook(state, kind, name, hook) { + const orig = hook; + if (!state.registry[name]) state.registry[name] = []; + if (kind === "before") hook = (method, options) => { + return Promise.resolve().then(orig.bind(null, options)).then(method.bind(null, options)); + }; + if (kind === "after") hook = (method, options) => { + let result; + return Promise.resolve().then(method.bind(null, options)).then((result_) => { + result = result_; + return orig(result, options); + }).then(() => { + return result; + }); + }; + if (kind === "error") hook = (method, options) => { + return Promise.resolve().then(method.bind(null, options)).catch((error) => { + return orig(error, options); + }); + }; + state.registry[name].push({ + hook, + orig + }); +} +//#endregion +//#region ../../node_modules/.pnpm/before-after-hook@4.0.0/node_modules/before-after-hook/lib/remove.js +function removeHook(state, name, method) { + if (!state.registry[name]) return; + const index = state.registry[name].map((registered) => { + return registered.orig; + }).indexOf(method); + if (index === -1) return; + state.registry[name].splice(index, 1); +} +//#endregion +//#region ../../node_modules/.pnpm/before-after-hook@4.0.0/node_modules/before-after-hook/index.js +const bind = Function.bind; +const bindable = bind.bind(bind); +function bindApi(hook, state, name) { + const removeHookRef = bindable(removeHook, null).apply(null, name ? [state, name] : [state]); + hook.api = { remove: removeHookRef }; + hook.remove = removeHookRef; + [ + "before", + "error", + "after", + "wrap" + ].forEach((kind) => { + const args = name ? [ + state, + kind, + name + ] : [state, kind]; + hook[kind] = hook.api[kind] = bindable(addHook, null).apply(null, args); + }); +} +function Singular() { + const singularHookName = Symbol("Singular"); + const singularHookState = { registry: {} }; + const singularHook = register.bind(null, singularHookState, singularHookName); + bindApi(singularHook, singularHookState, singularHookName); + return singularHook; +} +function Collection() { + const state = { registry: {} }; + const hook = register.bind(null, state); + bindApi(hook, state); + return hook; +} +var before_after_hook_default = { + Singular, + Collection +}; +//#endregion +//#region ../../node_modules/.pnpm/@octokit+endpoint@11.0.2/node_modules/@octokit/endpoint/dist-bundle/index.js +var DEFAULTS = { + method: "GET", + baseUrl: "https://api.github.com", + headers: { + accept: "application/vnd.github.v3+json", + "user-agent": `octokit-endpoint.js/0.0.0-development ${getUserAgent()}` + }, + mediaType: { format: "" } +}; +function lowercaseKeys(object) { + if (!object) return {}; + return Object.keys(object).reduce((newObj, key) => { + newObj[key.toLowerCase()] = object[key]; + return newObj; + }, {}); +} +function isPlainObject$1(value) { + if (typeof value !== "object" || value === null) return false; + if (Object.prototype.toString.call(value) !== "[object Object]") return false; + const proto = Object.getPrototypeOf(value); + if (proto === null) return true; + const Ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor; + return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value); +} +function mergeDeep(defaults, options) { + const result = Object.assign({}, defaults); + Object.keys(options).forEach((key) => { + if (isPlainObject$1(options[key])) { + if (!(key in defaults)) Object.assign(result, { [key]: options[key] }); + else result[key] = mergeDeep(defaults[key], options[key]); + } else Object.assign(result, { [key]: options[key] }); + }); + return result; +} +function removeUndefinedProperties(obj) { + for (const key in obj) if (obj[key] === void 0) delete obj[key]; + return obj; +} +function merge(defaults, route, options) { + if (typeof route === "string") { + let [method, url] = route.split(" "); + options = Object.assign(url ? { + method, + url + } : { url: method }, options); + } else options = Object.assign({}, route); + options.headers = lowercaseKeys(options.headers); + removeUndefinedProperties(options); + removeUndefinedProperties(options.headers); + const mergedOptions = mergeDeep(defaults || {}, options); + if (options.url === "/graphql") { + if (defaults && defaults.mediaType.previews?.length) mergedOptions.mediaType.previews = defaults.mediaType.previews.filter((preview) => !mergedOptions.mediaType.previews.includes(preview)).concat(mergedOptions.mediaType.previews); + mergedOptions.mediaType.previews = (mergedOptions.mediaType.previews || []).map((preview) => preview.replace(/-preview/, "")); + } + return mergedOptions; +} +function addQueryParameters(url, parameters) { + const separator = /\?/.test(url) ? "&" : "?"; + const names = Object.keys(parameters); + if (names.length === 0) return url; + return url + separator + names.map((name) => { + if (name === "q") return "q=" + parameters.q.split("+").map(encodeURIComponent).join("+"); + return `${name}=${encodeURIComponent(parameters[name])}`; + }).join("&"); +} +var urlVariableRegex = /\{[^{}}]+\}/g; +function removeNonChars(variableName) { + return variableName.replace(/(?:^\W+)|(?:(? a.concat(b), []); +} +function omit(object, keysToOmit) { + const result = { __proto__: null }; + for (const key of Object.keys(object)) if (keysToOmit.indexOf(key) === -1) result[key] = object[key]; + return result; +} +function encodeReserved(str) { + return str.split(/(%[0-9A-Fa-f]{2})/g).map(function(part) { + if (!/%[0-9A-Fa-f]/.test(part)) part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]"); + return part; + }).join(""); +} +function encodeUnreserved(str) { + return encodeURIComponent(str).replace(/[!'()*]/g, function(c) { + return "%" + c.charCodeAt(0).toString(16).toUpperCase(); + }); +} +function encodeValue(operator, value, key) { + value = operator === "+" || operator === "#" ? encodeReserved(value) : encodeUnreserved(value); + if (key) return encodeUnreserved(key) + "=" + value; + else return value; +} +function isDefined(value) { + return value !== void 0 && value !== null; +} +function isKeyOperator(operator) { + return operator === ";" || operator === "&" || operator === "?"; +} +function getValues(context, operator, key, modifier) { + var value = context[key], result = []; + if (isDefined(value) && value !== "") { + if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") { + value = value.toString(); + if (modifier && modifier !== "*") value = value.substring(0, parseInt(modifier, 10)); + result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : "")); + } else if (modifier === "*") { + if (Array.isArray(value)) value.filter(isDefined).forEach(function(value2) { + result.push(encodeValue(operator, value2, isKeyOperator(operator) ? key : "")); + }); + else Object.keys(value).forEach(function(k) { + if (isDefined(value[k])) result.push(encodeValue(operator, value[k], k)); + }); + } else { + const tmp = []; + if (Array.isArray(value)) value.filter(isDefined).forEach(function(value2) { + tmp.push(encodeValue(operator, value2)); + }); + else Object.keys(value).forEach(function(k) { + if (isDefined(value[k])) { + tmp.push(encodeUnreserved(k)); + tmp.push(encodeValue(operator, value[k].toString())); + } + }); + if (isKeyOperator(operator)) result.push(encodeUnreserved(key) + "=" + tmp.join(",")); + else if (tmp.length !== 0) result.push(tmp.join(",")); + } + } else if (operator === ";") { + if (isDefined(value)) result.push(encodeUnreserved(key)); + } else if (value === "" && (operator === "&" || operator === "?")) result.push(encodeUnreserved(key) + "="); + else if (value === "") result.push(""); + return result; +} +function parseUrl(template) { + return { expand: expand.bind(null, template) }; +} +function expand(template, context) { + var operators = [ + "+", + "#", + ".", + "/", + ";", + "?", + "&" + ]; + template = template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function(_, expression, literal) { + if (expression) { + let operator = ""; + const values = []; + if (operators.indexOf(expression.charAt(0)) !== -1) { + operator = expression.charAt(0); + expression = expression.substr(1); + } + expression.split(/,/g).forEach(function(variable) { + var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable); + values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3])); + }); + if (operator && operator !== "+") { + var separator = ","; + if (operator === "?") separator = "&"; + else if (operator !== "#") separator = operator; + return (values.length !== 0 ? operator : "") + values.join(separator); + } else return values.join(","); + } else return encodeReserved(literal); + }); + if (template === "/") return template; + else return template.replace(/\/$/, ""); +} +function parse(options) { + let method = options.method.toUpperCase(); + let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{$1}"); + let headers = Object.assign({}, options.headers); + let body; + let parameters = omit(options, [ + "method", + "baseUrl", + "url", + "headers", + "request", + "mediaType" + ]); + const urlVariableNames = extractUrlVariableNames(url); + url = parseUrl(url).expand(parameters); + if (!/^http/.test(url)) url = options.baseUrl + url; + const remainingParameters = omit(parameters, Object.keys(options).filter((option) => urlVariableNames.includes(option)).concat("baseUrl")); + if (!/application\/octet-stream/i.test(headers.accept)) { + if (options.mediaType.format) headers.accept = headers.accept.split(/,/).map((format) => format.replace(/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/, `application/vnd$1$2.${options.mediaType.format}`)).join(","); + if (url.endsWith("/graphql")) { + if (options.mediaType.previews?.length) headers.accept = (headers.accept.match(/(? { + return `application/vnd.github.${preview}-preview${options.mediaType.format ? `.${options.mediaType.format}` : "+json"}`; + }).join(","); + } + } + if (["GET", "HEAD"].includes(method)) url = addQueryParameters(url, remainingParameters); + else if ("data" in remainingParameters) body = remainingParameters.data; + else if (Object.keys(remainingParameters).length) body = remainingParameters; + if (!headers["content-type"] && typeof body !== "undefined") headers["content-type"] = "application/json; charset=utf-8"; + if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") body = ""; + return Object.assign({ + method, + url, + headers + }, typeof body !== "undefined" ? { body } : null, options.request ? { request: options.request } : null); +} +function endpointWithDefaults(defaults, route, options) { + return parse(merge(defaults, route, options)); +} +function withDefaults$2(oldDefaults, newDefaults) { + const DEFAULTS2 = merge(oldDefaults, newDefaults); + const endpoint2 = endpointWithDefaults.bind(null, DEFAULTS2); + return Object.assign(endpoint2, { + DEFAULTS: DEFAULTS2, + defaults: withDefaults$2.bind(null, DEFAULTS2), + merge: merge.bind(null, DEFAULTS2), + parse + }); +} +var endpoint = withDefaults$2(null, DEFAULTS); +//#endregion +//#region ../../node_modules/.pnpm/@octokit+request-error@7.1.0/node_modules/@octokit/request-error/dist-src/index.js +var import_fast_content_type_parse = (/* @__PURE__ */ __commonJSMin(((exports, module) => { + const NullObject = function NullObject() {}; + NullObject.prototype = Object.create(null); + /** + * RegExp to match *( ";" parameter ) in RFC 7231 sec 3.1.1.1 + * + * parameter = token "=" ( token / quoted-string ) + * token = 1*tchar + * tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" + * / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~" + * / DIGIT / ALPHA + * ; any VCHAR, except delimiters + * quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE + * qdtext = HTAB / SP / %x21 / %x23-5B / %x5D-7E / obs-text + * obs-text = %x80-FF + * quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text ) + */ + const paramRE = /; *([!#$%&'*+.^\w`|~-]+)=("(?:[\v\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\v\u0020-\u00ff])*"|[!#$%&'*+.^\w`|~-]+) */gu; + /** + * RegExp to match quoted-pair in RFC 7230 sec 3.2.6 + * + * quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text ) + * obs-text = %x80-FF + */ + const quotedPairRE = /\\([\v\u0020-\u00ff])/gu; + /** + * RegExp to match type in RFC 7231 sec 3.1.1.1 + * + * media-type = type "/" subtype + * type = token + * subtype = token + */ + const mediaTypeRE = /^[!#$%&'*+.^\w|~-]+\/[!#$%&'*+.^\w|~-]+$/u; + const defaultContentType = { + type: "", + parameters: new NullObject() + }; + Object.freeze(defaultContentType.parameters); + Object.freeze(defaultContentType); + /** + * Parse media type to object. + * + * @param {string|object} header + * @return {Object} + * @public + */ + function parse(header) { + if (typeof header !== "string") throw new TypeError("argument header is required and must be a string"); + let index = header.indexOf(";"); + const type = index !== -1 ? header.slice(0, index).trim() : header.trim(); + if (mediaTypeRE.test(type) === false) throw new TypeError("invalid media type"); + const result = { + type: type.toLowerCase(), + parameters: new NullObject() + }; + if (index === -1) return result; + let key; + let match; + let value; + paramRE.lastIndex = index; + while (match = paramRE.exec(header)) { + if (match.index !== index) throw new TypeError("invalid parameter format"); + index += match[0].length; + key = match[1].toLowerCase(); + value = match[2]; + if (value[0] === "\"") { + value = value.slice(1, value.length - 1); + quotedPairRE.test(value) && (value = value.replace(quotedPairRE, "$1")); + } + result.parameters[key] = value; + } + if (index !== header.length) throw new TypeError("invalid parameter format"); + return result; + } + function safeParse(header) { + if (typeof header !== "string") return defaultContentType; + let index = header.indexOf(";"); + const type = index !== -1 ? header.slice(0, index).trim() : header.trim(); + if (mediaTypeRE.test(type) === false) return defaultContentType; + const result = { + type: type.toLowerCase(), + parameters: new NullObject() + }; + if (index === -1) return result; + let key; + let match; + let value; + paramRE.lastIndex = index; + while (match = paramRE.exec(header)) { + if (match.index !== index) return defaultContentType; + index += match[0].length; + key = match[1].toLowerCase(); + value = match[2]; + if (value[0] === "\"") { + value = value.slice(1, value.length - 1); + quotedPairRE.test(value) && (value = value.replace(quotedPairRE, "$1")); + } + result.parameters[key] = value; + } + if (index !== header.length) return defaultContentType; + return result; + } + module.exports.default = { + parse, + safeParse + }; + module.exports.parse = parse; + module.exports.safeParse = safeParse; + module.exports.defaultContentType = defaultContentType; +})))(); +var RequestError = class extends Error { + name; + /** + * http status code + */ + status; + /** + * Request options that lead to the error. + */ + request; + /** + * Response object if a response was received + */ + response; + constructor(message, statusCode, options) { + super(message, { cause: options.cause }); + this.name = "HttpError"; + this.status = Number.parseInt(statusCode); + if (Number.isNaN(this.status)) this.status = 0; + /* v8 ignore else -- @preserve -- Bug with vitest coverage where it sees an else branch that doesn't exist */ + if ("response" in options) this.response = options.response; + const requestCopy = Object.assign({}, options.request); + if (options.request.headers.authorization) requestCopy.headers = Object.assign({}, options.request.headers, { authorization: options.request.headers.authorization.replace(/(? ""; +async function fetchWrapper(requestOptions) { + const fetch = requestOptions.request?.fetch || globalThis.fetch; + if (!fetch) throw new Error("fetch is not set. Please pass a fetch implementation as new Octokit({ request: { fetch }}). Learn more at https://github.com/octokit/octokit.js/#fetch-missing"); + const log = requestOptions.request?.log || console; + const parseSuccessResponseBody = requestOptions.request?.parseSuccessResponseBody !== false; + const body = isPlainObject(requestOptions.body) || Array.isArray(requestOptions.body) ? JSON.stringify(requestOptions.body) : requestOptions.body; + const requestHeaders = Object.fromEntries(Object.entries(requestOptions.headers).map(([name, value]) => [name, String(value)])); + let fetchResponse; + try { + fetchResponse = await fetch(requestOptions.url, { + method: requestOptions.method, + body, + redirect: requestOptions.request?.redirect, + headers: requestHeaders, + signal: requestOptions.request?.signal, + ...requestOptions.body && { duplex: "half" } + }); + } catch (error) { + let message = "Unknown Error"; + if (error instanceof Error) { + if (error.name === "AbortError") { + error.status = 500; + throw error; + } + message = error.message; + if (error.name === "TypeError" && "cause" in error) { + if (error.cause instanceof Error) message = error.cause.message; + else if (typeof error.cause === "string") message = error.cause; + } + } + const requestError = new RequestError(message, 500, { request: requestOptions }); + requestError.cause = error; + throw requestError; + } + const status = fetchResponse.status; + const url = fetchResponse.url; + const responseHeaders = {}; + for (const [key, value] of fetchResponse.headers) responseHeaders[key] = value; + const octokitResponse = { + url, + status, + headers: responseHeaders, + data: "" + }; + if ("deprecation" in responseHeaders) { + const matches = responseHeaders.link && responseHeaders.link.match(/<([^<>]+)>; rel="deprecation"/); + const deprecationLink = matches && matches.pop(); + log.warn(`[@octokit/request] "${requestOptions.method} ${requestOptions.url}" is deprecated. It is scheduled to be removed on ${responseHeaders.sunset}${deprecationLink ? `. See ${deprecationLink}` : ""}`); + } + if (status === 204 || status === 205) return octokitResponse; + if (requestOptions.method === "HEAD") { + if (status < 400) return octokitResponse; + throw new RequestError(fetchResponse.statusText, status, { + response: octokitResponse, + request: requestOptions + }); + } + if (status === 304) { + octokitResponse.data = await getResponseData(fetchResponse); + throw new RequestError("Not modified", status, { + response: octokitResponse, + request: requestOptions + }); + } + if (status >= 400) { + octokitResponse.data = await getResponseData(fetchResponse); + throw new RequestError(toErrorMessage(octokitResponse.data), status, { + response: octokitResponse, + request: requestOptions + }); + } + octokitResponse.data = parseSuccessResponseBody ? await getResponseData(fetchResponse) : fetchResponse.body; + return octokitResponse; +} +async function getResponseData(response) { + const contentType = response.headers.get("content-type"); + if (!contentType) return response.text().catch(noop$2); + const mimetype = (0, import_fast_content_type_parse.safeParse)(contentType); + if (isJSONResponse(mimetype)) { + let text = ""; + try { + text = await response.text(); + return JSON.parse(text); + } catch (err) { + return text; + } + } else if (mimetype.type.startsWith("text/") || mimetype.parameters.charset?.toLowerCase() === "utf-8") return response.text().catch(noop$2); + else return response.arrayBuffer().catch( + /* v8 ignore next -- @preserve */ + () => /* @__PURE__ */ new ArrayBuffer(0) + ); +} +function isJSONResponse(mimetype) { + return mimetype.type === "application/json" || mimetype.type === "application/scim+json"; +} +function toErrorMessage(data) { + if (typeof data === "string") return data; + if (data instanceof ArrayBuffer) return "Unknown error"; + if ("message" in data) { + const suffix = "documentation_url" in data ? ` - ${data.documentation_url}` : ""; + return Array.isArray(data.errors) ? `${data.message}: ${data.errors.map((v) => JSON.stringify(v)).join(", ")}${suffix}` : `${data.message}${suffix}`; + } + return `Unknown error: ${JSON.stringify(data)}`; +} +function withDefaults$1(oldEndpoint, newDefaults) { + const endpoint2 = oldEndpoint.defaults(newDefaults); + const newApi = function(route, parameters) { + const endpointOptions = endpoint2.merge(route, parameters); + if (!endpointOptions.request || !endpointOptions.request.hook) return fetchWrapper(endpoint2.parse(endpointOptions)); + const request2 = (route2, parameters2) => { + return fetchWrapper(endpoint2.parse(endpoint2.merge(route2, parameters2))); + }; + Object.assign(request2, { + endpoint: endpoint2, + defaults: withDefaults$1.bind(null, endpoint2) + }); + return endpointOptions.request.hook(request2, endpointOptions); + }; + return Object.assign(newApi, { + endpoint: endpoint2, + defaults: withDefaults$1.bind(null, endpoint2) + }); +} +var request = withDefaults$1(endpoint, defaults_default); +/* v8 ignore next -- @preserve */ +/* v8 ignore else -- @preserve */ +//#endregion +//#region ../../node_modules/.pnpm/@octokit+graphql@9.0.3/node_modules/@octokit/graphql/dist-bundle/index.js +var VERSION$4 = "0.0.0-development"; +function _buildMessageForResponseErrors(data) { + return `Request failed due to following response errors: +` + data.errors.map((e) => ` - ${e.message}`).join("\n"); +} +var GraphqlResponseError = class extends Error { + constructor(request2, headers, response) { + super(_buildMessageForResponseErrors(response)); + this.request = request2; + this.headers = headers; + this.response = response; + this.errors = response.errors; + this.data = response.data; + if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor); + } + name = "GraphqlResponseError"; + errors; + data; +}; +var NON_VARIABLE_OPTIONS = [ + "method", + "baseUrl", + "url", + "headers", + "request", + "query", + "mediaType", + "operationName" +]; +var FORBIDDEN_VARIABLE_OPTIONS = [ + "query", + "method", + "url" +]; +var GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/; +function graphql(request2, query, options) { + if (options) { + if (typeof query === "string" && "query" in options) return Promise.reject(/* @__PURE__ */ new Error(`[@octokit/graphql] "query" cannot be used as variable name`)); + for (const key in options) { + if (!FORBIDDEN_VARIABLE_OPTIONS.includes(key)) continue; + return Promise.reject(/* @__PURE__ */ new Error(`[@octokit/graphql] "${key}" cannot be used as variable name`)); + } + } + const parsedOptions = typeof query === "string" ? Object.assign({ query }, options) : query; + const requestOptions = Object.keys(parsedOptions).reduce((result, key) => { + if (NON_VARIABLE_OPTIONS.includes(key)) { + result[key] = parsedOptions[key]; + return result; + } + if (!result.variables) result.variables = {}; + result.variables[key] = parsedOptions[key]; + return result; + }, {}); + const baseUrl = parsedOptions.baseUrl || request2.endpoint.DEFAULTS.baseUrl; + if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql"); + return request2(requestOptions).then((response) => { + if (response.data.errors) { + const headers = {}; + for (const key of Object.keys(response.headers)) headers[key] = response.headers[key]; + throw new GraphqlResponseError(requestOptions, headers, response.data); + } + return response.data.data; + }); +} +function withDefaults(request2, newDefaults) { + const newRequest = request2.defaults(newDefaults); + const newApi = (query, options) => { + return graphql(newRequest, query, options); + }; + return Object.assign(newApi, { + defaults: withDefaults.bind(null, newRequest), + endpoint: newRequest.endpoint + }); +} +withDefaults(request, { + headers: { "user-agent": `octokit-graphql.js/${VERSION$4} ${getUserAgent()}` }, + method: "POST", + url: "/graphql" +}); +function withCustomRequest(customRequest) { + return withDefaults(customRequest, { + method: "POST", + url: "/graphql" + }); +} +//#endregion +//#region ../../node_modules/.pnpm/@octokit+auth-token@6.0.0/node_modules/@octokit/auth-token/dist-bundle/index.js +var b64url = "(?:[a-zA-Z0-9_-]+)"; +var sep = "\\."; +var jwtRE = new RegExp(`^${b64url}${sep}${b64url}${sep}${b64url}$`); +var isJWT = jwtRE.test.bind(jwtRE); +async function auth(token) { + const isApp = isJWT(token); + const isInstallation = token.startsWith("v1.") || token.startsWith("ghs_"); + const isUserToServer = token.startsWith("ghu_"); + return { + type: "token", + token, + tokenType: isApp ? "app" : isInstallation ? "installation" : isUserToServer ? "user-to-server" : "oauth" + }; +} +function withAuthorizationPrefix(token) { + if (token.split(/\./).length === 3) return `bearer ${token}`; + return `token ${token}`; +} +async function hook(token, request, route, parameters) { + const endpoint = request.endpoint.merge(route, parameters); + endpoint.headers.authorization = withAuthorizationPrefix(token); + return request(endpoint); +} +var createTokenAuth = function createTokenAuth2(token) { + if (!token) throw new Error("[@octokit/auth-token] No token passed to createTokenAuth"); + if (typeof token !== "string") throw new Error("[@octokit/auth-token] Token passed to createTokenAuth is not a string"); + token = token.replace(/^(token|bearer) +/i, ""); + return Object.assign(auth.bind(null, token), { hook: hook.bind(null, token) }); +}; +//#endregion +//#region ../../node_modules/.pnpm/@octokit+core@7.0.6/node_modules/@octokit/core/dist-src/version.js +const VERSION$3 = "7.0.6"; +//#endregion +//#region ../../node_modules/.pnpm/@octokit+core@7.0.6/node_modules/@octokit/core/dist-src/index.js +const noop$1 = () => {}; +const consoleWarn = console.warn.bind(console); +const consoleError = console.error.bind(console); +function createLogger(logger = {}) { + if (typeof logger.debug !== "function") logger.debug = noop$1; + if (typeof logger.info !== "function") logger.info = noop$1; + if (typeof logger.warn !== "function") logger.warn = consoleWarn; + if (typeof logger.error !== "function") logger.error = consoleError; + return logger; +} +const userAgentTrail = `octokit-core.js/${VERSION$3} ${getUserAgent()}`; +var Octokit = class { + static VERSION = VERSION$3; + static defaults(defaults) { + const OctokitWithDefaults = class extends this { + constructor(...args) { + const options = args[0] || {}; + if (typeof defaults === "function") { + super(defaults(options)); + return; + } + super(Object.assign({}, defaults, options, options.userAgent && defaults.userAgent ? { userAgent: `${options.userAgent} ${defaults.userAgent}` } : null)); + } + }; + return OctokitWithDefaults; + } + static plugins = []; + /** + * Attach a plugin (or many) to your Octokit instance. + * + * @example + * const API = Octokit.plugin(plugin1, plugin2, plugin3, ...) + */ + static plugin(...newPlugins) { + const currentPlugins = this.plugins; + const NewOctokit = class extends this { + static plugins = currentPlugins.concat(newPlugins.filter((plugin) => !currentPlugins.includes(plugin))); + }; + return NewOctokit; + } + constructor(options = {}) { + const hook = new before_after_hook_default.Collection(); + const requestDefaults = { + baseUrl: request.endpoint.DEFAULTS.baseUrl, + headers: {}, + request: Object.assign({}, options.request, { hook: hook.bind(null, "request") }), + mediaType: { + previews: [], + format: "" + } + }; + requestDefaults.headers["user-agent"] = options.userAgent ? `${options.userAgent} ${userAgentTrail}` : userAgentTrail; + if (options.baseUrl) requestDefaults.baseUrl = options.baseUrl; + if (options.previews) requestDefaults.mediaType.previews = options.previews; + if (options.timeZone) requestDefaults.headers["time-zone"] = options.timeZone; + this.request = request.defaults(requestDefaults); + this.graphql = withCustomRequest(this.request).defaults(requestDefaults); + this.log = createLogger(options.log); + this.hook = hook; + if (!options.authStrategy) { + if (!options.auth) this.auth = async () => ({ type: "unauthenticated" }); + else { + const auth = createTokenAuth(options.auth); + hook.wrap("request", auth.hook); + this.auth = auth; + } + } else { + const { authStrategy, ...otherOptions } = options; + const auth = authStrategy(Object.assign({ + request: this.request, + log: this.log, + octokit: this, + octokitOptions: otherOptions + }, options.auth)); + hook.wrap("request", auth.hook); + this.auth = auth; + } + const classConstructor = this.constructor; + for (let i = 0; i < classConstructor.plugins.length; ++i) Object.assign(this, classConstructor.plugins[i](this, options)); + } + request; + graphql; + log; + hook; + auth; +}; +//#endregion +//#region ../../node_modules/.pnpm/@octokit+plugin-rest-endpoint-methods@17.0.0_@octokit+core@7.0.6/node_modules/@octokit/plugin-rest-endpoint-methods/dist-src/version.js +const VERSION$2 = "17.0.0"; +//#endregion +//#region ../../node_modules/.pnpm/@octokit+plugin-rest-endpoint-methods@17.0.0_@octokit+core@7.0.6/node_modules/@octokit/plugin-rest-endpoint-methods/dist-src/generated/endpoints.js +var endpoints_default = { + actions: { + addCustomLabelsToSelfHostedRunnerForOrg: ["POST /orgs/{org}/actions/runners/{runner_id}/labels"], + addCustomLabelsToSelfHostedRunnerForRepo: ["POST /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"], + addRepoAccessToSelfHostedRunnerGroupInOrg: ["PUT /orgs/{org}/actions/runner-groups/{runner_group_id}/repositories/{repository_id}"], + addSelectedRepoToOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"], + addSelectedRepoToOrgVariable: ["PUT /orgs/{org}/actions/variables/{name}/repositories/{repository_id}"], + approveWorkflowRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/approve"], + cancelWorkflowRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel"], + createEnvironmentVariable: ["POST /repos/{owner}/{repo}/environments/{environment_name}/variables"], + createHostedRunnerForOrg: ["POST /orgs/{org}/actions/hosted-runners"], + createOrUpdateEnvironmentSecret: ["PUT /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}"], + createOrUpdateOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}"], + createOrUpdateRepoSecret: ["PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}"], + createOrgVariable: ["POST /orgs/{org}/actions/variables"], + createRegistrationTokenForOrg: ["POST /orgs/{org}/actions/runners/registration-token"], + createRegistrationTokenForRepo: ["POST /repos/{owner}/{repo}/actions/runners/registration-token"], + createRemoveTokenForOrg: ["POST /orgs/{org}/actions/runners/remove-token"], + createRemoveTokenForRepo: ["POST /repos/{owner}/{repo}/actions/runners/remove-token"], + createRepoVariable: ["POST /repos/{owner}/{repo}/actions/variables"], + createWorkflowDispatch: ["POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches"], + deleteActionsCacheById: ["DELETE /repos/{owner}/{repo}/actions/caches/{cache_id}"], + deleteActionsCacheByKey: ["DELETE /repos/{owner}/{repo}/actions/caches{?key,ref}"], + deleteArtifact: ["DELETE /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"], + deleteCustomImageFromOrg: ["DELETE /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}"], + deleteCustomImageVersionFromOrg: ["DELETE /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}/versions/{version}"], + deleteEnvironmentSecret: ["DELETE /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}"], + deleteEnvironmentVariable: ["DELETE /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}"], + deleteHostedRunnerForOrg: ["DELETE /orgs/{org}/actions/hosted-runners/{hosted_runner_id}"], + deleteOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}"], + deleteOrgVariable: ["DELETE /orgs/{org}/actions/variables/{name}"], + deleteRepoSecret: ["DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}"], + deleteRepoVariable: ["DELETE /repos/{owner}/{repo}/actions/variables/{name}"], + deleteSelfHostedRunnerFromOrg: ["DELETE /orgs/{org}/actions/runners/{runner_id}"], + deleteSelfHostedRunnerFromRepo: ["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}"], + deleteWorkflowRun: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}"], + deleteWorkflowRunLogs: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}/logs"], + disableSelectedRepositoryGithubActionsOrganization: ["DELETE /orgs/{org}/actions/permissions/repositories/{repository_id}"], + disableWorkflow: ["PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/disable"], + downloadArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}"], + downloadJobLogsForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs"], + downloadWorkflowRunAttemptLogs: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/logs"], + downloadWorkflowRunLogs: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/logs"], + enableSelectedRepositoryGithubActionsOrganization: ["PUT /orgs/{org}/actions/permissions/repositories/{repository_id}"], + enableWorkflow: ["PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/enable"], + forceCancelWorkflowRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/force-cancel"], + generateRunnerJitconfigForOrg: ["POST /orgs/{org}/actions/runners/generate-jitconfig"], + generateRunnerJitconfigForRepo: ["POST /repos/{owner}/{repo}/actions/runners/generate-jitconfig"], + getActionsCacheList: ["GET /repos/{owner}/{repo}/actions/caches"], + getActionsCacheUsage: ["GET /repos/{owner}/{repo}/actions/cache/usage"], + getActionsCacheUsageByRepoForOrg: ["GET /orgs/{org}/actions/cache/usage-by-repository"], + getActionsCacheUsageForOrg: ["GET /orgs/{org}/actions/cache/usage"], + getAllowedActionsOrganization: ["GET /orgs/{org}/actions/permissions/selected-actions"], + getAllowedActionsRepository: ["GET /repos/{owner}/{repo}/actions/permissions/selected-actions"], + getArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"], + getCustomImageForOrg: ["GET /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}"], + getCustomImageVersionForOrg: ["GET /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}/versions/{version}"], + getCustomOidcSubClaimForRepo: ["GET /repos/{owner}/{repo}/actions/oidc/customization/sub"], + getEnvironmentPublicKey: ["GET /repos/{owner}/{repo}/environments/{environment_name}/secrets/public-key"], + getEnvironmentSecret: ["GET /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}"], + getEnvironmentVariable: ["GET /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}"], + getGithubActionsDefaultWorkflowPermissionsOrganization: ["GET /orgs/{org}/actions/permissions/workflow"], + getGithubActionsDefaultWorkflowPermissionsRepository: ["GET /repos/{owner}/{repo}/actions/permissions/workflow"], + getGithubActionsPermissionsOrganization: ["GET /orgs/{org}/actions/permissions"], + getGithubActionsPermissionsRepository: ["GET /repos/{owner}/{repo}/actions/permissions"], + getHostedRunnerForOrg: ["GET /orgs/{org}/actions/hosted-runners/{hosted_runner_id}"], + getHostedRunnersGithubOwnedImagesForOrg: ["GET /orgs/{org}/actions/hosted-runners/images/github-owned"], + getHostedRunnersLimitsForOrg: ["GET /orgs/{org}/actions/hosted-runners/limits"], + getHostedRunnersMachineSpecsForOrg: ["GET /orgs/{org}/actions/hosted-runners/machine-sizes"], + getHostedRunnersPartnerImagesForOrg: ["GET /orgs/{org}/actions/hosted-runners/images/partner"], + getHostedRunnersPlatformsForOrg: ["GET /orgs/{org}/actions/hosted-runners/platforms"], + getJobForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}"], + getOrgPublicKey: ["GET /orgs/{org}/actions/secrets/public-key"], + getOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}"], + getOrgVariable: ["GET /orgs/{org}/actions/variables/{name}"], + getPendingDeploymentsForRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments"], + getRepoPermissions: [ + "GET /repos/{owner}/{repo}/actions/permissions", + {}, + { renamed: ["actions", "getGithubActionsPermissionsRepository"] } + ], + getRepoPublicKey: ["GET /repos/{owner}/{repo}/actions/secrets/public-key"], + getRepoSecret: ["GET /repos/{owner}/{repo}/actions/secrets/{secret_name}"], + getRepoVariable: ["GET /repos/{owner}/{repo}/actions/variables/{name}"], + getReviewsForRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/approvals"], + getSelfHostedRunnerForOrg: ["GET /orgs/{org}/actions/runners/{runner_id}"], + getSelfHostedRunnerForRepo: ["GET /repos/{owner}/{repo}/actions/runners/{runner_id}"], + getWorkflow: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}"], + getWorkflowAccessToRepository: ["GET /repos/{owner}/{repo}/actions/permissions/access"], + getWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}"], + getWorkflowRunAttempt: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}"], + getWorkflowRunUsage: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/timing"], + getWorkflowUsage: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/timing"], + listArtifactsForRepo: ["GET /repos/{owner}/{repo}/actions/artifacts"], + listCustomImageVersionsForOrg: ["GET /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}/versions"], + listCustomImagesForOrg: ["GET /orgs/{org}/actions/hosted-runners/images/custom"], + listEnvironmentSecrets: ["GET /repos/{owner}/{repo}/environments/{environment_name}/secrets"], + listEnvironmentVariables: ["GET /repos/{owner}/{repo}/environments/{environment_name}/variables"], + listGithubHostedRunnersInGroupForOrg: ["GET /orgs/{org}/actions/runner-groups/{runner_group_id}/hosted-runners"], + listHostedRunnersForOrg: ["GET /orgs/{org}/actions/hosted-runners"], + listJobsForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs"], + listJobsForWorkflowRunAttempt: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/jobs"], + listLabelsForSelfHostedRunnerForOrg: ["GET /orgs/{org}/actions/runners/{runner_id}/labels"], + listLabelsForSelfHostedRunnerForRepo: ["GET /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"], + listOrgSecrets: ["GET /orgs/{org}/actions/secrets"], + listOrgVariables: ["GET /orgs/{org}/actions/variables"], + listRepoOrganizationSecrets: ["GET /repos/{owner}/{repo}/actions/organization-secrets"], + listRepoOrganizationVariables: ["GET /repos/{owner}/{repo}/actions/organization-variables"], + listRepoSecrets: ["GET /repos/{owner}/{repo}/actions/secrets"], + listRepoVariables: ["GET /repos/{owner}/{repo}/actions/variables"], + listRepoWorkflows: ["GET /repos/{owner}/{repo}/actions/workflows"], + listRunnerApplicationsForOrg: ["GET /orgs/{org}/actions/runners/downloads"], + listRunnerApplicationsForRepo: ["GET /repos/{owner}/{repo}/actions/runners/downloads"], + listSelectedReposForOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}/repositories"], + listSelectedReposForOrgVariable: ["GET /orgs/{org}/actions/variables/{name}/repositories"], + listSelectedRepositoriesEnabledGithubActionsOrganization: ["GET /orgs/{org}/actions/permissions/repositories"], + listSelfHostedRunnersForOrg: ["GET /orgs/{org}/actions/runners"], + listSelfHostedRunnersForRepo: ["GET /repos/{owner}/{repo}/actions/runners"], + listWorkflowRunArtifacts: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts"], + listWorkflowRuns: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs"], + listWorkflowRunsForRepo: ["GET /repos/{owner}/{repo}/actions/runs"], + reRunJobForWorkflowRun: ["POST /repos/{owner}/{repo}/actions/jobs/{job_id}/rerun"], + reRunWorkflow: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun"], + reRunWorkflowFailedJobs: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun-failed-jobs"], + removeAllCustomLabelsFromSelfHostedRunnerForOrg: ["DELETE /orgs/{org}/actions/runners/{runner_id}/labels"], + removeAllCustomLabelsFromSelfHostedRunnerForRepo: ["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"], + removeCustomLabelFromSelfHostedRunnerForOrg: ["DELETE /orgs/{org}/actions/runners/{runner_id}/labels/{name}"], + removeCustomLabelFromSelfHostedRunnerForRepo: ["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}/labels/{name}"], + removeSelectedRepoFromOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"], + removeSelectedRepoFromOrgVariable: ["DELETE /orgs/{org}/actions/variables/{name}/repositories/{repository_id}"], + reviewCustomGatesForRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/deployment_protection_rule"], + reviewPendingDeploymentsForRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments"], + setAllowedActionsOrganization: ["PUT /orgs/{org}/actions/permissions/selected-actions"], + setAllowedActionsRepository: ["PUT /repos/{owner}/{repo}/actions/permissions/selected-actions"], + setCustomLabelsForSelfHostedRunnerForOrg: ["PUT /orgs/{org}/actions/runners/{runner_id}/labels"], + setCustomLabelsForSelfHostedRunnerForRepo: ["PUT /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"], + setCustomOidcSubClaimForRepo: ["PUT /repos/{owner}/{repo}/actions/oidc/customization/sub"], + setGithubActionsDefaultWorkflowPermissionsOrganization: ["PUT /orgs/{org}/actions/permissions/workflow"], + setGithubActionsDefaultWorkflowPermissionsRepository: ["PUT /repos/{owner}/{repo}/actions/permissions/workflow"], + setGithubActionsPermissionsOrganization: ["PUT /orgs/{org}/actions/permissions"], + setGithubActionsPermissionsRepository: ["PUT /repos/{owner}/{repo}/actions/permissions"], + setSelectedReposForOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories"], + setSelectedReposForOrgVariable: ["PUT /orgs/{org}/actions/variables/{name}/repositories"], + setSelectedRepositoriesEnabledGithubActionsOrganization: ["PUT /orgs/{org}/actions/permissions/repositories"], + setWorkflowAccessToRepository: ["PUT /repos/{owner}/{repo}/actions/permissions/access"], + updateEnvironmentVariable: ["PATCH /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}"], + updateHostedRunnerForOrg: ["PATCH /orgs/{org}/actions/hosted-runners/{hosted_runner_id}"], + updateOrgVariable: ["PATCH /orgs/{org}/actions/variables/{name}"], + updateRepoVariable: ["PATCH /repos/{owner}/{repo}/actions/variables/{name}"] + }, + activity: { + checkRepoIsStarredByAuthenticatedUser: ["GET /user/starred/{owner}/{repo}"], + deleteRepoSubscription: ["DELETE /repos/{owner}/{repo}/subscription"], + deleteThreadSubscription: ["DELETE /notifications/threads/{thread_id}/subscription"], + getFeeds: ["GET /feeds"], + getRepoSubscription: ["GET /repos/{owner}/{repo}/subscription"], + getThread: ["GET /notifications/threads/{thread_id}"], + getThreadSubscriptionForAuthenticatedUser: ["GET /notifications/threads/{thread_id}/subscription"], + listEventsForAuthenticatedUser: ["GET /users/{username}/events"], + listNotificationsForAuthenticatedUser: ["GET /notifications"], + listOrgEventsForAuthenticatedUser: ["GET /users/{username}/events/orgs/{org}"], + listPublicEvents: ["GET /events"], + listPublicEventsForRepoNetwork: ["GET /networks/{owner}/{repo}/events"], + listPublicEventsForUser: ["GET /users/{username}/events/public"], + listPublicOrgEvents: ["GET /orgs/{org}/events"], + listReceivedEventsForUser: ["GET /users/{username}/received_events"], + listReceivedPublicEventsForUser: ["GET /users/{username}/received_events/public"], + listRepoEvents: ["GET /repos/{owner}/{repo}/events"], + listRepoNotificationsForAuthenticatedUser: ["GET /repos/{owner}/{repo}/notifications"], + listReposStarredByAuthenticatedUser: ["GET /user/starred"], + listReposStarredByUser: ["GET /users/{username}/starred"], + listReposWatchedByUser: ["GET /users/{username}/subscriptions"], + listStargazersForRepo: ["GET /repos/{owner}/{repo}/stargazers"], + listWatchedReposForAuthenticatedUser: ["GET /user/subscriptions"], + listWatchersForRepo: ["GET /repos/{owner}/{repo}/subscribers"], + markNotificationsAsRead: ["PUT /notifications"], + markRepoNotificationsAsRead: ["PUT /repos/{owner}/{repo}/notifications"], + markThreadAsDone: ["DELETE /notifications/threads/{thread_id}"], + markThreadAsRead: ["PATCH /notifications/threads/{thread_id}"], + setRepoSubscription: ["PUT /repos/{owner}/{repo}/subscription"], + setThreadSubscription: ["PUT /notifications/threads/{thread_id}/subscription"], + starRepoForAuthenticatedUser: ["PUT /user/starred/{owner}/{repo}"], + unstarRepoForAuthenticatedUser: ["DELETE /user/starred/{owner}/{repo}"] + }, + apps: { + addRepoToInstallation: [ + "PUT /user/installations/{installation_id}/repositories/{repository_id}", + {}, + { renamed: ["apps", "addRepoToInstallationForAuthenticatedUser"] } + ], + addRepoToInstallationForAuthenticatedUser: ["PUT /user/installations/{installation_id}/repositories/{repository_id}"], + checkToken: ["POST /applications/{client_id}/token"], + createFromManifest: ["POST /app-manifests/{code}/conversions"], + createInstallationAccessToken: ["POST /app/installations/{installation_id}/access_tokens"], + deleteAuthorization: ["DELETE /applications/{client_id}/grant"], + deleteInstallation: ["DELETE /app/installations/{installation_id}"], + deleteToken: ["DELETE /applications/{client_id}/token"], + getAuthenticated: ["GET /app"], + getBySlug: ["GET /apps/{app_slug}"], + getInstallation: ["GET /app/installations/{installation_id}"], + getOrgInstallation: ["GET /orgs/{org}/installation"], + getRepoInstallation: ["GET /repos/{owner}/{repo}/installation"], + getSubscriptionPlanForAccount: ["GET /marketplace_listing/accounts/{account_id}"], + getSubscriptionPlanForAccountStubbed: ["GET /marketplace_listing/stubbed/accounts/{account_id}"], + getUserInstallation: ["GET /users/{username}/installation"], + getWebhookConfigForApp: ["GET /app/hook/config"], + getWebhookDelivery: ["GET /app/hook/deliveries/{delivery_id}"], + listAccountsForPlan: ["GET /marketplace_listing/plans/{plan_id}/accounts"], + listAccountsForPlanStubbed: ["GET /marketplace_listing/stubbed/plans/{plan_id}/accounts"], + listInstallationReposForAuthenticatedUser: ["GET /user/installations/{installation_id}/repositories"], + listInstallationRequestsForAuthenticatedApp: ["GET /app/installation-requests"], + listInstallations: ["GET /app/installations"], + listInstallationsForAuthenticatedUser: ["GET /user/installations"], + listPlans: ["GET /marketplace_listing/plans"], + listPlansStubbed: ["GET /marketplace_listing/stubbed/plans"], + listReposAccessibleToInstallation: ["GET /installation/repositories"], + listSubscriptionsForAuthenticatedUser: ["GET /user/marketplace_purchases"], + listSubscriptionsForAuthenticatedUserStubbed: ["GET /user/marketplace_purchases/stubbed"], + listWebhookDeliveries: ["GET /app/hook/deliveries"], + redeliverWebhookDelivery: ["POST /app/hook/deliveries/{delivery_id}/attempts"], + removeRepoFromInstallation: [ + "DELETE /user/installations/{installation_id}/repositories/{repository_id}", + {}, + { renamed: ["apps", "removeRepoFromInstallationForAuthenticatedUser"] } + ], + removeRepoFromInstallationForAuthenticatedUser: ["DELETE /user/installations/{installation_id}/repositories/{repository_id}"], + resetToken: ["PATCH /applications/{client_id}/token"], + revokeInstallationAccessToken: ["DELETE /installation/token"], + scopeToken: ["POST /applications/{client_id}/token/scoped"], + suspendInstallation: ["PUT /app/installations/{installation_id}/suspended"], + unsuspendInstallation: ["DELETE /app/installations/{installation_id}/suspended"], + updateWebhookConfigForApp: ["PATCH /app/hook/config"] + }, + billing: { + getGithubActionsBillingOrg: ["GET /orgs/{org}/settings/billing/actions"], + getGithubActionsBillingUser: ["GET /users/{username}/settings/billing/actions"], + getGithubBillingPremiumRequestUsageReportOrg: ["GET /organizations/{org}/settings/billing/premium_request/usage"], + getGithubBillingPremiumRequestUsageReportUser: ["GET /users/{username}/settings/billing/premium_request/usage"], + getGithubBillingUsageReportOrg: ["GET /organizations/{org}/settings/billing/usage"], + getGithubBillingUsageReportUser: ["GET /users/{username}/settings/billing/usage"], + getGithubPackagesBillingOrg: ["GET /orgs/{org}/settings/billing/packages"], + getGithubPackagesBillingUser: ["GET /users/{username}/settings/billing/packages"], + getSharedStorageBillingOrg: ["GET /orgs/{org}/settings/billing/shared-storage"], + getSharedStorageBillingUser: ["GET /users/{username}/settings/billing/shared-storage"] + }, + campaigns: { + createCampaign: ["POST /orgs/{org}/campaigns"], + deleteCampaign: ["DELETE /orgs/{org}/campaigns/{campaign_number}"], + getCampaignSummary: ["GET /orgs/{org}/campaigns/{campaign_number}"], + listOrgCampaigns: ["GET /orgs/{org}/campaigns"], + updateCampaign: ["PATCH /orgs/{org}/campaigns/{campaign_number}"] + }, + checks: { + create: ["POST /repos/{owner}/{repo}/check-runs"], + createSuite: ["POST /repos/{owner}/{repo}/check-suites"], + get: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}"], + getSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}"], + listAnnotations: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations"], + listForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-runs"], + listForSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs"], + listSuitesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-suites"], + rerequestRun: ["POST /repos/{owner}/{repo}/check-runs/{check_run_id}/rerequest"], + rerequestSuite: ["POST /repos/{owner}/{repo}/check-suites/{check_suite_id}/rerequest"], + setSuitesPreferences: ["PATCH /repos/{owner}/{repo}/check-suites/preferences"], + update: ["PATCH /repos/{owner}/{repo}/check-runs/{check_run_id}"] + }, + codeScanning: { + commitAutofix: ["POST /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/autofix/commits"], + createAutofix: ["POST /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/autofix"], + createVariantAnalysis: ["POST /repos/{owner}/{repo}/code-scanning/codeql/variant-analyses"], + deleteAnalysis: ["DELETE /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}{?confirm_delete}"], + deleteCodeqlDatabase: ["DELETE /repos/{owner}/{repo}/code-scanning/codeql/databases/{language}"], + getAlert: [ + "GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}", + {}, + { renamedParameters: { alert_id: "alert_number" } } + ], + getAnalysis: ["GET /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}"], + getAutofix: ["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/autofix"], + getCodeqlDatabase: ["GET /repos/{owner}/{repo}/code-scanning/codeql/databases/{language}"], + getDefaultSetup: ["GET /repos/{owner}/{repo}/code-scanning/default-setup"], + getSarif: ["GET /repos/{owner}/{repo}/code-scanning/sarifs/{sarif_id}"], + getVariantAnalysis: ["GET /repos/{owner}/{repo}/code-scanning/codeql/variant-analyses/{codeql_variant_analysis_id}"], + getVariantAnalysisRepoTask: ["GET /repos/{owner}/{repo}/code-scanning/codeql/variant-analyses/{codeql_variant_analysis_id}/repos/{repo_owner}/{repo_name}"], + listAlertInstances: ["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances"], + listAlertsForOrg: ["GET /orgs/{org}/code-scanning/alerts"], + listAlertsForRepo: ["GET /repos/{owner}/{repo}/code-scanning/alerts"], + listAlertsInstances: [ + "GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances", + {}, + { renamed: ["codeScanning", "listAlertInstances"] } + ], + listCodeqlDatabases: ["GET /repos/{owner}/{repo}/code-scanning/codeql/databases"], + listRecentAnalyses: ["GET /repos/{owner}/{repo}/code-scanning/analyses"], + updateAlert: ["PATCH /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}"], + updateDefaultSetup: ["PATCH /repos/{owner}/{repo}/code-scanning/default-setup"], + uploadSarif: ["POST /repos/{owner}/{repo}/code-scanning/sarifs"] + }, + codeSecurity: { + attachConfiguration: ["POST /orgs/{org}/code-security/configurations/{configuration_id}/attach"], + attachEnterpriseConfiguration: ["POST /enterprises/{enterprise}/code-security/configurations/{configuration_id}/attach"], + createConfiguration: ["POST /orgs/{org}/code-security/configurations"], + createConfigurationForEnterprise: ["POST /enterprises/{enterprise}/code-security/configurations"], + deleteConfiguration: ["DELETE /orgs/{org}/code-security/configurations/{configuration_id}"], + deleteConfigurationForEnterprise: ["DELETE /enterprises/{enterprise}/code-security/configurations/{configuration_id}"], + detachConfiguration: ["DELETE /orgs/{org}/code-security/configurations/detach"], + getConfiguration: ["GET /orgs/{org}/code-security/configurations/{configuration_id}"], + getConfigurationForRepository: ["GET /repos/{owner}/{repo}/code-security-configuration"], + getConfigurationsForEnterprise: ["GET /enterprises/{enterprise}/code-security/configurations"], + getConfigurationsForOrg: ["GET /orgs/{org}/code-security/configurations"], + getDefaultConfigurations: ["GET /orgs/{org}/code-security/configurations/defaults"], + getDefaultConfigurationsForEnterprise: ["GET /enterprises/{enterprise}/code-security/configurations/defaults"], + getRepositoriesForConfiguration: ["GET /orgs/{org}/code-security/configurations/{configuration_id}/repositories"], + getRepositoriesForEnterpriseConfiguration: ["GET /enterprises/{enterprise}/code-security/configurations/{configuration_id}/repositories"], + getSingleConfigurationForEnterprise: ["GET /enterprises/{enterprise}/code-security/configurations/{configuration_id}"], + setConfigurationAsDefault: ["PUT /orgs/{org}/code-security/configurations/{configuration_id}/defaults"], + setConfigurationAsDefaultForEnterprise: ["PUT /enterprises/{enterprise}/code-security/configurations/{configuration_id}/defaults"], + updateConfiguration: ["PATCH /orgs/{org}/code-security/configurations/{configuration_id}"], + updateEnterpriseConfiguration: ["PATCH /enterprises/{enterprise}/code-security/configurations/{configuration_id}"] + }, + codesOfConduct: { + getAllCodesOfConduct: ["GET /codes_of_conduct"], + getConductCode: ["GET /codes_of_conduct/{key}"] + }, + codespaces: { + addRepositoryForSecretForAuthenticatedUser: ["PUT /user/codespaces/secrets/{secret_name}/repositories/{repository_id}"], + addSelectedRepoToOrgSecret: ["PUT /orgs/{org}/codespaces/secrets/{secret_name}/repositories/{repository_id}"], + checkPermissionsForDevcontainer: ["GET /repos/{owner}/{repo}/codespaces/permissions_check"], + codespaceMachinesForAuthenticatedUser: ["GET /user/codespaces/{codespace_name}/machines"], + createForAuthenticatedUser: ["POST /user/codespaces"], + createOrUpdateOrgSecret: ["PUT /orgs/{org}/codespaces/secrets/{secret_name}"], + createOrUpdateRepoSecret: ["PUT /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"], + createOrUpdateSecretForAuthenticatedUser: ["PUT /user/codespaces/secrets/{secret_name}"], + createWithPrForAuthenticatedUser: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/codespaces"], + createWithRepoForAuthenticatedUser: ["POST /repos/{owner}/{repo}/codespaces"], + deleteForAuthenticatedUser: ["DELETE /user/codespaces/{codespace_name}"], + deleteFromOrganization: ["DELETE /orgs/{org}/members/{username}/codespaces/{codespace_name}"], + deleteOrgSecret: ["DELETE /orgs/{org}/codespaces/secrets/{secret_name}"], + deleteRepoSecret: ["DELETE /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"], + deleteSecretForAuthenticatedUser: ["DELETE /user/codespaces/secrets/{secret_name}"], + exportForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/exports"], + getCodespacesForUserInOrg: ["GET /orgs/{org}/members/{username}/codespaces"], + getExportDetailsForAuthenticatedUser: ["GET /user/codespaces/{codespace_name}/exports/{export_id}"], + getForAuthenticatedUser: ["GET /user/codespaces/{codespace_name}"], + getOrgPublicKey: ["GET /orgs/{org}/codespaces/secrets/public-key"], + getOrgSecret: ["GET /orgs/{org}/codespaces/secrets/{secret_name}"], + getPublicKeyForAuthenticatedUser: ["GET /user/codespaces/secrets/public-key"], + getRepoPublicKey: ["GET /repos/{owner}/{repo}/codespaces/secrets/public-key"], + getRepoSecret: ["GET /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"], + getSecretForAuthenticatedUser: ["GET /user/codespaces/secrets/{secret_name}"], + listDevcontainersInRepositoryForAuthenticatedUser: ["GET /repos/{owner}/{repo}/codespaces/devcontainers"], + listForAuthenticatedUser: ["GET /user/codespaces"], + listInOrganization: [ + "GET /orgs/{org}/codespaces", + {}, + { renamedParameters: { org_id: "org" } } + ], + listInRepositoryForAuthenticatedUser: ["GET /repos/{owner}/{repo}/codespaces"], + listOrgSecrets: ["GET /orgs/{org}/codespaces/secrets"], + listRepoSecrets: ["GET /repos/{owner}/{repo}/codespaces/secrets"], + listRepositoriesForSecretForAuthenticatedUser: ["GET /user/codespaces/secrets/{secret_name}/repositories"], + listSecretsForAuthenticatedUser: ["GET /user/codespaces/secrets"], + listSelectedReposForOrgSecret: ["GET /orgs/{org}/codespaces/secrets/{secret_name}/repositories"], + preFlightWithRepoForAuthenticatedUser: ["GET /repos/{owner}/{repo}/codespaces/new"], + publishForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/publish"], + removeRepositoryForSecretForAuthenticatedUser: ["DELETE /user/codespaces/secrets/{secret_name}/repositories/{repository_id}"], + removeSelectedRepoFromOrgSecret: ["DELETE /orgs/{org}/codespaces/secrets/{secret_name}/repositories/{repository_id}"], + repoMachinesForAuthenticatedUser: ["GET /repos/{owner}/{repo}/codespaces/machines"], + setRepositoriesForSecretForAuthenticatedUser: ["PUT /user/codespaces/secrets/{secret_name}/repositories"], + setSelectedReposForOrgSecret: ["PUT /orgs/{org}/codespaces/secrets/{secret_name}/repositories"], + startForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/start"], + stopForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/stop"], + stopInOrganization: ["POST /orgs/{org}/members/{username}/codespaces/{codespace_name}/stop"], + updateForAuthenticatedUser: ["PATCH /user/codespaces/{codespace_name}"] + }, + copilot: { + addCopilotSeatsForTeams: ["POST /orgs/{org}/copilot/billing/selected_teams"], + addCopilotSeatsForUsers: ["POST /orgs/{org}/copilot/billing/selected_users"], + cancelCopilotSeatAssignmentForTeams: ["DELETE /orgs/{org}/copilot/billing/selected_teams"], + cancelCopilotSeatAssignmentForUsers: ["DELETE /orgs/{org}/copilot/billing/selected_users"], + copilotMetricsForOrganization: ["GET /orgs/{org}/copilot/metrics"], + copilotMetricsForTeam: ["GET /orgs/{org}/team/{team_slug}/copilot/metrics"], + getCopilotOrganizationDetails: ["GET /orgs/{org}/copilot/billing"], + getCopilotSeatDetailsForUser: ["GET /orgs/{org}/members/{username}/copilot"], + listCopilotSeats: ["GET /orgs/{org}/copilot/billing/seats"] + }, + credentials: { revoke: ["POST /credentials/revoke"] }, + dependabot: { + addSelectedRepoToOrgSecret: ["PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}"], + createOrUpdateOrgSecret: ["PUT /orgs/{org}/dependabot/secrets/{secret_name}"], + createOrUpdateRepoSecret: ["PUT /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"], + deleteOrgSecret: ["DELETE /orgs/{org}/dependabot/secrets/{secret_name}"], + deleteRepoSecret: ["DELETE /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"], + getAlert: ["GET /repos/{owner}/{repo}/dependabot/alerts/{alert_number}"], + getOrgPublicKey: ["GET /orgs/{org}/dependabot/secrets/public-key"], + getOrgSecret: ["GET /orgs/{org}/dependabot/secrets/{secret_name}"], + getRepoPublicKey: ["GET /repos/{owner}/{repo}/dependabot/secrets/public-key"], + getRepoSecret: ["GET /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"], + listAlertsForEnterprise: ["GET /enterprises/{enterprise}/dependabot/alerts"], + listAlertsForOrg: ["GET /orgs/{org}/dependabot/alerts"], + listAlertsForRepo: ["GET /repos/{owner}/{repo}/dependabot/alerts"], + listOrgSecrets: ["GET /orgs/{org}/dependabot/secrets"], + listRepoSecrets: ["GET /repos/{owner}/{repo}/dependabot/secrets"], + listSelectedReposForOrgSecret: ["GET /orgs/{org}/dependabot/secrets/{secret_name}/repositories"], + removeSelectedRepoFromOrgSecret: ["DELETE /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}"], + repositoryAccessForOrg: ["GET /organizations/{org}/dependabot/repository-access"], + setRepositoryAccessDefaultLevel: ["PUT /organizations/{org}/dependabot/repository-access/default-level"], + setSelectedReposForOrgSecret: ["PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories"], + updateAlert: ["PATCH /repos/{owner}/{repo}/dependabot/alerts/{alert_number}"], + updateRepositoryAccessForOrg: ["PATCH /organizations/{org}/dependabot/repository-access"] + }, + dependencyGraph: { + createRepositorySnapshot: ["POST /repos/{owner}/{repo}/dependency-graph/snapshots"], + diffRange: ["GET /repos/{owner}/{repo}/dependency-graph/compare/{basehead}"], + exportSbom: ["GET /repos/{owner}/{repo}/dependency-graph/sbom"] + }, + emojis: { get: ["GET /emojis"] }, + enterpriseTeamMemberships: { + add: ["PUT /enterprises/{enterprise}/teams/{enterprise-team}/memberships/{username}"], + bulkAdd: ["POST /enterprises/{enterprise}/teams/{enterprise-team}/memberships/add"], + bulkRemove: ["POST /enterprises/{enterprise}/teams/{enterprise-team}/memberships/remove"], + get: ["GET /enterprises/{enterprise}/teams/{enterprise-team}/memberships/{username}"], + list: ["GET /enterprises/{enterprise}/teams/{enterprise-team}/memberships"], + remove: ["DELETE /enterprises/{enterprise}/teams/{enterprise-team}/memberships/{username}"] + }, + enterpriseTeamOrganizations: { + add: ["PUT /enterprises/{enterprise}/teams/{enterprise-team}/organizations/{org}"], + bulkAdd: ["POST /enterprises/{enterprise}/teams/{enterprise-team}/organizations/add"], + bulkRemove: ["POST /enterprises/{enterprise}/teams/{enterprise-team}/organizations/remove"], + delete: ["DELETE /enterprises/{enterprise}/teams/{enterprise-team}/organizations/{org}"], + getAssignment: ["GET /enterprises/{enterprise}/teams/{enterprise-team}/organizations/{org}"], + getAssignments: ["GET /enterprises/{enterprise}/teams/{enterprise-team}/organizations"] + }, + enterpriseTeams: { + create: ["POST /enterprises/{enterprise}/teams"], + delete: ["DELETE /enterprises/{enterprise}/teams/{team_slug}"], + get: ["GET /enterprises/{enterprise}/teams/{team_slug}"], + list: ["GET /enterprises/{enterprise}/teams"], + update: ["PATCH /enterprises/{enterprise}/teams/{team_slug}"] + }, + gists: { + checkIsStarred: ["GET /gists/{gist_id}/star"], + create: ["POST /gists"], + createComment: ["POST /gists/{gist_id}/comments"], + delete: ["DELETE /gists/{gist_id}"], + deleteComment: ["DELETE /gists/{gist_id}/comments/{comment_id}"], + fork: ["POST /gists/{gist_id}/forks"], + get: ["GET /gists/{gist_id}"], + getComment: ["GET /gists/{gist_id}/comments/{comment_id}"], + getRevision: ["GET /gists/{gist_id}/{sha}"], + list: ["GET /gists"], + listComments: ["GET /gists/{gist_id}/comments"], + listCommits: ["GET /gists/{gist_id}/commits"], + listForUser: ["GET /users/{username}/gists"], + listForks: ["GET /gists/{gist_id}/forks"], + listPublic: ["GET /gists/public"], + listStarred: ["GET /gists/starred"], + star: ["PUT /gists/{gist_id}/star"], + unstar: ["DELETE /gists/{gist_id}/star"], + update: ["PATCH /gists/{gist_id}"], + updateComment: ["PATCH /gists/{gist_id}/comments/{comment_id}"] + }, + git: { + createBlob: ["POST /repos/{owner}/{repo}/git/blobs"], + createCommit: ["POST /repos/{owner}/{repo}/git/commits"], + createRef: ["POST /repos/{owner}/{repo}/git/refs"], + createTag: ["POST /repos/{owner}/{repo}/git/tags"], + createTree: ["POST /repos/{owner}/{repo}/git/trees"], + deleteRef: ["DELETE /repos/{owner}/{repo}/git/refs/{ref}"], + getBlob: ["GET /repos/{owner}/{repo}/git/blobs/{file_sha}"], + getCommit: ["GET /repos/{owner}/{repo}/git/commits/{commit_sha}"], + getRef: ["GET /repos/{owner}/{repo}/git/ref/{ref}"], + getTag: ["GET /repos/{owner}/{repo}/git/tags/{tag_sha}"], + getTree: ["GET /repos/{owner}/{repo}/git/trees/{tree_sha}"], + listMatchingRefs: ["GET /repos/{owner}/{repo}/git/matching-refs/{ref}"], + updateRef: ["PATCH /repos/{owner}/{repo}/git/refs/{ref}"] + }, + gitignore: { + getAllTemplates: ["GET /gitignore/templates"], + getTemplate: ["GET /gitignore/templates/{name}"] + }, + hostedCompute: { + createNetworkConfigurationForOrg: ["POST /orgs/{org}/settings/network-configurations"], + deleteNetworkConfigurationFromOrg: ["DELETE /orgs/{org}/settings/network-configurations/{network_configuration_id}"], + getNetworkConfigurationForOrg: ["GET /orgs/{org}/settings/network-configurations/{network_configuration_id}"], + getNetworkSettingsForOrg: ["GET /orgs/{org}/settings/network-settings/{network_settings_id}"], + listNetworkConfigurationsForOrg: ["GET /orgs/{org}/settings/network-configurations"], + updateNetworkConfigurationForOrg: ["PATCH /orgs/{org}/settings/network-configurations/{network_configuration_id}"] + }, + interactions: { + getRestrictionsForAuthenticatedUser: ["GET /user/interaction-limits"], + getRestrictionsForOrg: ["GET /orgs/{org}/interaction-limits"], + getRestrictionsForRepo: ["GET /repos/{owner}/{repo}/interaction-limits"], + getRestrictionsForYourPublicRepos: [ + "GET /user/interaction-limits", + {}, + { renamed: ["interactions", "getRestrictionsForAuthenticatedUser"] } + ], + removeRestrictionsForAuthenticatedUser: ["DELETE /user/interaction-limits"], + removeRestrictionsForOrg: ["DELETE /orgs/{org}/interaction-limits"], + removeRestrictionsForRepo: ["DELETE /repos/{owner}/{repo}/interaction-limits"], + removeRestrictionsForYourPublicRepos: [ + "DELETE /user/interaction-limits", + {}, + { renamed: ["interactions", "removeRestrictionsForAuthenticatedUser"] } + ], + setRestrictionsForAuthenticatedUser: ["PUT /user/interaction-limits"], + setRestrictionsForOrg: ["PUT /orgs/{org}/interaction-limits"], + setRestrictionsForRepo: ["PUT /repos/{owner}/{repo}/interaction-limits"], + setRestrictionsForYourPublicRepos: [ + "PUT /user/interaction-limits", + {}, + { renamed: ["interactions", "setRestrictionsForAuthenticatedUser"] } + ] + }, + issues: { + addAssignees: ["POST /repos/{owner}/{repo}/issues/{issue_number}/assignees"], + addBlockedByDependency: ["POST /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocked_by"], + addLabels: ["POST /repos/{owner}/{repo}/issues/{issue_number}/labels"], + addSubIssue: ["POST /repos/{owner}/{repo}/issues/{issue_number}/sub_issues"], + checkUserCanBeAssigned: ["GET /repos/{owner}/{repo}/assignees/{assignee}"], + checkUserCanBeAssignedToIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/assignees/{assignee}"], + create: ["POST /repos/{owner}/{repo}/issues"], + createComment: ["POST /repos/{owner}/{repo}/issues/{issue_number}/comments"], + createLabel: ["POST /repos/{owner}/{repo}/labels"], + createMilestone: ["POST /repos/{owner}/{repo}/milestones"], + deleteComment: ["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}"], + deleteLabel: ["DELETE /repos/{owner}/{repo}/labels/{name}"], + deleteMilestone: ["DELETE /repos/{owner}/{repo}/milestones/{milestone_number}"], + get: ["GET /repos/{owner}/{repo}/issues/{issue_number}"], + getComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}"], + getEvent: ["GET /repos/{owner}/{repo}/issues/events/{event_id}"], + getLabel: ["GET /repos/{owner}/{repo}/labels/{name}"], + getMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}"], + getParent: ["GET /repos/{owner}/{repo}/issues/{issue_number}/parent"], + list: ["GET /issues"], + listAssignees: ["GET /repos/{owner}/{repo}/assignees"], + listComments: ["GET /repos/{owner}/{repo}/issues/{issue_number}/comments"], + listCommentsForRepo: ["GET /repos/{owner}/{repo}/issues/comments"], + listDependenciesBlockedBy: ["GET /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocked_by"], + listDependenciesBlocking: ["GET /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocking"], + listEvents: ["GET /repos/{owner}/{repo}/issues/{issue_number}/events"], + listEventsForRepo: ["GET /repos/{owner}/{repo}/issues/events"], + listEventsForTimeline: ["GET /repos/{owner}/{repo}/issues/{issue_number}/timeline"], + listForAuthenticatedUser: ["GET /user/issues"], + listForOrg: ["GET /orgs/{org}/issues"], + listForRepo: ["GET /repos/{owner}/{repo}/issues"], + listLabelsForMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels"], + listLabelsForRepo: ["GET /repos/{owner}/{repo}/labels"], + listLabelsOnIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/labels"], + listMilestones: ["GET /repos/{owner}/{repo}/milestones"], + listSubIssues: ["GET /repos/{owner}/{repo}/issues/{issue_number}/sub_issues"], + lock: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/lock"], + removeAllLabels: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels"], + removeAssignees: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/assignees"], + removeDependencyBlockedBy: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocked_by/{issue_id}"], + removeLabel: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels/{name}"], + removeSubIssue: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/sub_issue"], + reprioritizeSubIssue: ["PATCH /repos/{owner}/{repo}/issues/{issue_number}/sub_issues/priority"], + setLabels: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/labels"], + unlock: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/lock"], + update: ["PATCH /repos/{owner}/{repo}/issues/{issue_number}"], + updateComment: ["PATCH /repos/{owner}/{repo}/issues/comments/{comment_id}"], + updateLabel: ["PATCH /repos/{owner}/{repo}/labels/{name}"], + updateMilestone: ["PATCH /repos/{owner}/{repo}/milestones/{milestone_number}"] + }, + licenses: { + get: ["GET /licenses/{license}"], + getAllCommonlyUsed: ["GET /licenses"], + getForRepo: ["GET /repos/{owner}/{repo}/license"] + }, + markdown: { + render: ["POST /markdown"], + renderRaw: ["POST /markdown/raw", { headers: { "content-type": "text/plain; charset=utf-8" } }] + }, + meta: { + get: ["GET /meta"], + getAllVersions: ["GET /versions"], + getOctocat: ["GET /octocat"], + getZen: ["GET /zen"], + root: ["GET /"] + }, + migrations: { + deleteArchiveForAuthenticatedUser: ["DELETE /user/migrations/{migration_id}/archive"], + deleteArchiveForOrg: ["DELETE /orgs/{org}/migrations/{migration_id}/archive"], + downloadArchiveForOrg: ["GET /orgs/{org}/migrations/{migration_id}/archive"], + getArchiveForAuthenticatedUser: ["GET /user/migrations/{migration_id}/archive"], + getStatusForAuthenticatedUser: ["GET /user/migrations/{migration_id}"], + getStatusForOrg: ["GET /orgs/{org}/migrations/{migration_id}"], + listForAuthenticatedUser: ["GET /user/migrations"], + listForOrg: ["GET /orgs/{org}/migrations"], + listReposForAuthenticatedUser: ["GET /user/migrations/{migration_id}/repositories"], + listReposForOrg: ["GET /orgs/{org}/migrations/{migration_id}/repositories"], + listReposForUser: [ + "GET /user/migrations/{migration_id}/repositories", + {}, + { renamed: ["migrations", "listReposForAuthenticatedUser"] } + ], + startForAuthenticatedUser: ["POST /user/migrations"], + startForOrg: ["POST /orgs/{org}/migrations"], + unlockRepoForAuthenticatedUser: ["DELETE /user/migrations/{migration_id}/repos/{repo_name}/lock"], + unlockRepoForOrg: ["DELETE /orgs/{org}/migrations/{migration_id}/repos/{repo_name}/lock"] + }, + oidc: { + getOidcCustomSubTemplateForOrg: ["GET /orgs/{org}/actions/oidc/customization/sub"], + updateOidcCustomSubTemplateForOrg: ["PUT /orgs/{org}/actions/oidc/customization/sub"] + }, + orgs: { + addSecurityManagerTeam: [ + "PUT /orgs/{org}/security-managers/teams/{team_slug}", + {}, + { deprecated: "octokit.rest.orgs.addSecurityManagerTeam() is deprecated, see https://docs.github.com/rest/orgs/security-managers#add-a-security-manager-team" } + ], + assignTeamToOrgRole: ["PUT /orgs/{org}/organization-roles/teams/{team_slug}/{role_id}"], + assignUserToOrgRole: ["PUT /orgs/{org}/organization-roles/users/{username}/{role_id}"], + blockUser: ["PUT /orgs/{org}/blocks/{username}"], + cancelInvitation: ["DELETE /orgs/{org}/invitations/{invitation_id}"], + checkBlockedUser: ["GET /orgs/{org}/blocks/{username}"], + checkMembershipForUser: ["GET /orgs/{org}/members/{username}"], + checkPublicMembershipForUser: ["GET /orgs/{org}/public_members/{username}"], + convertMemberToOutsideCollaborator: ["PUT /orgs/{org}/outside_collaborators/{username}"], + createArtifactStorageRecord: ["POST /orgs/{org}/artifacts/metadata/storage-record"], + createInvitation: ["POST /orgs/{org}/invitations"], + createIssueType: ["POST /orgs/{org}/issue-types"], + createWebhook: ["POST /orgs/{org}/hooks"], + customPropertiesForOrgsCreateOrUpdateOrganizationValues: ["PATCH /organizations/{org}/org-properties/values"], + customPropertiesForOrgsGetOrganizationValues: ["GET /organizations/{org}/org-properties/values"], + customPropertiesForReposCreateOrUpdateOrganizationDefinition: ["PUT /orgs/{org}/properties/schema/{custom_property_name}"], + customPropertiesForReposCreateOrUpdateOrganizationDefinitions: ["PATCH /orgs/{org}/properties/schema"], + customPropertiesForReposCreateOrUpdateOrganizationValues: ["PATCH /orgs/{org}/properties/values"], + customPropertiesForReposDeleteOrganizationDefinition: ["DELETE /orgs/{org}/properties/schema/{custom_property_name}"], + customPropertiesForReposGetOrganizationDefinition: ["GET /orgs/{org}/properties/schema/{custom_property_name}"], + customPropertiesForReposGetOrganizationDefinitions: ["GET /orgs/{org}/properties/schema"], + customPropertiesForReposGetOrganizationValues: ["GET /orgs/{org}/properties/values"], + delete: ["DELETE /orgs/{org}"], + deleteAttestationsBulk: ["POST /orgs/{org}/attestations/delete-request"], + deleteAttestationsById: ["DELETE /orgs/{org}/attestations/{attestation_id}"], + deleteAttestationsBySubjectDigest: ["DELETE /orgs/{org}/attestations/digest/{subject_digest}"], + deleteIssueType: ["DELETE /orgs/{org}/issue-types/{issue_type_id}"], + deleteWebhook: ["DELETE /orgs/{org}/hooks/{hook_id}"], + disableSelectedRepositoryImmutableReleasesOrganization: ["DELETE /orgs/{org}/settings/immutable-releases/repositories/{repository_id}"], + enableSelectedRepositoryImmutableReleasesOrganization: ["PUT /orgs/{org}/settings/immutable-releases/repositories/{repository_id}"], + get: ["GET /orgs/{org}"], + getImmutableReleasesSettings: ["GET /orgs/{org}/settings/immutable-releases"], + getImmutableReleasesSettingsRepositories: ["GET /orgs/{org}/settings/immutable-releases/repositories"], + getMembershipForAuthenticatedUser: ["GET /user/memberships/orgs/{org}"], + getMembershipForUser: ["GET /orgs/{org}/memberships/{username}"], + getOrgRole: ["GET /orgs/{org}/organization-roles/{role_id}"], + getOrgRulesetHistory: ["GET /orgs/{org}/rulesets/{ruleset_id}/history"], + getOrgRulesetVersion: ["GET /orgs/{org}/rulesets/{ruleset_id}/history/{version_id}"], + getWebhook: ["GET /orgs/{org}/hooks/{hook_id}"], + getWebhookConfigForOrg: ["GET /orgs/{org}/hooks/{hook_id}/config"], + getWebhookDelivery: ["GET /orgs/{org}/hooks/{hook_id}/deliveries/{delivery_id}"], + list: ["GET /organizations"], + listAppInstallations: ["GET /orgs/{org}/installations"], + listArtifactStorageRecords: ["GET /orgs/{org}/artifacts/{subject_digest}/metadata/storage-records"], + listAttestationRepositories: ["GET /orgs/{org}/attestations/repositories"], + listAttestations: ["GET /orgs/{org}/attestations/{subject_digest}"], + listAttestationsBulk: ["POST /orgs/{org}/attestations/bulk-list{?per_page,before,after}"], + listBlockedUsers: ["GET /orgs/{org}/blocks"], + listFailedInvitations: ["GET /orgs/{org}/failed_invitations"], + listForAuthenticatedUser: ["GET /user/orgs"], + listForUser: ["GET /users/{username}/orgs"], + listInvitationTeams: ["GET /orgs/{org}/invitations/{invitation_id}/teams"], + listIssueTypes: ["GET /orgs/{org}/issue-types"], + listMembers: ["GET /orgs/{org}/members"], + listMembershipsForAuthenticatedUser: ["GET /user/memberships/orgs"], + listOrgRoleTeams: ["GET /orgs/{org}/organization-roles/{role_id}/teams"], + listOrgRoleUsers: ["GET /orgs/{org}/organization-roles/{role_id}/users"], + listOrgRoles: ["GET /orgs/{org}/organization-roles"], + listOrganizationFineGrainedPermissions: ["GET /orgs/{org}/organization-fine-grained-permissions"], + listOutsideCollaborators: ["GET /orgs/{org}/outside_collaborators"], + listPatGrantRepositories: ["GET /orgs/{org}/personal-access-tokens/{pat_id}/repositories"], + listPatGrantRequestRepositories: ["GET /orgs/{org}/personal-access-token-requests/{pat_request_id}/repositories"], + listPatGrantRequests: ["GET /orgs/{org}/personal-access-token-requests"], + listPatGrants: ["GET /orgs/{org}/personal-access-tokens"], + listPendingInvitations: ["GET /orgs/{org}/invitations"], + listPublicMembers: ["GET /orgs/{org}/public_members"], + listSecurityManagerTeams: [ + "GET /orgs/{org}/security-managers", + {}, + { deprecated: "octokit.rest.orgs.listSecurityManagerTeams() is deprecated, see https://docs.github.com/rest/orgs/security-managers#list-security-manager-teams" } + ], + listWebhookDeliveries: ["GET /orgs/{org}/hooks/{hook_id}/deliveries"], + listWebhooks: ["GET /orgs/{org}/hooks"], + pingWebhook: ["POST /orgs/{org}/hooks/{hook_id}/pings"], + redeliverWebhookDelivery: ["POST /orgs/{org}/hooks/{hook_id}/deliveries/{delivery_id}/attempts"], + removeMember: ["DELETE /orgs/{org}/members/{username}"], + removeMembershipForUser: ["DELETE /orgs/{org}/memberships/{username}"], + removeOutsideCollaborator: ["DELETE /orgs/{org}/outside_collaborators/{username}"], + removePublicMembershipForAuthenticatedUser: ["DELETE /orgs/{org}/public_members/{username}"], + removeSecurityManagerTeam: [ + "DELETE /orgs/{org}/security-managers/teams/{team_slug}", + {}, + { deprecated: "octokit.rest.orgs.removeSecurityManagerTeam() is deprecated, see https://docs.github.com/rest/orgs/security-managers#remove-a-security-manager-team" } + ], + reviewPatGrantRequest: ["POST /orgs/{org}/personal-access-token-requests/{pat_request_id}"], + reviewPatGrantRequestsInBulk: ["POST /orgs/{org}/personal-access-token-requests"], + revokeAllOrgRolesTeam: ["DELETE /orgs/{org}/organization-roles/teams/{team_slug}"], + revokeAllOrgRolesUser: ["DELETE /orgs/{org}/organization-roles/users/{username}"], + revokeOrgRoleTeam: ["DELETE /orgs/{org}/organization-roles/teams/{team_slug}/{role_id}"], + revokeOrgRoleUser: ["DELETE /orgs/{org}/organization-roles/users/{username}/{role_id}"], + setImmutableReleasesSettings: ["PUT /orgs/{org}/settings/immutable-releases"], + setImmutableReleasesSettingsRepositories: ["PUT /orgs/{org}/settings/immutable-releases/repositories"], + setMembershipForUser: ["PUT /orgs/{org}/memberships/{username}"], + setPublicMembershipForAuthenticatedUser: ["PUT /orgs/{org}/public_members/{username}"], + unblockUser: ["DELETE /orgs/{org}/blocks/{username}"], + update: ["PATCH /orgs/{org}"], + updateIssueType: ["PUT /orgs/{org}/issue-types/{issue_type_id}"], + updateMembershipForAuthenticatedUser: ["PATCH /user/memberships/orgs/{org}"], + updatePatAccess: ["POST /orgs/{org}/personal-access-tokens/{pat_id}"], + updatePatAccesses: ["POST /orgs/{org}/personal-access-tokens"], + updateWebhook: ["PATCH /orgs/{org}/hooks/{hook_id}"], + updateWebhookConfigForOrg: ["PATCH /orgs/{org}/hooks/{hook_id}/config"] + }, + packages: { + deletePackageForAuthenticatedUser: ["DELETE /user/packages/{package_type}/{package_name}"], + deletePackageForOrg: ["DELETE /orgs/{org}/packages/{package_type}/{package_name}"], + deletePackageForUser: ["DELETE /users/{username}/packages/{package_type}/{package_name}"], + deletePackageVersionForAuthenticatedUser: ["DELETE /user/packages/{package_type}/{package_name}/versions/{package_version_id}"], + deletePackageVersionForOrg: ["DELETE /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}"], + deletePackageVersionForUser: ["DELETE /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}"], + getAllPackageVersionsForAPackageOwnedByAnOrg: [ + "GET /orgs/{org}/packages/{package_type}/{package_name}/versions", + {}, + { renamed: ["packages", "getAllPackageVersionsForPackageOwnedByOrg"] } + ], + getAllPackageVersionsForAPackageOwnedByTheAuthenticatedUser: [ + "GET /user/packages/{package_type}/{package_name}/versions", + {}, + { renamed: ["packages", "getAllPackageVersionsForPackageOwnedByAuthenticatedUser"] } + ], + getAllPackageVersionsForPackageOwnedByAuthenticatedUser: ["GET /user/packages/{package_type}/{package_name}/versions"], + getAllPackageVersionsForPackageOwnedByOrg: ["GET /orgs/{org}/packages/{package_type}/{package_name}/versions"], + getAllPackageVersionsForPackageOwnedByUser: ["GET /users/{username}/packages/{package_type}/{package_name}/versions"], + getPackageForAuthenticatedUser: ["GET /user/packages/{package_type}/{package_name}"], + getPackageForOrganization: ["GET /orgs/{org}/packages/{package_type}/{package_name}"], + getPackageForUser: ["GET /users/{username}/packages/{package_type}/{package_name}"], + getPackageVersionForAuthenticatedUser: ["GET /user/packages/{package_type}/{package_name}/versions/{package_version_id}"], + getPackageVersionForOrganization: ["GET /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}"], + getPackageVersionForUser: ["GET /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}"], + listDockerMigrationConflictingPackagesForAuthenticatedUser: ["GET /user/docker/conflicts"], + listDockerMigrationConflictingPackagesForOrganization: ["GET /orgs/{org}/docker/conflicts"], + listDockerMigrationConflictingPackagesForUser: ["GET /users/{username}/docker/conflicts"], + listPackagesForAuthenticatedUser: ["GET /user/packages"], + listPackagesForOrganization: ["GET /orgs/{org}/packages"], + listPackagesForUser: ["GET /users/{username}/packages"], + restorePackageForAuthenticatedUser: ["POST /user/packages/{package_type}/{package_name}/restore{?token}"], + restorePackageForOrg: ["POST /orgs/{org}/packages/{package_type}/{package_name}/restore{?token}"], + restorePackageForUser: ["POST /users/{username}/packages/{package_type}/{package_name}/restore{?token}"], + restorePackageVersionForAuthenticatedUser: ["POST /user/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"], + restorePackageVersionForOrg: ["POST /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"], + restorePackageVersionForUser: ["POST /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"] + }, + privateRegistries: { + createOrgPrivateRegistry: ["POST /orgs/{org}/private-registries"], + deleteOrgPrivateRegistry: ["DELETE /orgs/{org}/private-registries/{secret_name}"], + getOrgPrivateRegistry: ["GET /orgs/{org}/private-registries/{secret_name}"], + getOrgPublicKey: ["GET /orgs/{org}/private-registries/public-key"], + listOrgPrivateRegistries: ["GET /orgs/{org}/private-registries"], + updateOrgPrivateRegistry: ["PATCH /orgs/{org}/private-registries/{secret_name}"] + }, + projects: { + addItemForOrg: ["POST /orgs/{org}/projectsV2/{project_number}/items"], + addItemForUser: ["POST /users/{username}/projectsV2/{project_number}/items"], + deleteItemForOrg: ["DELETE /orgs/{org}/projectsV2/{project_number}/items/{item_id}"], + deleteItemForUser: ["DELETE /users/{username}/projectsV2/{project_number}/items/{item_id}"], + getFieldForOrg: ["GET /orgs/{org}/projectsV2/{project_number}/fields/{field_id}"], + getFieldForUser: ["GET /users/{username}/projectsV2/{project_number}/fields/{field_id}"], + getForOrg: ["GET /orgs/{org}/projectsV2/{project_number}"], + getForUser: ["GET /users/{username}/projectsV2/{project_number}"], + getOrgItem: ["GET /orgs/{org}/projectsV2/{project_number}/items/{item_id}"], + getUserItem: ["GET /users/{username}/projectsV2/{project_number}/items/{item_id}"], + listFieldsForOrg: ["GET /orgs/{org}/projectsV2/{project_number}/fields"], + listFieldsForUser: ["GET /users/{username}/projectsV2/{project_number}/fields"], + listForOrg: ["GET /orgs/{org}/projectsV2"], + listForUser: ["GET /users/{username}/projectsV2"], + listItemsForOrg: ["GET /orgs/{org}/projectsV2/{project_number}/items"], + listItemsForUser: ["GET /users/{username}/projectsV2/{project_number}/items"], + updateItemForOrg: ["PATCH /orgs/{org}/projectsV2/{project_number}/items/{item_id}"], + updateItemForUser: ["PATCH /users/{username}/projectsV2/{project_number}/items/{item_id}"] + }, + pulls: { + checkIfMerged: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/merge"], + create: ["POST /repos/{owner}/{repo}/pulls"], + createReplyForReviewComment: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies"], + createReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews"], + createReviewComment: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments"], + deletePendingReview: ["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"], + deleteReviewComment: ["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}"], + dismissReview: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/dismissals"], + get: ["GET /repos/{owner}/{repo}/pulls/{pull_number}"], + getReview: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"], + getReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}"], + list: ["GET /repos/{owner}/{repo}/pulls"], + listCommentsForReview: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments"], + listCommits: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/commits"], + listFiles: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/files"], + listRequestedReviewers: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"], + listReviewComments: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/comments"], + listReviewCommentsForRepo: ["GET /repos/{owner}/{repo}/pulls/comments"], + listReviews: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews"], + merge: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/merge"], + removeRequestedReviewers: ["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"], + requestReviewers: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"], + submitReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/events"], + update: ["PATCH /repos/{owner}/{repo}/pulls/{pull_number}"], + updateBranch: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/update-branch"], + updateReview: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"], + updateReviewComment: ["PATCH /repos/{owner}/{repo}/pulls/comments/{comment_id}"] + }, + rateLimit: { get: ["GET /rate_limit"] }, + reactions: { + createForCommitComment: ["POST /repos/{owner}/{repo}/comments/{comment_id}/reactions"], + createForIssue: ["POST /repos/{owner}/{repo}/issues/{issue_number}/reactions"], + createForIssueComment: ["POST /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions"], + createForPullRequestReviewComment: ["POST /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions"], + createForRelease: ["POST /repos/{owner}/{repo}/releases/{release_id}/reactions"], + createForTeamDiscussionCommentInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions"], + createForTeamDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions"], + deleteForCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}/reactions/{reaction_id}"], + deleteForIssue: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/reactions/{reaction_id}"], + deleteForIssueComment: ["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions/{reaction_id}"], + deleteForPullRequestComment: ["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions/{reaction_id}"], + deleteForRelease: ["DELETE /repos/{owner}/{repo}/releases/{release_id}/reactions/{reaction_id}"], + deleteForTeamDiscussion: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions/{reaction_id}"], + deleteForTeamDiscussionComment: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions/{reaction_id}"], + listForCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}/reactions"], + listForIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/reactions"], + listForIssueComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions"], + listForPullRequestReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions"], + listForRelease: ["GET /repos/{owner}/{repo}/releases/{release_id}/reactions"], + listForTeamDiscussionCommentInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions"], + listForTeamDiscussionInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions"] + }, + repos: { + acceptInvitation: [ + "PATCH /user/repository_invitations/{invitation_id}", + {}, + { renamed: ["repos", "acceptInvitationForAuthenticatedUser"] } + ], + acceptInvitationForAuthenticatedUser: ["PATCH /user/repository_invitations/{invitation_id}"], + addAppAccessRestrictions: [ + "POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", + {}, + { mapToData: "apps" } + ], + addCollaborator: ["PUT /repos/{owner}/{repo}/collaborators/{username}"], + addStatusCheckContexts: [ + "POST /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", + {}, + { mapToData: "contexts" } + ], + addTeamAccessRestrictions: [ + "POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", + {}, + { mapToData: "teams" } + ], + addUserAccessRestrictions: [ + "POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", + {}, + { mapToData: "users" } + ], + cancelPagesDeployment: ["POST /repos/{owner}/{repo}/pages/deployments/{pages_deployment_id}/cancel"], + checkAutomatedSecurityFixes: ["GET /repos/{owner}/{repo}/automated-security-fixes"], + checkCollaborator: ["GET /repos/{owner}/{repo}/collaborators/{username}"], + checkImmutableReleases: ["GET /repos/{owner}/{repo}/immutable-releases"], + checkPrivateVulnerabilityReporting: ["GET /repos/{owner}/{repo}/private-vulnerability-reporting"], + checkVulnerabilityAlerts: ["GET /repos/{owner}/{repo}/vulnerability-alerts"], + codeownersErrors: ["GET /repos/{owner}/{repo}/codeowners/errors"], + compareCommits: ["GET /repos/{owner}/{repo}/compare/{base}...{head}"], + compareCommitsWithBasehead: ["GET /repos/{owner}/{repo}/compare/{basehead}"], + createAttestation: ["POST /repos/{owner}/{repo}/attestations"], + createAutolink: ["POST /repos/{owner}/{repo}/autolinks"], + createCommitComment: ["POST /repos/{owner}/{repo}/commits/{commit_sha}/comments"], + createCommitSignatureProtection: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"], + createCommitStatus: ["POST /repos/{owner}/{repo}/statuses/{sha}"], + createDeployKey: ["POST /repos/{owner}/{repo}/keys"], + createDeployment: ["POST /repos/{owner}/{repo}/deployments"], + createDeploymentBranchPolicy: ["POST /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies"], + createDeploymentProtectionRule: ["POST /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules"], + createDeploymentStatus: ["POST /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"], + createDispatchEvent: ["POST /repos/{owner}/{repo}/dispatches"], + createForAuthenticatedUser: ["POST /user/repos"], + createFork: ["POST /repos/{owner}/{repo}/forks"], + createInOrg: ["POST /orgs/{org}/repos"], + createOrUpdateEnvironment: ["PUT /repos/{owner}/{repo}/environments/{environment_name}"], + createOrUpdateFileContents: ["PUT /repos/{owner}/{repo}/contents/{path}"], + createOrgRuleset: ["POST /orgs/{org}/rulesets"], + createPagesDeployment: ["POST /repos/{owner}/{repo}/pages/deployments"], + createPagesSite: ["POST /repos/{owner}/{repo}/pages"], + createRelease: ["POST /repos/{owner}/{repo}/releases"], + createRepoRuleset: ["POST /repos/{owner}/{repo}/rulesets"], + createUsingTemplate: ["POST /repos/{template_owner}/{template_repo}/generate"], + createWebhook: ["POST /repos/{owner}/{repo}/hooks"], + customPropertiesForReposCreateOrUpdateRepositoryValues: ["PATCH /repos/{owner}/{repo}/properties/values"], + customPropertiesForReposGetRepositoryValues: ["GET /repos/{owner}/{repo}/properties/values"], + declineInvitation: [ + "DELETE /user/repository_invitations/{invitation_id}", + {}, + { renamed: ["repos", "declineInvitationForAuthenticatedUser"] } + ], + declineInvitationForAuthenticatedUser: ["DELETE /user/repository_invitations/{invitation_id}"], + delete: ["DELETE /repos/{owner}/{repo}"], + deleteAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"], + deleteAdminBranchProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"], + deleteAnEnvironment: ["DELETE /repos/{owner}/{repo}/environments/{environment_name}"], + deleteAutolink: ["DELETE /repos/{owner}/{repo}/autolinks/{autolink_id}"], + deleteBranchProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection"], + deleteCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}"], + deleteCommitSignatureProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"], + deleteDeployKey: ["DELETE /repos/{owner}/{repo}/keys/{key_id}"], + deleteDeployment: ["DELETE /repos/{owner}/{repo}/deployments/{deployment_id}"], + deleteDeploymentBranchPolicy: ["DELETE /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"], + deleteFile: ["DELETE /repos/{owner}/{repo}/contents/{path}"], + deleteInvitation: ["DELETE /repos/{owner}/{repo}/invitations/{invitation_id}"], + deleteOrgRuleset: ["DELETE /orgs/{org}/rulesets/{ruleset_id}"], + deletePagesSite: ["DELETE /repos/{owner}/{repo}/pages"], + deletePullRequestReviewProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"], + deleteRelease: ["DELETE /repos/{owner}/{repo}/releases/{release_id}"], + deleteReleaseAsset: ["DELETE /repos/{owner}/{repo}/releases/assets/{asset_id}"], + deleteRepoRuleset: ["DELETE /repos/{owner}/{repo}/rulesets/{ruleset_id}"], + deleteWebhook: ["DELETE /repos/{owner}/{repo}/hooks/{hook_id}"], + disableAutomatedSecurityFixes: ["DELETE /repos/{owner}/{repo}/automated-security-fixes"], + disableDeploymentProtectionRule: ["DELETE /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/{protection_rule_id}"], + disableImmutableReleases: ["DELETE /repos/{owner}/{repo}/immutable-releases"], + disablePrivateVulnerabilityReporting: ["DELETE /repos/{owner}/{repo}/private-vulnerability-reporting"], + disableVulnerabilityAlerts: ["DELETE /repos/{owner}/{repo}/vulnerability-alerts"], + downloadArchive: [ + "GET /repos/{owner}/{repo}/zipball/{ref}", + {}, + { renamed: ["repos", "downloadZipballArchive"] } + ], + downloadTarballArchive: ["GET /repos/{owner}/{repo}/tarball/{ref}"], + downloadZipballArchive: ["GET /repos/{owner}/{repo}/zipball/{ref}"], + enableAutomatedSecurityFixes: ["PUT /repos/{owner}/{repo}/automated-security-fixes"], + enableImmutableReleases: ["PUT /repos/{owner}/{repo}/immutable-releases"], + enablePrivateVulnerabilityReporting: ["PUT /repos/{owner}/{repo}/private-vulnerability-reporting"], + enableVulnerabilityAlerts: ["PUT /repos/{owner}/{repo}/vulnerability-alerts"], + generateReleaseNotes: ["POST /repos/{owner}/{repo}/releases/generate-notes"], + get: ["GET /repos/{owner}/{repo}"], + getAccessRestrictions: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"], + getAdminBranchProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"], + getAllDeploymentProtectionRules: ["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules"], + getAllEnvironments: ["GET /repos/{owner}/{repo}/environments"], + getAllStatusCheckContexts: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts"], + getAllTopics: ["GET /repos/{owner}/{repo}/topics"], + getAppsWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps"], + getAutolink: ["GET /repos/{owner}/{repo}/autolinks/{autolink_id}"], + getBranch: ["GET /repos/{owner}/{repo}/branches/{branch}"], + getBranchProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection"], + getBranchRules: ["GET /repos/{owner}/{repo}/rules/branches/{branch}"], + getClones: ["GET /repos/{owner}/{repo}/traffic/clones"], + getCodeFrequencyStats: ["GET /repos/{owner}/{repo}/stats/code_frequency"], + getCollaboratorPermissionLevel: ["GET /repos/{owner}/{repo}/collaborators/{username}/permission"], + getCombinedStatusForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/status"], + getCommit: ["GET /repos/{owner}/{repo}/commits/{ref}"], + getCommitActivityStats: ["GET /repos/{owner}/{repo}/stats/commit_activity"], + getCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}"], + getCommitSignatureProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"], + getCommunityProfileMetrics: ["GET /repos/{owner}/{repo}/community/profile"], + getContent: ["GET /repos/{owner}/{repo}/contents/{path}"], + getContributorsStats: ["GET /repos/{owner}/{repo}/stats/contributors"], + getCustomDeploymentProtectionRule: ["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/{protection_rule_id}"], + getDeployKey: ["GET /repos/{owner}/{repo}/keys/{key_id}"], + getDeployment: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}"], + getDeploymentBranchPolicy: ["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"], + getDeploymentStatus: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses/{status_id}"], + getEnvironment: ["GET /repos/{owner}/{repo}/environments/{environment_name}"], + getLatestPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/latest"], + getLatestRelease: ["GET /repos/{owner}/{repo}/releases/latest"], + getOrgRuleSuite: ["GET /orgs/{org}/rulesets/rule-suites/{rule_suite_id}"], + getOrgRuleSuites: ["GET /orgs/{org}/rulesets/rule-suites"], + getOrgRuleset: ["GET /orgs/{org}/rulesets/{ruleset_id}"], + getOrgRulesets: ["GET /orgs/{org}/rulesets"], + getPages: ["GET /repos/{owner}/{repo}/pages"], + getPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/{build_id}"], + getPagesDeployment: ["GET /repos/{owner}/{repo}/pages/deployments/{pages_deployment_id}"], + getPagesHealthCheck: ["GET /repos/{owner}/{repo}/pages/health"], + getParticipationStats: ["GET /repos/{owner}/{repo}/stats/participation"], + getPullRequestReviewProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"], + getPunchCardStats: ["GET /repos/{owner}/{repo}/stats/punch_card"], + getReadme: ["GET /repos/{owner}/{repo}/readme"], + getReadmeInDirectory: ["GET /repos/{owner}/{repo}/readme/{dir}"], + getRelease: ["GET /repos/{owner}/{repo}/releases/{release_id}"], + getReleaseAsset: ["GET /repos/{owner}/{repo}/releases/assets/{asset_id}"], + getReleaseByTag: ["GET /repos/{owner}/{repo}/releases/tags/{tag}"], + getRepoRuleSuite: ["GET /repos/{owner}/{repo}/rulesets/rule-suites/{rule_suite_id}"], + getRepoRuleSuites: ["GET /repos/{owner}/{repo}/rulesets/rule-suites"], + getRepoRuleset: ["GET /repos/{owner}/{repo}/rulesets/{ruleset_id}"], + getRepoRulesetHistory: ["GET /repos/{owner}/{repo}/rulesets/{ruleset_id}/history"], + getRepoRulesetVersion: ["GET /repos/{owner}/{repo}/rulesets/{ruleset_id}/history/{version_id}"], + getRepoRulesets: ["GET /repos/{owner}/{repo}/rulesets"], + getStatusChecksProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"], + getTeamsWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams"], + getTopPaths: ["GET /repos/{owner}/{repo}/traffic/popular/paths"], + getTopReferrers: ["GET /repos/{owner}/{repo}/traffic/popular/referrers"], + getUsersWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users"], + getViews: ["GET /repos/{owner}/{repo}/traffic/views"], + getWebhook: ["GET /repos/{owner}/{repo}/hooks/{hook_id}"], + getWebhookConfigForRepo: ["GET /repos/{owner}/{repo}/hooks/{hook_id}/config"], + getWebhookDelivery: ["GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries/{delivery_id}"], + listActivities: ["GET /repos/{owner}/{repo}/activity"], + listAttestations: ["GET /repos/{owner}/{repo}/attestations/{subject_digest}"], + listAutolinks: ["GET /repos/{owner}/{repo}/autolinks"], + listBranches: ["GET /repos/{owner}/{repo}/branches"], + listBranchesForHeadCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/branches-where-head"], + listCollaborators: ["GET /repos/{owner}/{repo}/collaborators"], + listCommentsForCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/comments"], + listCommitCommentsForRepo: ["GET /repos/{owner}/{repo}/comments"], + listCommitStatusesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/statuses"], + listCommits: ["GET /repos/{owner}/{repo}/commits"], + listContributors: ["GET /repos/{owner}/{repo}/contributors"], + listCustomDeploymentRuleIntegrations: ["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/apps"], + listDeployKeys: ["GET /repos/{owner}/{repo}/keys"], + listDeploymentBranchPolicies: ["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies"], + listDeploymentStatuses: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"], + listDeployments: ["GET /repos/{owner}/{repo}/deployments"], + listForAuthenticatedUser: ["GET /user/repos"], + listForOrg: ["GET /orgs/{org}/repos"], + listForUser: ["GET /users/{username}/repos"], + listForks: ["GET /repos/{owner}/{repo}/forks"], + listInvitations: ["GET /repos/{owner}/{repo}/invitations"], + listInvitationsForAuthenticatedUser: ["GET /user/repository_invitations"], + listLanguages: ["GET /repos/{owner}/{repo}/languages"], + listPagesBuilds: ["GET /repos/{owner}/{repo}/pages/builds"], + listPublic: ["GET /repositories"], + listPullRequestsAssociatedWithCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls"], + listReleaseAssets: ["GET /repos/{owner}/{repo}/releases/{release_id}/assets"], + listReleases: ["GET /repos/{owner}/{repo}/releases"], + listTags: ["GET /repos/{owner}/{repo}/tags"], + listTeams: ["GET /repos/{owner}/{repo}/teams"], + listWebhookDeliveries: ["GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries"], + listWebhooks: ["GET /repos/{owner}/{repo}/hooks"], + merge: ["POST /repos/{owner}/{repo}/merges"], + mergeUpstream: ["POST /repos/{owner}/{repo}/merge-upstream"], + pingWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/pings"], + redeliverWebhookDelivery: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/deliveries/{delivery_id}/attempts"], + removeAppAccessRestrictions: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", + {}, + { mapToData: "apps" } + ], + removeCollaborator: ["DELETE /repos/{owner}/{repo}/collaborators/{username}"], + removeStatusCheckContexts: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", + {}, + { mapToData: "contexts" } + ], + removeStatusCheckProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"], + removeTeamAccessRestrictions: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", + {}, + { mapToData: "teams" } + ], + removeUserAccessRestrictions: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", + {}, + { mapToData: "users" } + ], + renameBranch: ["POST /repos/{owner}/{repo}/branches/{branch}/rename"], + replaceAllTopics: ["PUT /repos/{owner}/{repo}/topics"], + requestPagesBuild: ["POST /repos/{owner}/{repo}/pages/builds"], + setAdminBranchProtection: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"], + setAppAccessRestrictions: [ + "PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", + {}, + { mapToData: "apps" } + ], + setStatusCheckContexts: [ + "PUT /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", + {}, + { mapToData: "contexts" } + ], + setTeamAccessRestrictions: [ + "PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", + {}, + { mapToData: "teams" } + ], + setUserAccessRestrictions: [ + "PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", + {}, + { mapToData: "users" } + ], + testPushWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/tests"], + transfer: ["POST /repos/{owner}/{repo}/transfer"], + update: ["PATCH /repos/{owner}/{repo}"], + updateBranchProtection: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection"], + updateCommitComment: ["PATCH /repos/{owner}/{repo}/comments/{comment_id}"], + updateDeploymentBranchPolicy: ["PUT /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"], + updateInformationAboutPagesSite: ["PUT /repos/{owner}/{repo}/pages"], + updateInvitation: ["PATCH /repos/{owner}/{repo}/invitations/{invitation_id}"], + updateOrgRuleset: ["PUT /orgs/{org}/rulesets/{ruleset_id}"], + updatePullRequestReviewProtection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"], + updateRelease: ["PATCH /repos/{owner}/{repo}/releases/{release_id}"], + updateReleaseAsset: ["PATCH /repos/{owner}/{repo}/releases/assets/{asset_id}"], + updateRepoRuleset: ["PUT /repos/{owner}/{repo}/rulesets/{ruleset_id}"], + updateStatusCheckPotection: [ + "PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks", + {}, + { renamed: ["repos", "updateStatusCheckProtection"] } + ], + updateStatusCheckProtection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"], + updateWebhook: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}"], + updateWebhookConfigForRepo: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}/config"], + uploadReleaseAsset: ["POST /repos/{owner}/{repo}/releases/{release_id}/assets{?name,label}", { baseUrl: "https://uploads.github.com" }] + }, + search: { + code: ["GET /search/code"], + commits: ["GET /search/commits"], + issuesAndPullRequests: ["GET /search/issues"], + labels: ["GET /search/labels"], + repos: ["GET /search/repositories"], + topics: ["GET /search/topics"], + users: ["GET /search/users"] + }, + secretScanning: { + createPushProtectionBypass: ["POST /repos/{owner}/{repo}/secret-scanning/push-protection-bypasses"], + getAlert: ["GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"], + getScanHistory: ["GET /repos/{owner}/{repo}/secret-scanning/scan-history"], + listAlertsForOrg: ["GET /orgs/{org}/secret-scanning/alerts"], + listAlertsForRepo: ["GET /repos/{owner}/{repo}/secret-scanning/alerts"], + listLocationsForAlert: ["GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}/locations"], + listOrgPatternConfigs: ["GET /orgs/{org}/secret-scanning/pattern-configurations"], + updateAlert: ["PATCH /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"], + updateOrgPatternConfigs: ["PATCH /orgs/{org}/secret-scanning/pattern-configurations"] + }, + securityAdvisories: { + createFork: ["POST /repos/{owner}/{repo}/security-advisories/{ghsa_id}/forks"], + createPrivateVulnerabilityReport: ["POST /repos/{owner}/{repo}/security-advisories/reports"], + createRepositoryAdvisory: ["POST /repos/{owner}/{repo}/security-advisories"], + createRepositoryAdvisoryCveRequest: ["POST /repos/{owner}/{repo}/security-advisories/{ghsa_id}/cve"], + getGlobalAdvisory: ["GET /advisories/{ghsa_id}"], + getRepositoryAdvisory: ["GET /repos/{owner}/{repo}/security-advisories/{ghsa_id}"], + listGlobalAdvisories: ["GET /advisories"], + listOrgRepositoryAdvisories: ["GET /orgs/{org}/security-advisories"], + listRepositoryAdvisories: ["GET /repos/{owner}/{repo}/security-advisories"], + updateRepositoryAdvisory: ["PATCH /repos/{owner}/{repo}/security-advisories/{ghsa_id}"] + }, + teams: { + addOrUpdateMembershipForUserInOrg: ["PUT /orgs/{org}/teams/{team_slug}/memberships/{username}"], + addOrUpdateRepoPermissionsInOrg: ["PUT /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"], + checkPermissionsForRepoInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"], + create: ["POST /orgs/{org}/teams"], + createDiscussionCommentInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"], + createDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions"], + deleteDiscussionCommentInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"], + deleteDiscussionInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"], + deleteInOrg: ["DELETE /orgs/{org}/teams/{team_slug}"], + getByName: ["GET /orgs/{org}/teams/{team_slug}"], + getDiscussionCommentInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"], + getDiscussionInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"], + getMembershipForUserInOrg: ["GET /orgs/{org}/teams/{team_slug}/memberships/{username}"], + list: ["GET /orgs/{org}/teams"], + listChildInOrg: ["GET /orgs/{org}/teams/{team_slug}/teams"], + listDiscussionCommentsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"], + listDiscussionsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions"], + listForAuthenticatedUser: ["GET /user/teams"], + listMembersInOrg: ["GET /orgs/{org}/teams/{team_slug}/members"], + listPendingInvitationsInOrg: ["GET /orgs/{org}/teams/{team_slug}/invitations"], + listReposInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos"], + removeMembershipForUserInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/memberships/{username}"], + removeRepoInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"], + updateDiscussionCommentInOrg: ["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"], + updateDiscussionInOrg: ["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"], + updateInOrg: ["PATCH /orgs/{org}/teams/{team_slug}"] + }, + users: { + addEmailForAuthenticated: [ + "POST /user/emails", + {}, + { renamed: ["users", "addEmailForAuthenticatedUser"] } + ], + addEmailForAuthenticatedUser: ["POST /user/emails"], + addSocialAccountForAuthenticatedUser: ["POST /user/social_accounts"], + block: ["PUT /user/blocks/{username}"], + checkBlocked: ["GET /user/blocks/{username}"], + checkFollowingForUser: ["GET /users/{username}/following/{target_user}"], + checkPersonIsFollowedByAuthenticated: ["GET /user/following/{username}"], + createGpgKeyForAuthenticated: [ + "POST /user/gpg_keys", + {}, + { renamed: ["users", "createGpgKeyForAuthenticatedUser"] } + ], + createGpgKeyForAuthenticatedUser: ["POST /user/gpg_keys"], + createPublicSshKeyForAuthenticated: [ + "POST /user/keys", + {}, + { renamed: ["users", "createPublicSshKeyForAuthenticatedUser"] } + ], + createPublicSshKeyForAuthenticatedUser: ["POST /user/keys"], + createSshSigningKeyForAuthenticatedUser: ["POST /user/ssh_signing_keys"], + deleteAttestationsBulk: ["POST /users/{username}/attestations/delete-request"], + deleteAttestationsById: ["DELETE /users/{username}/attestations/{attestation_id}"], + deleteAttestationsBySubjectDigest: ["DELETE /users/{username}/attestations/digest/{subject_digest}"], + deleteEmailForAuthenticated: [ + "DELETE /user/emails", + {}, + { renamed: ["users", "deleteEmailForAuthenticatedUser"] } + ], + deleteEmailForAuthenticatedUser: ["DELETE /user/emails"], + deleteGpgKeyForAuthenticated: [ + "DELETE /user/gpg_keys/{gpg_key_id}", + {}, + { renamed: ["users", "deleteGpgKeyForAuthenticatedUser"] } + ], + deleteGpgKeyForAuthenticatedUser: ["DELETE /user/gpg_keys/{gpg_key_id}"], + deletePublicSshKeyForAuthenticated: [ + "DELETE /user/keys/{key_id}", + {}, + { renamed: ["users", "deletePublicSshKeyForAuthenticatedUser"] } + ], + deletePublicSshKeyForAuthenticatedUser: ["DELETE /user/keys/{key_id}"], + deleteSocialAccountForAuthenticatedUser: ["DELETE /user/social_accounts"], + deleteSshSigningKeyForAuthenticatedUser: ["DELETE /user/ssh_signing_keys/{ssh_signing_key_id}"], + follow: ["PUT /user/following/{username}"], + getAuthenticated: ["GET /user"], + getById: ["GET /user/{account_id}"], + getByUsername: ["GET /users/{username}"], + getContextForUser: ["GET /users/{username}/hovercard"], + getGpgKeyForAuthenticated: [ + "GET /user/gpg_keys/{gpg_key_id}", + {}, + { renamed: ["users", "getGpgKeyForAuthenticatedUser"] } + ], + getGpgKeyForAuthenticatedUser: ["GET /user/gpg_keys/{gpg_key_id}"], + getPublicSshKeyForAuthenticated: [ + "GET /user/keys/{key_id}", + {}, + { renamed: ["users", "getPublicSshKeyForAuthenticatedUser"] } + ], + getPublicSshKeyForAuthenticatedUser: ["GET /user/keys/{key_id}"], + getSshSigningKeyForAuthenticatedUser: ["GET /user/ssh_signing_keys/{ssh_signing_key_id}"], + list: ["GET /users"], + listAttestations: ["GET /users/{username}/attestations/{subject_digest}"], + listAttestationsBulk: ["POST /users/{username}/attestations/bulk-list{?per_page,before,after}"], + listBlockedByAuthenticated: [ + "GET /user/blocks", + {}, + { renamed: ["users", "listBlockedByAuthenticatedUser"] } + ], + listBlockedByAuthenticatedUser: ["GET /user/blocks"], + listEmailsForAuthenticated: [ + "GET /user/emails", + {}, + { renamed: ["users", "listEmailsForAuthenticatedUser"] } + ], + listEmailsForAuthenticatedUser: ["GET /user/emails"], + listFollowedByAuthenticated: [ + "GET /user/following", + {}, + { renamed: ["users", "listFollowedByAuthenticatedUser"] } + ], + listFollowedByAuthenticatedUser: ["GET /user/following"], + listFollowersForAuthenticatedUser: ["GET /user/followers"], + listFollowersForUser: ["GET /users/{username}/followers"], + listFollowingForUser: ["GET /users/{username}/following"], + listGpgKeysForAuthenticated: [ + "GET /user/gpg_keys", + {}, + { renamed: ["users", "listGpgKeysForAuthenticatedUser"] } + ], + listGpgKeysForAuthenticatedUser: ["GET /user/gpg_keys"], + listGpgKeysForUser: ["GET /users/{username}/gpg_keys"], + listPublicEmailsForAuthenticated: [ + "GET /user/public_emails", + {}, + { renamed: ["users", "listPublicEmailsForAuthenticatedUser"] } + ], + listPublicEmailsForAuthenticatedUser: ["GET /user/public_emails"], + listPublicKeysForUser: ["GET /users/{username}/keys"], + listPublicSshKeysForAuthenticated: [ + "GET /user/keys", + {}, + { renamed: ["users", "listPublicSshKeysForAuthenticatedUser"] } + ], + listPublicSshKeysForAuthenticatedUser: ["GET /user/keys"], + listSocialAccountsForAuthenticatedUser: ["GET /user/social_accounts"], + listSocialAccountsForUser: ["GET /users/{username}/social_accounts"], + listSshSigningKeysForAuthenticatedUser: ["GET /user/ssh_signing_keys"], + listSshSigningKeysForUser: ["GET /users/{username}/ssh_signing_keys"], + setPrimaryEmailVisibilityForAuthenticated: [ + "PATCH /user/email/visibility", + {}, + { renamed: ["users", "setPrimaryEmailVisibilityForAuthenticatedUser"] } + ], + setPrimaryEmailVisibilityForAuthenticatedUser: ["PATCH /user/email/visibility"], + unblock: ["DELETE /user/blocks/{username}"], + unfollow: ["DELETE /user/following/{username}"], + updateAuthenticated: ["PATCH /user"] + } +}; +//#endregion +//#region ../../node_modules/.pnpm/@octokit+plugin-rest-endpoint-methods@17.0.0_@octokit+core@7.0.6/node_modules/@octokit/plugin-rest-endpoint-methods/dist-src/endpoints-to-methods.js +const endpointMethodsMap = /* @__PURE__ */ new Map(); +for (const [scope, endpoints] of Object.entries(endpoints_default)) for (const [methodName, endpoint] of Object.entries(endpoints)) { + const [route, defaults, decorations] = endpoint; + const [method, url] = route.split(/ /); + const endpointDefaults = Object.assign({ + method, + url + }, defaults); + if (!endpointMethodsMap.has(scope)) endpointMethodsMap.set(scope, /* @__PURE__ */ new Map()); + endpointMethodsMap.get(scope).set(methodName, { + scope, + methodName, + endpointDefaults, + decorations + }); +} +const handler = { + has({ scope }, methodName) { + return endpointMethodsMap.get(scope).has(methodName); + }, + getOwnPropertyDescriptor(target, methodName) { + return { + value: this.get(target, methodName), + configurable: true, + writable: true, + enumerable: true + }; + }, + defineProperty(target, methodName, descriptor) { + Object.defineProperty(target.cache, methodName, descriptor); + return true; + }, + deleteProperty(target, methodName) { + delete target.cache[methodName]; + return true; + }, + ownKeys({ scope }) { + return [...endpointMethodsMap.get(scope).keys()]; + }, + set(target, methodName, value) { + return target.cache[methodName] = value; + }, + get({ octokit, scope, cache }, methodName) { + if (cache[methodName]) return cache[methodName]; + const method = endpointMethodsMap.get(scope).get(methodName); + if (!method) return; + const { endpointDefaults, decorations } = method; + if (decorations) cache[methodName] = decorate(octokit, scope, methodName, endpointDefaults, decorations); + else cache[methodName] = octokit.request.defaults(endpointDefaults); + return cache[methodName]; + } +}; +function endpointsToMethods(octokit) { + const newMethods = {}; + for (const scope of endpointMethodsMap.keys()) newMethods[scope] = new Proxy({ + octokit, + scope, + cache: {} + }, handler); + return newMethods; +} +function decorate(octokit, scope, methodName, defaults, decorations) { + const requestWithDefaults = octokit.request.defaults(defaults); + function withDecorations(...args) { + let options = requestWithDefaults.endpoint.merge(...args); + if (decorations.mapToData) { + options = Object.assign({}, options, { + data: options[decorations.mapToData], + [decorations.mapToData]: void 0 + }); + return requestWithDefaults(options); + } + if (decorations.renamed) { + const [newScope, newMethodName] = decorations.renamed; + octokit.log.warn(`octokit.${scope}.${methodName}() has been renamed to octokit.${newScope}.${newMethodName}()`); + } + if (decorations.deprecated) octokit.log.warn(decorations.deprecated); + if (decorations.renamedParameters) { + const options2 = requestWithDefaults.endpoint.merge(...args); + for (const [name, alias] of Object.entries(decorations.renamedParameters)) if (name in options2) { + octokit.log.warn(`"${name}" parameter is deprecated for "octokit.${scope}.${methodName}()". Use "${alias}" instead`); + if (!(alias in options2)) options2[alias] = options2[name]; + delete options2[name]; + } + return requestWithDefaults(options2); + } + return requestWithDefaults(...args); + } + return Object.assign(withDecorations, requestWithDefaults); +} +//#endregion +//#region ../../node_modules/.pnpm/@octokit+plugin-rest-endpoint-methods@17.0.0_@octokit+core@7.0.6/node_modules/@octokit/plugin-rest-endpoint-methods/dist-src/index.js +function restEndpointMethods(octokit) { + return { rest: endpointsToMethods(octokit) }; +} +restEndpointMethods.VERSION = VERSION$2; +function legacyRestEndpointMethods(octokit) { + const api = endpointsToMethods(octokit); + return { + ...api, + rest: api + }; +} +legacyRestEndpointMethods.VERSION = VERSION$2; +//#endregion +//#region ../../node_modules/.pnpm/@octokit+plugin-paginate-rest@14.0.0_@octokit+core@7.0.6/node_modules/@octokit/plugin-paginate-rest/dist-bundle/index.js +var VERSION$1 = "0.0.0-development"; +function normalizePaginatedListResponse(response) { + if (!response.data) return { + ...response, + data: [] + }; + if (!(("total_count" in response.data || "total_commits" in response.data) && !("url" in response.data))) return response; + const incompleteResults = response.data.incomplete_results; + const repositorySelection = response.data.repository_selection; + const totalCount = response.data.total_count; + const totalCommits = response.data.total_commits; + delete response.data.incomplete_results; + delete response.data.repository_selection; + delete response.data.total_count; + delete response.data.total_commits; + const namespaceKey = Object.keys(response.data)[0]; + response.data = response.data[namespaceKey]; + if (typeof incompleteResults !== "undefined") response.data.incomplete_results = incompleteResults; + if (typeof repositorySelection !== "undefined") response.data.repository_selection = repositorySelection; + response.data.total_count = totalCount; + response.data.total_commits = totalCommits; + return response; +} +function iterator(octokit, route, parameters) { + const options = typeof route === "function" ? route.endpoint(parameters) : octokit.request.endpoint(route, parameters); + const requestMethod = typeof route === "function" ? route : octokit.request; + const method = options.method; + const headers = options.headers; + let url = options.url; + return { [Symbol.asyncIterator]: () => ({ async next() { + if (!url) return { done: true }; + try { + const normalizedResponse = normalizePaginatedListResponse(await requestMethod({ + method, + url, + headers + })); + url = ((normalizedResponse.headers.link || "").match(/<([^<>]+)>;\s*rel="next"/) || [])[1]; + if (!url && "total_commits" in normalizedResponse.data) { + const parsedUrl = new URL(normalizedResponse.url); + const params = parsedUrl.searchParams; + const page = parseInt(params.get("page") || "1", 10); + if (page * parseInt(params.get("per_page") || "250", 10) < normalizedResponse.data.total_commits) { + params.set("page", String(page + 1)); + url = parsedUrl.toString(); + } + } + return { value: normalizedResponse }; + } catch (error) { + if (error.status !== 409) throw error; + url = ""; + return { value: { + status: 200, + headers: {}, + data: [] + } }; + } + } }) }; +} +function paginate(octokit, route, parameters, mapFn) { + if (typeof parameters === "function") { + mapFn = parameters; + parameters = void 0; + } + return gather(octokit, [], iterator(octokit, route, parameters)[Symbol.asyncIterator](), mapFn); +} +function gather(octokit, results, iterator2, mapFn) { + return iterator2.next().then((result) => { + if (result.done) return results; + let earlyExit = false; + function done() { + earlyExit = true; + } + results = results.concat(mapFn ? mapFn(result.value, done) : result.value.data); + if (earlyExit) return results; + return gather(octokit, results, iterator2, mapFn); + }); +} +Object.assign(paginate, { iterator }); +function paginateRest(octokit) { + return { paginate: Object.assign(paginate.bind(null, octokit), { iterator: iterator.bind(null, octokit) }) }; +} +paginateRest.VERSION = VERSION$1; +new Context(); +const baseUrl = getApiBaseUrl(); +const defaults$1 = { + baseUrl, + request: { + agent: getProxyAgent(baseUrl), + fetch: getProxyFetch(baseUrl) + } +}; +const GitHub = Octokit.plugin(restEndpointMethods, paginateRest).defaults(defaults$1); +/** +* Convience function to correctly format Octokit Options to pass into the constructor. +* +* @param token the repo PAT or GITHUB_TOKEN +* @param options other options to set +*/ +function getOctokitOptions(token, options) { + const opts = Object.assign({}, options || {}); + const auth = getAuthString(token, opts); + if (auth) opts.auth = auth; + const userAgent = getUserAgentWithOrchestrationId(opts.userAgent); + if (userAgent) opts.userAgent = userAgent; + return opts; +} +//#endregion +//#region ../../node_modules/.pnpm/@actions+github@9.1.1/node_modules/@actions/github/lib/github.js +const context = new Context(); +/** +* Returns a hydrated octokit ready to use for GitHub Actions +* +* @param token the repo PAT or GITHUB_TOKEN +* @param options other options to set +*/ +function getOctokit(token, options, ...additionalPlugins) { + return new (GitHub.plugin(...additionalPlugins))(getOctokitOptions(token, options)); +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/tslib.mjs +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); +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/utils/uuid.mjs +/** +* https://stackoverflow.com/a/2117523 +*/ +let uuid4 = function() { + const { crypto } = globalThis; + if (crypto?.randomUUID) { + uuid4 = crypto.randomUUID.bind(crypto); + return crypto.randomUUID(); + } + const u8 = /* @__PURE__ */ new Uint8Array(1); + const randomByte = crypto ? () => crypto.getRandomValues(u8)[0] : () => Math.random() * 255 & 255; + return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c) => (+c ^ randomByte() & 15 >> +c / 4).toString(16)); +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/errors.mjs +function isAbortError(err) { + return typeof err === "object" && err !== null && ("name" in err && err.name === "AbortError" || "message" in err && String(err.message).includes("FetchRequestCanceledException")); +} +const castToError = (err) => { + if (err instanceof Error) return err; + if (typeof err === "object" && err !== null) { + try { + if (Object.prototype.toString.call(err) === "[object Error]") { + const hasCause = "cause" in err; + const error = new Error(err.message, hasCause ? { cause: err.cause } : {}); + if (err.stack) error.stack = err.stack; + if (hasCause && !Object.prototype.hasOwnProperty.call(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); +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/core/error.mjs +var OpenAIError = class extends Error {}; +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: 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); + } +}; +var APIUserAbortError = class extends APIError { + constructor({ message } = {}) { + super(void 0, void 0, message || "Request was aborted.", void 0); + } +}; +var APIConnectionError = class extends APIError { + constructor({ message, cause }) { + super(void 0, void 0, message || "Connection error.", void 0); + if (cause) this.cause = cause; + } +}; +var APIConnectionTimeoutError = class extends APIConnectionError { + constructor({ message } = {}) { + super({ message: message ?? "Request timed out." }); + } +}; +var BadRequestError = class extends APIError {}; +var AuthenticationError = class extends APIError {}; +var PermissionDeniedError = class extends APIError {}; +var NotFoundError = class extends APIError {}; +var ConflictError = class extends APIError {}; +var UnprocessableEntityError = class extends APIError {}; +var RateLimitError = class extends APIError {}; +var InternalServerError = class extends APIError {}; +var LengthFinishReasonError = class extends OpenAIError { + constructor() { + super(`Could not parse response content as the length limit was reached`); + } +}; +var ContentFilterFinishReasonError = class extends OpenAIError { + constructor() { + super(`Could not parse response content as the request was rejected by the content filter`); + } +}; +var InvalidWebhookSignatureError = class extends Error { + constructor(message) { + super(message); + } +}; +/** +* 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. +*/ +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; + } +}; +var SubjectTokenProviderError = class extends OpenAIError { + constructor(message, provider, cause) { + super(message); + this.provider = provider; + this.cause = cause; + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/utils/values.mjs +const startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i; +const isAbsoluteURL = (url) => { + return startsWithSchemeRegexp.test(url); +}; +let isArray = (val) => (isArray = Array.isArray, isArray(val)); +let isReadonlyArray = isArray; +/** Returns an object if the given value isn't an object, otherwise returns as-is */ +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); +} +const validatePositiveInteger = (name, n) => { + if (typeof n !== "number" || !Number.isInteger(n)) throw new OpenAIError(`${name} must be an integer`); + if (n < 0) throw new OpenAIError(`${name} must be a positive integer`); + return n; +}; +const safeJSON = (text) => { + try { + return JSON.parse(text); + } catch (err) { + return; + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/utils/sleep.mjs +const sleep = (ms, ...signals) => new Promise((resolve, reject) => { + const activeSignals = [...new Set(signals.filter((signal) => signal != null))]; + let timeout; + let settled = false; + const cleanup = () => { + for (const signal of activeSignals) try { + signal.removeEventListener("abort", abort); + } catch {} + }; + const settle = (callback) => { + if (settled) return; + settled = true; + if (timeout !== void 0) { + clearTimeout(timeout); + timeout = void 0; + } + cleanup(); + callback(); + }; + const abort = () => { + settle(() => reject()); + }; + if (activeSignals.some((signal) => signal.aborted)) { + abort(); + return; + } + timeout = setTimeout(() => { + settle(resolve); + }, ms); + for (const signal of activeSignals) { + if (settled) break; + try { + signal.addEventListener("abort", abort, { once: true }); + } catch (error) { + settle(() => reject(error)); + } + } + if (activeSignals.some((signal) => signal.aborted)) abort(); +}); +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/utils/abort.mjs +const weakGlobals = globalThis; +const finalizer = typeof weakGlobals.FinalizationRegistry === "function" ? new weakGlobals.FinalizationRegistry((cleanup) => { + try { + cleanup(); + } catch {} +}) : void 0; +const callbackOwners = /* @__PURE__ */ new WeakMap(); +const subscriptions = /* @__PURE__ */ new WeakMap(); +function subscribeWeakly(signal, reference, registry) { + let subscription = subscriptions.get(signal); + if (!subscription) { + const callbacks = /* @__PURE__ */ new Set(); + const abort = () => { + subscriptions.delete(signal); + for (const callback of callbacks) { + registry.unregister(callback); + callback.deref()?.(); + } + callbacks.clear(); + }; + subscription = { + callbacks, + abort + }; + signal.addEventListener("abort", abort, { once: true }); + subscriptions.set(signal, subscription); + } + const owner = subscription; + owner.callbacks.add(reference); + return () => { + owner.callbacks.delete(reference); + registry.unregister(reference); + if (owner.callbacks.size === 0) { + if (subscriptions.get(signal) === owner) subscriptions.delete(signal); + signal.removeEventListener("abort", owner.abort); + } + }; +} +function releaseOnAbort(signal, callbacks, abort) { + signal.addEventListener("abort", () => callbacks.deref()?.delete(abort), { once: true }); +} +/** Keep cancellation alive until abort or collection of the response body or bodyless custom response. */ +function retainRequestAbortCallback(owner, abort, requestSignal) { + if (typeof weakGlobals.WeakRef === "function" && finalizer && !requestSignal.aborted) { + let callbacks = callbackOwners.get(owner); + if (!callbacks) { + callbacks = /* @__PURE__ */ new Set(); + callbackOwners.set(owner, callbacks); + } + callbacks.add(abort); + releaseOnAbort(requestSignal, new weakGlobals.WeakRef(callbacks), abort); + } +} +/** +* Share one caller listener without it retaining completed requests. Collection removes +* weak subscriptions eventually; a live response body or custom response retains its callback. +* Runtimes without weak references keep the existing listener-based behavior. +*/ +function addRequestAbortListener(signal, abort, requestSignal) { + if (signal.aborted) { + abort(); + return () => {}; + } + if (typeof weakGlobals.WeakRef !== "function" || !finalizer) { + signal.addEventListener("abort", abort, { once: true }); + return () => signal.removeEventListener("abort", abort); + } + const reference = new weakGlobals.WeakRef(abort); + const cleanup = subscribeWeakly(signal, reference, finalizer); + finalizer.register(abort, cleanup, reference); + retainRequestAbortCallback(requestSignal, abort, requestSignal); + return cleanup; +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/shims.mjs +/** +* This module provides internal shims and utility functions for environments where certain Node.js or global types may not be available. +* +* These are used to ensure we can provide a consistent behaviour between different JavaScript environments and good error +* messages in cases where an environment isn't fully supported. +*/ +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?.(); + } + }); +} +/** +* Most browsers don't yet have async iterable support for ReadableStream, +* and Node has a very different way of reading bytes from its "ReadableStream". +* +* This polyfill was pulled from https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490 +*/ +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; + } + }; +} +/** +* Cancels a ReadableStream we don't need to consume. +* See https://undici.nodejs.org/#/?id=garbage-collection +*/ +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; +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/utils/bytes.mjs +let encodeUTF8_; +/** Encodes text as UTF-8 bytes, reusing the platform encoder after its first call. */ +function encodeUTF8(str) { + let encoder; + return (encodeUTF8_ ?? (encoder = new globalThis.TextEncoder(), encodeUTF8_ = encoder.encode.bind(encoder)))(str); +} +let decodeUTF8_; +/** Decodes UTF-8 bytes as text, reusing the platform decoder after its first call. */ +function decodeUTF8(bytes) { + let decoder; + return (decodeUTF8_ ?? (decoder = new globalThis.TextDecoder(), decodeUTF8_ = decoder.decode.bind(decoder)))(bytes); +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/decoders/line.mjs +var _LineDecoder_instances; +var _LineDecoder_buffer; +var _LineDecoder_start; +var _LineDecoder_end; +var _LineDecoder_searchIndex; +var _LineDecoder_skipLeadingLF; +var _LineDecoder_append; +/** Maximum backing-buffer capacity retained when completed lines leave little active data. */ +const MAX_RETAINED_BUFFER_BYTES = 65536; +/** +* Incrementally decodes UTF-8 text into lines without losing partial characters +* or newline sequences that span multiple chunks. +* +* Supports `\n`, `\r`, and `\r\n` line endings. Call {@link flush} after the +* final chunk to emit a trailing line that does not end with a newline. +* +* Based on the line decoder used by the Python `httpx` project: +* https://github.com/encode/httpx/blob/920333ea98118e9cf617f246905d7b202510941c/httpx/_decoders.py#L258 +*/ +var LineDecoder = class { + /** Creates a decoder with no buffered bytes or pending newline continuation. */ + constructor() { + _LineDecoder_instances.add(this); + _LineDecoder_buffer.set(this, void 0); + _LineDecoder_start.set(this, void 0); + _LineDecoder_end.set(this, void 0); + _LineDecoder_searchIndex.set(this, void 0); + _LineDecoder_skipLeadingLF.set(this, void 0); + __classPrivateFieldSet(this, _LineDecoder_buffer, /* @__PURE__ */ new Uint8Array(), "f"); + __classPrivateFieldSet(this, _LineDecoder_start, 0, "f"); + __classPrivateFieldSet(this, _LineDecoder_end, 0, "f"); + __classPrivateFieldSet(this, _LineDecoder_searchIndex, 0, "f"); + __classPrivateFieldSet(this, _LineDecoder_skipLeadingLF, false, "f"); + } + /** + * Appends a text or UTF-8 byte chunk and returns every newly completed line. + * + * Incomplete lines remain buffered for the next call. A trailing `\r` + * completes its line immediately, and a following `\n` is consumed as its + * continuation. `null` and `undefined` are ignored and do not flush buffered + * content. + */ + decode(chunk) { + if (chunk == null) return []; + let binaryChunk; + if (chunk instanceof ArrayBuffer) binaryChunk = new Uint8Array(chunk); + else if (typeof chunk === "string") binaryChunk = encodeUTF8(chunk); + else binaryChunk = chunk; + if (binaryChunk.length === 0) return []; + if (__classPrivateFieldGet(this, _LineDecoder_skipLeadingLF, "f")) { + __classPrivateFieldSet(this, _LineDecoder_skipLeadingLF, false, "f"); + if (binaryChunk[0] === 10) binaryChunk = binaryChunk.subarray(1); + if (binaryChunk.length === 0) return []; + } + __classPrivateFieldGet(this, _LineDecoder_instances, "m", _LineDecoder_append).call(this, binaryChunk); + const lines = []; + let patternIndex; + while ((patternIndex = findNewlineIndex(__classPrivateFieldGet(this, _LineDecoder_buffer, "f"), __classPrivateFieldGet(this, _LineDecoder_searchIndex, "f"), __classPrivateFieldGet(this, _LineDecoder_end, "f"))) != null) { + const line = decodeUTF8(__classPrivateFieldGet(this, _LineDecoder_buffer, "f").subarray(__classPrivateFieldGet(this, _LineDecoder_start, "f"), patternIndex.preceding)); + lines.push(line); + __classPrivateFieldSet(this, _LineDecoder_start, patternIndex.index, "f"); + if (patternIndex.carriage) { + if (__classPrivateFieldGet(this, _LineDecoder_start, "f") < __classPrivateFieldGet(this, _LineDecoder_end, "f") && __classPrivateFieldGet(this, _LineDecoder_buffer, "f")[__classPrivateFieldGet(this, _LineDecoder_start, "f")] === 10) __classPrivateFieldSet(this, _LineDecoder_start, __classPrivateFieldGet(this, _LineDecoder_start, "f") + 1, "f"); + else if (__classPrivateFieldGet(this, _LineDecoder_start, "f") === __classPrivateFieldGet(this, _LineDecoder_end, "f")) __classPrivateFieldSet(this, _LineDecoder_skipLeadingLF, true, "f"); + } + __classPrivateFieldSet(this, _LineDecoder_searchIndex, __classPrivateFieldGet(this, _LineDecoder_start, "f"), "f"); + } + __classPrivateFieldSet(this, _LineDecoder_searchIndex, __classPrivateFieldGet(this, _LineDecoder_end, "f"), "f"); + if (__classPrivateFieldGet(this, _LineDecoder_start, "f") === __classPrivateFieldGet(this, _LineDecoder_end, "f")) { + __classPrivateFieldSet(this, _LineDecoder_start, 0, "f"); + __classPrivateFieldSet(this, _LineDecoder_end, 0, "f"); + __classPrivateFieldSet(this, _LineDecoder_searchIndex, 0, "f"); + if (__classPrivateFieldGet(this, _LineDecoder_buffer, "f").length > MAX_RETAINED_BUFFER_BYTES) __classPrivateFieldSet(this, _LineDecoder_buffer, /* @__PURE__ */ new Uint8Array(), "f"); + } else if (lines.length > 0 && __classPrivateFieldGet(this, _LineDecoder_buffer, "f").length > MAX_RETAINED_BUFFER_BYTES) { + const length = __classPrivateFieldGet(this, _LineDecoder_end, "f") - __classPrivateFieldGet(this, _LineDecoder_start, "f"); + if (length <= MAX_RETAINED_BUFFER_BYTES || __classPrivateFieldGet(this, _LineDecoder_buffer, "f").length > length * 4) { + const capacity = length <= MAX_RETAINED_BUFFER_BYTES ? Math.min(Math.max(length * 2, 256), MAX_RETAINED_BUFFER_BYTES) : length * 2; + const buffer = new Uint8Array(capacity); + buffer.set(__classPrivateFieldGet(this, _LineDecoder_buffer, "f").subarray(__classPrivateFieldGet(this, _LineDecoder_start, "f"), __classPrivateFieldGet(this, _LineDecoder_end, "f"))); + __classPrivateFieldSet(this, _LineDecoder_buffer, buffer, "f"); + __classPrivateFieldSet(this, _LineDecoder_start, 0, "f"); + __classPrivateFieldSet(this, _LineDecoder_end, length, "f"); + __classPrivateFieldSet(this, _LineDecoder_searchIndex, length, "f"); + } + } + return lines; + } + /** Emits the remaining unterminated line, or returns an empty array when idle. */ + flush() { + __classPrivateFieldSet(this, _LineDecoder_skipLeadingLF, false, "f"); + if (__classPrivateFieldGet(this, _LineDecoder_start, "f") === __classPrivateFieldGet(this, _LineDecoder_end, "f")) return []; + return this.decode("\n"); + } +}; +_LineDecoder_buffer = /* @__PURE__ */ new WeakMap(), _LineDecoder_start = /* @__PURE__ */ new WeakMap(), _LineDecoder_end = /* @__PURE__ */ new WeakMap(), _LineDecoder_searchIndex = /* @__PURE__ */ new WeakMap(), _LineDecoder_skipLeadingLF = /* @__PURE__ */ new WeakMap(), _LineDecoder_instances = /* @__PURE__ */ new WeakSet(), _LineDecoder_append = function _LineDecoder_append(chunk) { + if (__classPrivateFieldGet(this, _LineDecoder_end, "f") + chunk.length > __classPrivateFieldGet(this, _LineDecoder_buffer, "f").length) { + const length = __classPrivateFieldGet(this, _LineDecoder_end, "f") - __classPrivateFieldGet(this, _LineDecoder_start, "f"); + if (__classPrivateFieldGet(this, _LineDecoder_start, "f") >= __classPrivateFieldGet(this, _LineDecoder_buffer, "f").length / 2 && length + chunk.length <= __classPrivateFieldGet(this, _LineDecoder_buffer, "f").length) __classPrivateFieldGet(this, _LineDecoder_buffer, "f").copyWithin(0, __classPrivateFieldGet(this, _LineDecoder_start, "f"), __classPrivateFieldGet(this, _LineDecoder_end, "f")); + else { + const capacity = Math.max(__classPrivateFieldGet(this, _LineDecoder_buffer, "f").length * 2, length + chunk.length, 256); + const buffer = new Uint8Array(capacity); + buffer.set(__classPrivateFieldGet(this, _LineDecoder_buffer, "f").subarray(__classPrivateFieldGet(this, _LineDecoder_start, "f"), __classPrivateFieldGet(this, _LineDecoder_end, "f"))); + __classPrivateFieldSet(this, _LineDecoder_buffer, buffer, "f"); + } + __classPrivateFieldSet(this, _LineDecoder_searchIndex, __classPrivateFieldGet(this, _LineDecoder_searchIndex, "f") - __classPrivateFieldGet(this, _LineDecoder_start, "f"), "f"); + __classPrivateFieldSet(this, _LineDecoder_end, length, "f"); + __classPrivateFieldSet(this, _LineDecoder_start, 0, "f"); + } + __classPrivateFieldGet(this, _LineDecoder_buffer, "f").set(chunk, __classPrivateFieldGet(this, _LineDecoder_end, "f")); + __classPrivateFieldSet(this, _LineDecoder_end, __classPrivateFieldGet(this, _LineDecoder_end, "f") + chunk.length, "f"); +}; +/** Individual characters recognized as possible line terminators. */ +LineDecoder.NEWLINE_CHARS = /* @__PURE__ */ new Set(["\n", "\r"]); +/** Matches complete CRLF terminators as well as standalone CR and LF characters. */ +LineDecoder.NEWLINE_REGEXP = /\r\n|[\n\r]/g; +/** +* Searches the active buffer range for the next CR or LF byte and returns its +* zero-based position, the position immediately after it, and whether the byte +* was a carriage return. Returns `null` when the range contains no newline byte. +* +* ```ts +* findNewlineIndex(new TextEncoder().encode('abc\ndef'), 0, 7) +* // => { preceding: 3, index: 4, carriage: false } +* ``` +*/ +function findNewlineIndex(buffer, start, end) { + const newline = 10; + const carriage = 13; + for (let i = start; i < end; i++) { + if (buffer[i] === newline) return { + preceding: i, + index: i + 1, + carriage: false + }; + if (buffer[i] === carriage) return { + preceding: i, + index: i + 1, + carriage: true + }; + } + return null; +} +/** +* Finds the first blank-line separator used to delimit streamed event records. +* +* @returns The byte offset immediately after the first pair of consecutive +* line endings, or `-1` when the buffer contains no complete separator. +*/ +function findDoubleNewlineIndex(buffer) { + for (let i = 0; i < buffer.length - 1; i++) { + const firstEndingLength = lineEndingLength(buffer, i); + if (firstEndingLength > 0) { + const secondEndingIndex = i + firstEndingLength; + const secondEndingLength = lineEndingLength(buffer, secondEndingIndex); + if (secondEndingLength > 0) return secondEndingIndex + secondEndingLength; + } + } + return -1; +} +function lineEndingLength(buffer, index) { + const newline = 10; + const carriage = 13; + if (buffer[index] === newline) return 1; + if (buffer[index] === carriage) return buffer[index + 1] === newline ? 2 : 1; + return 0; +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/utils/log.mjs +const levelNumbers = { + off: 0, + error: 200, + warn: 300, + info: 400, + debug: 500 +}; +const parseLogLevel = (maybeLevel, sourceName, client) => { + if (!maybeLevel) return; + if (hasOwn(levelNumbers, maybeLevel)) return maybeLevel; + loggerFor(client).warn(`${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(Object.keys(levelNumbers))}`); +}; +function noop() {} +function makeLogFn(fnLevel, logger, logLevel) { + if (!logger || levelNumbers[fnLevel] > levelNumbers[logLevel]) return noop; + else return logger[fnLevel].bind(logger); +} +const noopLogger = { + error: noop, + warn: noop, + info: noop, + debug: noop +}; +let cachedLoggers = /* @__PURE__ */ new WeakMap(); +function loggerFor(client) { + const logger = client.logger; + const logLevel = client.logLevel ?? "off"; + if (!logger) return noopLogger; + const cachedLogger = cachedLoggers.get(logger); + if (cachedLogger && cachedLogger[0] === logLevel) return cachedLogger[1]; + const levelLogger = { + error: makeLogFn("error", logger, logLevel), + warn: makeLogFn("warn", logger, logLevel), + info: makeLogFn("info", logger, logLevel), + debug: makeLogFn("debug", logger, logLevel) + }; + cachedLoggers.set(logger, [logLevel, levelLogger]); + return levelLogger; +} +const sensitiveQueryNames = /* @__PURE__ */ new Set([ + "apikey", + "accesstoken", + "refreshtoken", + "sessiontoken", + "sessionid", + "idtoken", + "authtoken", + "authorization", + "token", + "password", + "clientsecret", + "signingsecret", + "sig", + "signature", + "xgoogsignature", + "xgoogcredential", + "xamzsecuritytoken", + "xamzsignature", + "xamzcredential" +]); +/** Recognizes credential-bearing query names across ordinary and provider authentication. */ +function isSensitiveQueryParameter(name) { + const normalized = name.toLowerCase().replace(/[-_]/gu, ""); + return sensitiveQueryNames.has(normalized) || sensitiveQueryNames.has(normalized.replace(/^x/u, "")); +} +const sensitiveHeaderNames = /* @__PURE__ */ new Set([ + "authorization", + "proxy-authorization", + "api-key", + "x-api-key", + "x-amz-security-token", + "cookie", + "set-cookie", + "x-session-token", + "x-session-id", + "x-auth-token", + "x-id-token" +]); +/** Recognizes credential-bearing request headers across provider and workload authentication. */ +function isSensitiveHeader(name) { + return sensitiveHeaderNames.has(name.toLowerCase().replace(/_/gu, "-")) || isSensitiveQueryParameter(name); +} +/** Removes credential-valued query parameters before a request URL reaches any logger. */ +function redactURL(value) { + const url = new URL(value); + url.username = ""; + url.password = ""; + url.hash = ""; + for (const name of url.searchParams.keys()) if (isSensitiveQueryParameter(name)) url.searchParams.set(name, "***"); + return url.href; +} +const formatRequestDetails = (details) => { + if (details.options) { + details.options = { ...details.options }; + delete details.options["headers"]; + if (details.options.path) { + const path = details.options.path; + const redacted = new URL(redactURL(new URL(path, "https://redacted.invalid").href)); + details.options.path = redacted.origin === "https://redacted.invalid" ? `${path.startsWith("/") ? "/" : ""}${redacted.pathname.slice(1)}${redacted.search}` : redacted.href; + } + if (details.options.query) details.options.query = Object.fromEntries(Object.entries(details.options.query).map(([name, value]) => [name, isSensitiveQueryParameter(name) ? "***" : value])); + } + if (details.url) details.url = redactURL(details.url); + if (details.headers) details.headers = Object.fromEntries((details.headers instanceof Headers ? [...details.headers] : Object.entries(details.headers)).map(([name, value]) => [name, isSensitiveHeader(name) ? "***" : value])); + if ("retryOfRequestLogID" in details) { + if (details.retryOfRequestLogID) details.retryOf = details.retryOfRequestLogID; + delete details.retryOfRequestLogID; + } + return details; +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/core/streaming.mjs +var _Stream_instances; +var _Stream_client; +var _Stream_isTeeBranch; +var _Stream_cancelIterator; +function isTransportAbortError(error) { + return !(error instanceof APIError) && isAbortError(error); +} +function createStreamTeeQueue() { + let entries = []; + let head = 0; + let canceled = false; + return { + get length() { + return entries.length - head; + }, + get canceled() { + return canceled; + }, + enqueue(value) { + if (!canceled) entries.push(value); + }, + dequeue() { + if (head === entries.length) return; + const value = entries[head]; + entries[head] = void 0; + head += 1; + if (head === entries.length) { + entries = []; + head = 0; + } else if (head >= 1024 && head * 2 >= entries.length) { + entries = entries.slice(head); + head = 0; + } + return value; + }, + cancel() { + canceled = true; + entries.length = 0; + head = 0; + } + }; +} +/** +* A single-consumption asynchronous API response stream. +* +* Use {@link Stream.tee} when two consumers need the same events. Breaking out of +* a response-backed stream early aborts its request; branches created by `tee()` +* instead share {@link Stream.controller} for explicit cancellation. +*/ +var Stream = class Stream { + /** Wraps an asynchronous event iterator and the controller that owns its request. */ + constructor(iterator, controller, client) { + _Stream_instances.add(this); + _Stream_client.set(this, void 0); + _Stream_isTeeBranch.set(this, false); + this.iterator = iterator; + this.controller = controller; + __classPrivateFieldSet(this, _Stream_client, client, "f"); + } + /** + * Decodes an SSE response into parsed JSON events. + * + * The resulting stream can be consumed only once, ignores events after `[DONE]`, and + * surfaces API error payloads as `APIError` instances. When + * `synthesizeEventData` is enabled, each item also includes its SSE event name. + */ + static fromSSEResponse(response, controller, client, synthesizeEventData) { + let consumed = false; + const logger = client ? loggerFor(client) : console; + async function* iterator() { + if (consumed) throw new OpenAIError("Cannot iterate over a consumed stream, use `.tee()` to split the stream."); + consumed = true; + let done = false; + let receivedCompletionSentinel = false; + const messages = _iterSSEMessages(response, controller); + const closeMessages = messages.return.bind(messages); + messages.return = (value) => { + if (!receivedCompletionSentinel) controller.abort(); + return closeMessages(value); + }; + try { + for await (const sse of messages) { + if (sse.data === "[DONE]") { + receivedCompletionSentinel = true; + break; + } + if (sse.event === null || !sse.event.startsWith("thread.")) { + let data; + try { + data = JSON.parse(sse.data); + } catch { + logger.error(`Could not parse message into JSON:`); + logger.error(`From chunk:`); + throw new SyntaxError("Error reading response: malformed server-sent event JSON."); + } + if (sse.event === "error") throw new APIError(void 0, data?.error ?? data, void 0, response.headers); + if (data && data.error) throw new APIError(void 0, data.error, void 0, response.headers); + yield synthesizeEventData ? { + event: sse.event, + data + } : data; + } else { + let data; + try { + data = JSON.parse(sse.data); + } catch { + logger.error(`Could not parse message into JSON:`); + logger.error(`From chunk:`); + throw new SyntaxError("Error reading response: malformed server-sent event JSON."); + } + yield { + event: sse.event, + data + }; + } + } + done = true; + } catch (e) { + if (receivedCompletionSentinel || isTransportAbortError(e) || controller.signal.aborted && e === controller.signal.reason) return; + throw e; + } finally { + if (!done) controller.abort(); + } + } + return new Stream(iterator, controller, client); + } + /** + * Generates a Stream from a newline-separated ReadableStream + * where each item is a JSON value. + */ + static fromReadableStream(readableStream, controller, client) { + let consumed = false; + async function* iterLines() { + const lineDecoder = new LineDecoder(); + const reader = readableStream.getReader(); + let closed = false; + let cancelPromise; + const cancel = () => { + cancelPromise ?? (cancelPromise = reader.cancel()); + cancelPromise.catch(() => void 0); + }; + controller.signal.addEventListener("abort", cancel, { once: true }); + try { + if (controller.signal.aborted) { + cancel(); + return; + } + while (true) { + const { value: chunk, done } = await reader.read(); + if (done) { + closed = true; + break; + } + if (controller.signal.aborted) return; + for (const line of lineDecoder.decode(chunk)) { + if (controller.signal.aborted) return; + yield line; + } + } + if (controller.signal.aborted) return; + for (const line of lineDecoder.flush()) { + if (controller.signal.aborted) return; + yield line; + } + } finally { + controller.signal.removeEventListener("abort", cancel); + if (!closed) cancel(); + reader.releaseLock(); + } + } + async function* iterator() { + if (consumed) throw new OpenAIError("Cannot iterate over a consumed stream, use `.tee()` to split the stream."); + consumed = true; + let done = false; + try { + for await (const line of iterLines()) if (line) { + let data; + try { + data = JSON.parse(line); + } catch (error) { + if (error instanceof SyntaxError) throw new SyntaxError("Error reading response: malformed newline-delimited JSON."); + throw error; + } + yield data; + } + done = true; + } catch (e) { + if (controller.signal.aborted || isAbortError(e)) return; + throw e; + } finally { + if (!done) controller.abort(); + } + } + return new Stream(iterator, controller, client); + } + /** Starts consuming this stream; attempting to consume it again throws. */ + [(_Stream_client = /* @__PURE__ */ new WeakMap(), _Stream_isTeeBranch = /* @__PURE__ */ new WeakMap(), _Stream_instances = /* @__PURE__ */ new WeakSet(), Symbol.asyncIterator)]() { + return this.iterator(); + } + /** Beta-only iterator decoration for Agents helpers, preserving custom stream identity. + * @internal + */ + __betaTransformIterator(transform) { + this.iterator = transform(this.iterator.bind(this)); + } + /** + * Splits the stream into two streams which can be + * independently read from at different speeds. + * Closing a branch discards its buffered events without stopping its sibling. + * Future reads on that branch finish immediately; previously issued `next()` + * promises remain shared with its sibling and may still resolve with events. + * Closing both branches invokes the source iterator's `return()` when available. + * For {@link Stream.fromReadableStream}, closing both branches before iteration + * starts does not cancel the supplied readable; cancel that readable directly. + */ + tee() { + const { controller } = this; + const left = createStreamTeeQueue(); + const right = createStreamTeeQueue(); + const iterator = this.iterator(); + const teeIterator = (queue) => ({ + next: () => { + if (queue.canceled) return Promise.resolve({ + value: void 0, + done: true + }); + if (queue.length === 0) { + const result = iterator.next(); + left.enqueue(result); + right.enqueue(result); + } + return queue.dequeue(); + }, + return: async () => { + if (!queue.canceled) { + queue.cancel(); + if (left.canceled && right.canceled) await __classPrivateFieldGet(this, _Stream_instances, "m", _Stream_cancelIterator).call(this, iterator, controller); + } + return { + value: void 0, + done: true + }; + } + }); + const branch = (queue) => { + const stream = new Stream(() => teeIterator(queue), controller, __classPrivateFieldGet(this, _Stream_client, "f")); + __classPrivateFieldSet(stream, _Stream_isTeeBranch, true, "f"); + return stream; + }; + return [branch(left), branch(right)]; + } + /** + * Converts this stream to a newline-separated ReadableStream of + * JSON stringified values in the stream + * which can be turned back into a Stream with `Stream.fromReadableStream()`. + * Canceling a response-backed readable aborts its request. Canceling a tee + * branch discards its buffered events and leaves sibling consumers running. + * Read or serialization failures also release the iterator without replacing the original error. + */ + toReadableStream() { + const { controller } = this; + let iter; + let cancellation; + const cancel = () => cancellation ?? (cancellation = __classPrivateFieldGet(this, _Stream_instances, "m", _Stream_cancelIterator).call(this, iter, controller)); + return makeReadableStream({ + start: async () => { + iter = this[Symbol.asyncIterator](); + }, + async pull(ctrl) { + try { + const { value, done } = await iter.next(); + if (done) return ctrl.close(); + const bytes = encodeUTF8(JSON.stringify(value) + "\n"); + ctrl.enqueue(bytes); + } catch (err) { + ctrl.error(err); + cancel().catch(() => void 0); + } + }, + cancel + }); + } +}; +_Stream_cancelIterator = async function _Stream_cancelIterator(iterator, controller) { + const returnMethod = iterator.return; + if (returnMethod) { + if (!__classPrivateFieldGet(this, _Stream_isTeeBranch, "f")) controller.abort(); + await Reflect.apply(returnMethod, iterator, []); + } +}; +function createAbortableSSESource(body, signal) { + const reader = typeof body.getReader === "function" ? body.getReader() : void 0; + const source = reader ? { + next: () => reader.read(), + return: () => reader.cancel() + } : ReadableStreamToAsyncIterable(body)[Symbol.asyncIterator](); + const ended = { + value: void 0, + done: true + }; + let closed = false; + let canceled = false; + let cancellation; + let interrupt; + const waitForAbort = () => new Promise((resolve) => { + interrupt = resolve; + }); + const cancel = () => { + if (canceled || closed) return cancellation; + canceled = true; + try { + cancellation = Promise.resolve(source.return?.()); + } catch (error) { + cancellation = Promise.reject(error); + } + cancellation.catch(() => void 0); + return cancellation; + }; + const abort = () => { + queueMicrotask(() => { + interrupt?.(); + cancel(); + }); + }; + return { + iterator: { + async next() { + if (signal.aborted) return ended; + const aborted = waitForAbort().then(() => ended); + try { + const result = await Promise.race([source.next(), aborted]); + if (signal.aborted) return ended; + if (result.done) { + closed = true; + return ended; + } + return { + value: result.value, + done: false + }; + } catch (error) { + if (signal.aborted && (isAbortError(error) || error === signal.reason)) return ended; + throw error; + } finally { + interrupt = void 0; + } + }, + async return() { + const pending = cancel(); + if (pending && !signal.aborted) { + const aborted = waitForAbort(); + try { + if (!signal.aborted) await Promise.race([pending, aborted]); + } finally { + interrupt = void 0; + } + } + return ended; + }, + [Symbol.asyncIterator]() { + return this; + } + }, + start() { + signal.addEventListener("abort", abort, { once: true }); + if (signal.aborted) abort(); + }, + async cleanup(failed) { + let cleanupError; + try { + signal.removeEventListener("abort", abort); + } catch (error) { + cleanupError = error; + } + if (!closed) { + const pending = cancel(); + if (pending && !failed && !signal.aborted) try { + await pending; + } catch (error) { + cleanupError ?? (cleanupError = error); + } + } + if (reader) try { + reader.releaseLock(); + } catch (error) { + cleanupError ?? (cleanupError = error); + } + if (cleanupError !== void 0 && !failed && !signal.aborted) throw cleanupError; + } + }; +} +/** +* Decodes complete SSE records from a response and aborts when its body is absent. +* Complete events are decoded on demand without imposing a line or event size limit. +* +* @yields {ServerSentEvent} Each decoded server-sent event in wire order. +*/ +async function* _iterSSEMessages(response, controller) { + if (!response.body) { + controller.abort(); + if (globalThis.navigator !== void 0 && globalThis.navigator.product === "ReactNative") throw new OpenAIError(`The default react-native fetch implementation does not support streaming. Please use expo/fetch: https://docs.expo.dev/versions/latest/sdk/expo/#expofetch-api`); + throw new OpenAIError(`Attempted to iterate over a response with no body`); + } + const sseDecoder = new SSEDecoder(); + const lineDecoder = new LineDecoder(); + const { signal } = controller; + const source = createAbortableSSESource(response.body, signal); + let failed = false; + try { + source.start(); + for await (const sseChunk of iterSSEChunks(source.iterator)) { + if (signal.aborted) return; + for (const line of lineDecoder.decode(sseChunk)) { + if (signal.aborted) return; + const sse = sseDecoder.decode(line); + if (sse) yield sse; + } + } + if (signal.aborted) return; + for (const line of lineDecoder.flush()) { + if (signal.aborted) return; + const sse = sseDecoder.decode(line); + if (sse) yield sse; + } + if (signal.aborted) return; + const pending = sseDecoder.flush(); + if (pending) yield pending; + } catch (error) { + failed = true; + if (!signal.aborted || !isAbortError(error) && error !== signal.reason) throw error; + } finally { + await source.cleanup(failed); + } +} +const DOUBLE_NEWLINE_DELIMITER_MAX_OVERLAP_BYTES = 3; +/** +* Given an async iterable iterator, iterates over it and yields full +* SSE chunks, i.e. yields when a double new-line is encountered. +* +* @yields {Uint8Array} A complete SSE chunk. +*/ +async function* iterSSEChunks(iterator) { + let data = /* @__PURE__ */ new Uint8Array(); + let dataStart = 0; + let dataEnd = 0; + let searchStartIndex = 0; + for await (const chunk of iterator) { + if (chunk == null) continue; + let binaryChunk; + if (chunk instanceof ArrayBuffer) binaryChunk = new Uint8Array(chunk); + else if (typeof chunk === "string") binaryChunk = encodeUTF8(chunk); + else binaryChunk = chunk; + if (dataEnd + binaryChunk.length > data.length) { + const bufferedLength = dataEnd - dataStart; + if (dataStart >= data.length / 2 && bufferedLength + binaryChunk.length <= data.length) data.copyWithin(0, dataStart, dataEnd); + else { + const newData = new Uint8Array(Math.max(data.length * 2, bufferedLength + binaryChunk.length)); + newData.set(data.subarray(dataStart, dataEnd)); + data = newData; + } + searchStartIndex -= dataStart; + dataStart = 0; + dataEnd = bufferedLength; + } + data.set(binaryChunk, dataEnd); + dataEnd += binaryChunk.length; + let patternIndex; + while ((patternIndex = findDoubleNewlineIndex(data.subarray(searchStartIndex, dataEnd))) !== -1) { + patternIndex += searchStartIndex; + yield data.slice(dataStart, patternIndex); + dataStart = patternIndex; + searchStartIndex = dataStart; + } + searchStartIndex = Math.max(dataStart, dataEnd - DOUBLE_NEWLINE_DELIMITER_MAX_OVERLAP_BYTES); + } + if (dataEnd > dataStart) yield data.slice(dataStart, dataEnd); +} +var SSEDecoder = class { + constructor() { + this.event = null; + this.data = []; + this.chunks = []; + } + decode(line) { + if (line.endsWith("\r")) line = line.slice(0, -1); + if (!line) { + if (!this.event && !this.data.length) return null; + const sse = { + event: this.event, + data: this.data.join("\n"), + raw: this.chunks + }; + this.event = null; + this.data = []; + this.chunks = []; + return sse; + } + this.chunks.push(line); + if (line.startsWith(":")) return null; + const [fieldname, , initialValue] = partition(line, ":"); + let value = initialValue; + if (value.startsWith(" ")) value = value.slice(1); + if (fieldname === "event") this.event = value; + else if (fieldname === "data") this.data.push(value); + return null; + } + /** + * Emits a pending event at EOF when the stream omitted the trailing blank + * line. Returns `null` when no event is in progress so a record that already + * ended with a blank line is not delivered twice. + */ + flush() { + return this.decode(""); + } +}; +function partition(str, delimiter) { + const index = str.indexOf(delimiter); + if (index !== -1) return [ + str.slice(0, index), + delimiter, + str.slice(index + delimiter.length) + ]; + return [ + str, + "", + "" + ]; +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/parse.mjs +async function defaultParseResponse(client, props) { + const { response, requestLogID, retryOfRequestLogID, startTime } = props; + let jsonBodyLength; + const body = await (async () => { + if (props.options.stream) { + loggerFor(client).debug("response", response.status, response.url, response.headers, response.body); + if (props.options.__streamClass) return props.options.__streamClass.fromSSEResponse(response, props.controller, client, props.options.__synthesizeEventData); + return Stream.fromSSEResponse(response, props.controller, client, props.options.__synthesizeEventData); + } + if (response.status === 204) return null; + if (props.options.__binaryResponse) return response; + const mediaType = response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase(); + if (mediaType?.includes("application/json") || mediaType?.endsWith("+json")) { + if (response.headers.get("content-length") === "0") return; + const bodyText = await response.text(); + if (!bodyText) return; + const json = JSON.parse(bodyText); + jsonBodyLength = bodyText.length; + return addRequestID(json, response); + } + return await response.text(); + })().catch((error) => { + throw asAbortError(error, props.controller.signal); + }); + if (client.logLevel === "debug") loggerFor(client).debug(`[${requestLogID}] response parsed`, formatRequestDetails({ + retryOfRequestLogID, + url: response.url, + status: response.status, + body: jsonBodyLength === void 0 ? body : { + type: "json", + length: jsonBodyLength + }, + durationMs: Date.now() - startTime + })); + return body; +} +function asAbortError(error, signal) { + if (!signal.aborted || error !== signal.reason || isAbortError(error)) return error; + const message = "This operation was aborted"; + const DOMExceptionConstructor = globalThis.DOMException; + return typeof DOMExceptionConstructor === "function" ? new DOMExceptionConstructor(message, "AbortError") : Object.assign(/* @__PURE__ */ new Error(message), { name: "AbortError" }); +} +function addRequestID(value, response) { + if (!value || typeof value !== "object" || Array.isArray(value)) return value; + return Object.defineProperty(value, "_request_id", { + value: response.headers.get("x-request-id"), + enumerable: false + }); +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/version.mjs +/** Version of the installed OpenAI SDK package. */ +const VERSION = "7.34.0"; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/detect-platform.mjs +const isRunningInBrowser = () => { + return typeof window !== "undefined" && typeof window.document !== "undefined" && typeof navigator !== "undefined"; +}; +/** +* Note this does not detect 'browser'; for that, use getBrowserInfo(). +*/ +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"; +} +const getPlatformProperties = () => { + const detectedPlatform = getDetectedPlatform(); + if (detectedPlatform === "deno") return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": 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, + "X-Stainless-OS": "Unknown", + "X-Stainless-Arch": `other:${EdgeRuntime}`, + "X-Stainless-Runtime": "edge", + "X-Stainless-Runtime-Version": globalThis.process?.version ?? "unknown" + }; + if (detectedPlatform === "node") return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": 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, + "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, + "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; + for (const { key, pattern } of [ + { + key: "edge", + pattern: /\bEdg(?:e|A|iOS)?\b(?:\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/ + } + ]) { + const match = pattern.exec(navigator.userAgent); + if (match) return { + browser: key, + version: `${match[1] || 0}.${match[2] || 0}.${match[3] || 0}` + }; + } + return null; +} +const 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"; +}; +const 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"; +}; +let _platformHeaders; +const getPlatformHeaders = () => { + return _platformHeaders ?? (_platformHeaders = getPlatformProperties()); +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/request-options.mjs +const jsonRequestBodyObservers = /* @__PURE__ */ new WeakMap(); +/** Observes values produced by the actual JSON request serializer without changing them. */ +function observeJSONRequestBody(body, observer) { + let observers = jsonRequestBodyObservers.get(body); + if (!observers) { + observers = /* @__PURE__ */ new Set(); + jsonRequestBodyObservers.set(body, observers); + } + observers.add(observer); + return () => { + const active = jsonRequestBodyObservers.get(body); + if (!active) return; + active.delete(observer); + if (active.size === 0) jsonRequestBodyObservers.delete(body); + }; +} +const FallbackEncoder = ({ headers, body }) => { + const observers = typeof body === "object" && body !== null ? jsonRequestBodyObservers.get(body) : void 0; + let encoded; + if (!observers || observers.size === 0) encoded = JSON.stringify(body); + else { + const active = [...observers]; + encoded = JSON.stringify(body, function(key, value) { + let observed = value; + for (const observer of active) { + const replacement = observer.value(this, key, observed); + if (replacement !== void 0) observed = replacement; + } + return observed; + }); + for (const observer of active) observer.complete(); + } + return { + bodyHeaders: { "content-type": "application/json" }, + body: encoded + }; +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/qs/formats.mjs +const default_format = "RFC3986"; +const default_formatter = String; +const formatters = { + RFC1738: (v) => String(v).replace(/%20/g, "+"), + RFC3986: default_formatter +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/qs/utils.mjs +let cachedHas; +const has = (obj, key) => { + const resolvedHas = cachedHas ?? Object.hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty); + cachedHas = resolvedHas; + return resolvedHas(obj, key); +}; +const hex_table = /* @__PURE__ */ (() => { + const array = []; + for (let i = 0; i < 256; ++i) array.push("%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase()); + return array; +})(); +const limit = 1024; +const 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, ($0) => "%26%23" + Number.parseInt($0.slice(2), 16) + "%3B"); + let out = ""; + for (let j = 0; j < string.length;) { + let segmentEnd = Math.min((Math.floor(j / limit) + 1) * limit, string.length); + if (segmentEnd < string.length && string.codePointAt(segmentEnd - 1) > 65535) segmentEnd += 1; + const segment = string.length >= limit ? string.slice(j, segmentEnd) : 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 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || format === "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(""); + j = segmentEnd; + } + return out; +}; +function is_buffer(obj) { + if (!obj || typeof obj !== "object") return false; + return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj)); +} +function maybe_map(val, fn) { + if (isArray(val)) { + const mapped = []; + for (const item of val) mapped.push(fn(item)); + return mapped; + } + return fn(val); +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/qs/stringify.mjs +const array_prefix_generators = { + brackets(prefix) { + return String(prefix) + "[]"; + }, + comma: "comma", + indices(prefix, key) { + return String(prefix) + "[" + key + "]"; + }, + repeat(prefix) { + return String(prefix); + } +}; +const push_to_array = function push_to_array(arr, value_or_array) { + Array.prototype.push.apply(arr, isArray(value_or_array) ? value_or_array : [value_or_array]); +}; +let toISOString; +const defaults = { + addQueryPrefix: false, + allowDots: false, + allowEmptyArrays: false, + arrayFormat: "indices", + charset: "utf-8", + charsetSentinel: false, + delimiter: "&", + encode: true, + encodeDotInKeys: false, + encoder: encode, + encodeValuesOnly: false, + format: default_format, + formatter: 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"; +} +const 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 (pos !== void 0) { + if (pos === step) throw new RangeError("Cyclic object value"); + else find_flag = true; + } + if (tmp_sc.get(sentinel) === void 0) step = 0; + } + if (typeof filter === "function") obj = filter(prefix, obj); + else if (obj instanceof Date) obj = serializeDate?.(obj); + else if (generateArrayPrefix === "comma" && isArray(obj)) obj = maybe_map(obj, (value) => { + if (value instanceof Date) return serializeDate?.(value); + return value; + }); + if (obj === null) { + if (strictNullHandling) return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, "key", format) : prefix; + obj = ""; + } + if (is_non_nullish_primitive(obj) || is_buffer(obj)) { + if (encoder) { + const key_value = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, "key", format); + return [formatter?.(key_value) + "=" + formatter?.(encoder(obj, defaults.encoder, charset, "value", format))]; + } + return [formatter?.(prefix) + "=" + formatter?.(String(obj))]; + } + const values = []; + if (obj === void 0) return values; + let obj_keys; + if (generateArrayPrefix === "comma" && isArray(obj)) { + if (encodeValuesOnly && encoder) obj = maybe_map(obj, encoder); + obj_keys = [{ value: obj.length > 0 ? obj.join(",") || null : void 0 }]; + } else if (isArray(filter)) obj_keys = filter; + else { + const keys = Object.keys(obj); + if (sort) keys.sort(sort); + obj_keys = keys; + } + const encoded_prefix = encodeDotInKeys ? String(prefix).replace(/\./g, "%2E") : String(prefix); + const adjusted_prefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encoded_prefix + "[]" : encoded_prefix; + if (allowEmptyArrays && isArray(obj) && obj.length === 0) return adjusted_prefix + "[]"; + for (const key of obj_keys) { + const value = typeof key === "object" && key.value !== void 0 ? key.value : obj[key]; + if (skipNulls && value === null) continue; + const encoded_key = allowDots && encodeDotInKeys ? key.replace(/\./g, "%2E") : key; + let key_prefix; + if (isArray(obj)) key_prefix = typeof generateArrayPrefix === "function" ? generateArrayPrefix(adjusted_prefix, encoded_key) : adjusted_prefix; + else key_prefix = adjusted_prefix + (allowDots ? "." + encoded_key : "[" + encoded_key + "]"); + sideChannel.set(object, step); + const valueSideChannel = new WeakMap([[sentinel, sideChannel]]); + push_to_array(values, inner_stringify(value, key_prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, generateArrayPrefix === "comma" && encodeValuesOnly && isArray(obj) ? null : encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, valueSideChannel)); + } + return values; +} +function normalize_stringify_options(opts = defaults) { + if (opts.allowEmptyArrays !== void 0 && typeof opts.allowEmptyArrays !== "boolean") throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided"); + if (opts.encodeDotInKeys !== void 0 && typeof opts.encodeDotInKeys !== "boolean") throw new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided"); + if (opts.encoder !== null && opts.encoder !== void 0 && typeof opts.encoder !== "function") throw new TypeError("Encoder has to be a function."); + const charset = opts.charset || defaults.charset; + if (opts.charset !== void 0 && 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 = default_format; + if (opts.format !== void 0) { + if (!has(formatters, opts.format)) throw new TypeError("Unknown format option provided."); + format = opts.format; + } + const formatter = formatters[format]; + let filter = defaults.filter; + if (typeof opts.filter === "function" || 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"); + let allowDots; + if (opts.allowDots === void 0) allowDots = !!opts.encodeDotInKeys === true ? true : defaults.allowDots; + else allowDots = !!opts.allowDots; + return { + addQueryPrefix: typeof opts.addQueryPrefix === "boolean" ? opts.addQueryPrefix : defaults.addQueryPrefix, + 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: opts.delimiter === void 0 ? 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, + 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 (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 (const key of obj_keys) { + if (options.skipNulls && obj[key] === null) continue; + push_to_array(keys, inner_stringify(obj[key], key, 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) prefix += options.charset === "iso-8859-1" ? "utf8=%26%2310003%3B&" : "utf8=%E2%9C%93&"; + return joined.length > 0 ? prefix + joined : ""; +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/utils/query.mjs +function stringifyQuery(query) { + return stringify(query, { arrayFormat: "brackets" }); +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/data-residency.mjs +const endpoints = /* @__PURE__ */ new Map([ + ["global", "https://api.openai.com/v1"], + ["us", "https://us.api.openai.com/v1"], + ["eu", "https://eu.api.openai.com/v1"], + ["ae", "https://ae.api.openai.com/v1"] +]); +/** Resolves an explicit residency selection before client options are inherited. */ +function resolveDataResidency(options) { + if (options.dataResidency === null || options.dataResidency === void 0) return; + if (hasOwn(options, "baseURL")) throw new OpenAIError("The `dataResidency` and `baseURL` options are mutually exclusive."); + const endpoint = endpoints.get(options.dataResidency); + if (endpoint === void 0) throw new OpenAIError("Invalid `dataResidency`; expected one of: global, us, eu, ae."); + return endpoint; +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/core/api-promise.mjs +var _APIPromise_client; +/** +* A subclass of `Promise` providing additional helper methods +* for interacting with the SDK. +*/ +var APIPromise = class APIPromise extends Promise { + constructor(client, responsePromise, parseResponse = defaultParseResponse) { + super((resolve) => { + resolve(null); + }); + this.responsePromise = responsePromise; + this.parseResponse = parseResponse; + _APIPromise_client.set(this, void 0); + __classPrivateFieldSet(this, _APIPromise_client, client, "f"); + } + _thenUnwrap(transform) { + return new APIPromise(__classPrivateFieldGet(this, _APIPromise_client, "f"), this.responsePromise, async (client, props) => addRequestID(transform(await this.parseResponse(client, props), props), props.response)); + } + /** + * Gets the raw `Response` instance instead of parsing the response + * data. + * + * If you want to parse the response body but still get the `Response` + * instance, you can use {@link withResponse()}. + * + * 👋 Getting the wrong TypeScript type for `Response`? + * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]` + * to your `tsconfig.json`. + */ + asResponse() { + return this.responsePromise.then((p) => p.response); + } + /** + * Gets the parsed response data, the raw `Response` instance and the ID of the request, + * returned via the X-Request-ID header which is useful for debugging requests and reporting + * issues to OpenAI. + * + * If you just want to get the raw `Response` instance without parsing it, + * you can use {@link asResponse()}. + * + * 👋 Getting the wrong TypeScript type for `Response`? + * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]` + * to your `tsconfig.json`. + */ + async withResponse() { + const [data, response] = await Promise.all([this.parse(), this.asResponse()]); + return { + data, + response, + request_id: response.headers.get("x-request-id") + }; + } + parse() { + if (!this.parsedPromise) this.parsedPromise = this.responsePromise.then((data) => this.parseResponse(__classPrivateFieldGet(this, _APIPromise_client, "f"), data)); + return this.parsedPromise; + } + then(onfulfilled, onrejected) { + return this.parse().then(onfulfilled, onrejected); + } + catch(onrejected) { + return this.parse().catch(onrejected); + } + finally(onfinally) { + return this.parse().finally(onfinally); + } +}; +_APIPromise_client = /* @__PURE__ */ new WeakMap(); +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/core/pagination.mjs +var _AbstractPage_client; +var AbstractPage = class { + constructor(client, response, body, options) { + _AbstractPage_client.set(this, void 0); + __classPrivateFieldSet(this, _AbstractPage_client, client, "f"); + this.options = options; + this.response = response; + this.body = body; + } + hasNextPage() { + if (!this.getPaginatedItems().length) return false; + return this.nextPageRequestOptions() != null; + } + async getNextPage() { + const nextOptions = this.nextPageRequestOptions(); + if (!nextOptions) throw new OpenAIError("No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`."); + return await __classPrivateFieldGet(this, _AbstractPage_client, "f").requestAPIList(this.constructor, nextOptions); + } + async *iterPages() { + let page = this; + yield page; + while (page.hasNextPage()) { + page = await page.getNextPage(); + yield page; + } + } + async *[(_AbstractPage_client = /* @__PURE__ */ new WeakMap(), Symbol.asyncIterator)]() { + for await (const page of this.iterPages()) for (const item of page.getPaginatedItems()) yield item; + } +}; +/** +* This subclass of Promise will resolve to an instantiated Page once the request completes. +* +* It also implements AsyncIterable to allow auto-paginating iteration on an unawaited list call, eg: +* +* for await (const item of client.items.list()) { +* console.log(item) +* } +*/ +var PagePromise = class extends APIPromise { + constructor(client, request, Page) { + super(client, request, async (client, props) => new Page(client, props.response, await defaultParseResponse(client, props), props.options)); + } + /** + * Allow auto-paginating iteration on an unawaited list call, eg: + * + * for await (const item of client.items.list()) { + * console.log(item) + * } + */ + async *[Symbol.asyncIterator]() { + const page = await this; + for await (const item of page) yield item; + } +}; +/** +* Note: no pagination actually occurs yet, this is for forwards-compatibility. +*/ +var Page = class extends AbstractPage { + constructor(client, response, body, options) { + super(client, response, body, options); + this.data = body.data || []; + this.object = body.object; + } + getPaginatedItems() { + return this.data ?? []; + } + nextPageRequestOptions() { + return null; + } +}; +var CursorPage = class extends AbstractPage { + constructor(client, response, body, options) { + super(client, response, body, options); + this.data = body.data || []; + this.has_more = body.has_more || false; + } + getPaginatedItems() { + return this.data ?? []; + } + hasNextPage() { + if (this.has_more === false) return false; + return super.hasNextPage(); + } + nextPageRequestOptions() { + const data = this.getPaginatedItems(); + const id = data[data.length - 1]?.id; + if (!id) return null; + return { + ...this.options, + query: { + ...maybeObj(this.options.query), + after: id + } + }; + } +}; +var ConversationCursorPage = class extends AbstractPage { + constructor(client, response, body, options) { + super(client, response, body, options); + this.data = body.data || []; + this.has_more = body.has_more || false; + this.last_id = body.last_id || ""; + } + getPaginatedItems() { + return this.data ?? []; + } + hasNextPage() { + if (this.has_more === false) return false; + return super.hasNextPage(); + } + nextPageRequestOptions() { + const cursor = this.last_id; + if (!cursor) return null; + return { + ...this.options, + query: { + ...maybeObj(this.options.query), + after: cursor + } + }; + } +}; +var NextCursorPage = class extends AbstractPage { + constructor(client, response, body, options) { + super(client, response, body, options); + this.data = body.data || []; + this.has_more = body.has_more || false; + this.next = body.next || null; + } + getPaginatedItems() { + return this.data ?? []; + } + hasNextPage() { + if (this.has_more === false) return false; + return this.nextPageRequestOptions() != null; + } + nextPageRequestOptions() { + const cursor = this.next; + if (!cursor) return null; + return { + ...this.options, + query: { + ...maybeObj(this.options.query), + after: cursor + } + }; + } +}; +var TokenPage = class extends AbstractPage { + constructor(client, response, body, options) { + super(client, response, body, options); + this.data = body.data || []; + this.has_more = body.has_more || false; + this.next = body.next || null; + } + getPaginatedItems() { + return this.data ?? []; + } + hasNextPage() { + if (this.has_more === false) return false; + return this.nextPageRequestOptions() != null; + } + nextPageRequestOptions() { + const cursor = this.next; + if (!cursor) return null; + return { + ...this.options, + query: { + ...maybeObj(this.options.query), + page: cursor + } + }; + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/auth/workload-identity-auth.mjs +const SUBJECT_TOKEN_TYPES = { + jwt: "urn:ietf:params:oauth:token-type:jwt", + id: "urn:ietf:params:oauth:token-type:id_token" +}; +const TOKEN_EXCHANGE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:token-exchange"; +const MAX_REFRESH_BUFFER_FRACTION = .5; +function calculateExpiresAt(expiresIn, exchangeStartedAt) { + if (typeof expiresIn !== "number" || !Number.isFinite(expiresIn) || expiresIn <= 0) throw new OpenAIError("Token exchange response has invalid 'expires_in' field"); + const now = Date.now(); + const fullLifetimeDeadline = now + expiresIn * 1e3; + if (!Number.isSafeInteger(fullLifetimeDeadline) || fullLifetimeDeadline <= now) throw new OpenAIError("Token exchange response has invalid 'expires_in' field"); + const expiresAt = fullLifetimeDeadline - (performance.now() - exchangeStartedAt); + if (expiresAt <= now) throw new OpenAIError("Workload identity token expired before its exchange completed."); + return expiresAt; +} +function calculateRefreshAt(expiresAt, lifetimeSeconds, refreshBufferSeconds) { + const configuredBufferMs = (refreshBufferSeconds ?? 1200) * 1e3; + return expiresAt - Math.min(configuredBufferMs, lifetimeSeconds * 1e3 * MAX_REFRESH_BUFFER_FRACTION); +} +const NATIVE_RESPONSE_PROTOTYPE = Response.prototype; +const READ_NATIVE_RESPONSE_BODY = NATIVE_RESPONSE_PROTOTYPE.arrayBuffer; +function isResponsePrototype(response, prototype) { + const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor")?.value; + if (prototype === response || typeof constructor !== "function" || Object.getOwnPropertyDescriptor(constructor, "name")?.value !== "Response" || Object.getOwnPropertyDescriptor(constructor, "prototype")?.value !== prototype) return false; + const tag = Object.getOwnPropertyDescriptor(prototype, Symbol.toStringTag); + return (tag?.value === "Response" || typeof tag?.get === "function") && typeof Object.getOwnPropertyDescriptor(prototype, "headers")?.get === "function" && typeof Object.getOwnPropertyDescriptor(prototype, "ok")?.get === "function" && typeof Object.getOwnPropertyDescriptor(prototype, "status")?.get === "function"; +} +function isResponseBodyPrototype(prototype, responsePrototype) { + if (prototype === responsePrototype) return true; + const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor")?.value; + return responsePrototype !== null && Object.getPrototypeOf(responsePrototype) === prototype && typeof constructor === "function" && Object.getOwnPropertyDescriptor(constructor, "name")?.value === "Body" && Object.getOwnPropertyDescriptor(constructor, "prototype")?.value === prototype; +} +function decodeNativeResponseBody(body) { + return new TextDecoder("utf-8", { ignoreBOM: typeof globalThis.Bun?.version === "string" }).decode(body); +} +async function parseOAuthTokenResponse(response) { + let readText; + let responsePrototype = null; + for (let depth = 0, prototype = response; prototype !== null && depth < 16; prototype = Object.getPrototypeOf(prototype), depth += 1) { + if (prototype === NATIVE_RESPONSE_PROTOTYPE) break; + if (isResponsePrototype(response, prototype)) responsePrototype = prototype; + const parser = Object.getOwnPropertyDescriptor(prototype, "json"); + if (!parser) continue; + if (typeof parser.value !== "function") break; + const bodyReader = Object.getOwnPropertyDescriptor(prototype, "text")?.value; + if (typeof bodyReader === "function" && isResponseBodyPrototype(prototype, responsePrototype)) { + readText = bodyReader; + break; + } + return parser.value.call(response); + } + const body = readText === void 0 ? decodeNativeResponseBody(await READ_NATIVE_RESPONSE_BODY.call(response)) : await readText.call(response); + try { + return JSON.parse(body); + } catch { + throw new SyntaxError("Token exchange response contains invalid JSON"); + } +} +function isUnsafeAccessToken(accessToken) { + if (typeof globalThis.Bun?.version === "string") return /[^\t\u0020-\u007E]|^[\t ]|[\t ]$/u.test(accessToken); + return /[^\t\u0020-\u007E\u0080-\u00FF]|^[\t ]|[\t ]$/u.test(accessToken); +} +/** +* Exchanges external workload-identity tokens for cached OpenAI access tokens. +* +* Concurrent token exchanges are shared. Valid cached tokens are returned while +* a proactive refresh runs in the background; expired or missing tokens wait +* for a successful exchange before they are returned. +*/ +var WorkloadIdentityAuth = class WorkloadIdentityAuth { + /** + * Creates a workload-identity token cache and OAuth token-exchange client. + * + * @param config External identity provider, OpenAI service account, and refresh settings. + * @param fetch Optional fetch implementation for calls to the OpenAI token endpoint. + */ + constructor(config, fetch) { + this.cachedToken = null; + this.refreshPromise = null; + this.tokenGeneration = 0; + this.tokenExchangeUrl = "https://auth.openai.com/oauth/token"; + const { identityProviderId, serviceAccountId, clientId, refreshBufferSeconds, provider } = config; + this.config = { + identityProviderId, + serviceAccountId, + ...clientId === void 0 ? {} : { clientId }, + ...refreshBufferSeconds === void 0 ? {} : { refreshBufferSeconds }, + provider: { + tokenType: provider.tokenType, + getToken: provider.getToken.bind(provider) + } + }; + this.fetch = fetch ?? getDefaultFetch(); + } + /** + * Returns a valid OpenAI access token, exchanging or refreshing credentials as needed. + * + * Cached tokens nearing expiration are returned immediately while a background + * refresh runs. Concurrent callers share the same in-flight token exchange. + * + * @throws {OAuthError} When the token endpoint rejects the subject token or identity. + * @throws {APIError} When another unsuccessful HTTP response prevents token exchange. + * @throws {OpenAIError} When a successful exchange has an invalid access token or expiration. + */ + async getToken() { + if (!this.cachedToken || WorkloadIdentityAuth.isTokenExpired(this.cachedToken)) { + if (this.refreshPromise) return await this.refreshPromise; + const refreshPromise = this.refreshToken(this.tokenGeneration); + this.refreshPromise = refreshPromise; + try { + return await refreshPromise; + } finally { + if (this.refreshPromise === refreshPromise) this.refreshPromise = null; + } + } + if (WorkloadIdentityAuth.needsRefresh(this.cachedToken) && !this.refreshPromise) { + const refreshPromise = this.refreshToken(this.tokenGeneration).finally(() => { + if (this.refreshPromise === refreshPromise) this.refreshPromise = null; + }); + this.refreshPromise = refreshPromise; + refreshPromise.catch(() => null); + } + return this.cachedToken.token; + } + async refreshToken(generation) { + const subjectToken = await this.config.provider.getToken(); + const body = { + grant_type: TOKEN_EXCHANGE_GRANT_TYPE, + subject_token: subjectToken, + subject_token_type: SUBJECT_TOKEN_TYPES[this.config.provider.tokenType], + identity_provider_id: this.config.identityProviderId, + service_account_id: this.config.serviceAccountId + }; + if (this.config.clientId) body["client_id"] = this.config.clientId; + const exchangeStartedAt = performance.now(); + const response = await this.fetch(this.tokenExchangeUrl, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify(body), + redirect: "manual" + }); + if (!response.ok) { + const errorText = await response.text(); + let body = void 0; + try { + body = JSON.parse(errorText); + } catch {} + if (response.status === 400 || response.status === 401 || response.status === 403) throw new OAuthError(response.status, body, response.headers); + throw APIError.generate(response.status, body, `Token exchange failed with status ${response.status}`, response.headers); + } + const tokenResponse = await parseOAuthTokenResponse(response); + const accessToken = typeof tokenResponse === "object" && tokenResponse !== null && "access_token" in tokenResponse ? tokenResponse.access_token : void 0; + if (typeof accessToken !== "string" || accessToken.trim().length === 0 || isUnsafeAccessToken(accessToken)) throw new OpenAIError("Token exchange response missing 'access_token' field"); + const expiresIn = tokenResponse.expires_in ?? 3600; + const expiresAt = calculateExpiresAt(expiresIn, exchangeStartedAt); + if (this.tokenGeneration === generation) this.cachedToken = { + token: accessToken, + expiresAt, + refreshAt: calculateRefreshAt(expiresAt, expiresIn, this.config.refreshBufferSeconds) + }; + return accessToken; + } + static isTokenExpired(cachedToken) { + return Date.now() >= cachedToken.expiresAt; + } + static needsRefresh(cachedToken) { + return Date.now() >= cachedToken.refreshAt; + } + /** Discards the cached access token so the next request performs a fresh exchange. */ + invalidateToken() { + this.tokenGeneration += 1; + this.cachedToken = null; + this.refreshPromise = null; + } +}; +/** Validates the enrolled API authority and rejects credential-bearing query parameters. */ +function assertX509APIOrigin(value) { + let target; + try { + target = new URL(value); + } catch { + throw new OpenAIError("X.509 workload identity requires the approved global mTLS API origin."); + } + if (target.origin !== "https://mtls.api.openai.com" || target.username || target.password) throw new OpenAIError("X.509 workload identity requires the approved global mTLS API origin."); + for (const name of target.searchParams.keys()) if (isSensitiveQueryParameter(name)) throw new OpenAIError("X.509 workload identity cannot send conflicting query authentication credentials."); + return target; +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/headers.mjs +const brand_privateNullableHeaders = /* @__PURE__ */ Symbol("brand.privateNullableHeaders"); +const httpTokenHeaderName = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/; +function* iterateHeaders(headers) { + if (!headers) return; + if (brand_privateNullableHeaders in headers) { + const { values, nulls } = headers; + yield* values.entries(); + for (const name of nulls) yield [name, null]; + return; + } + let shouldClear = false; + let iter; + const iterator = Symbol.iterator in headers ? headers[Symbol.iterator] : void 0; + if (typeof iterator === "function") iter = { [Symbol.iterator]: () => iterator.call(headers) }; + else { + shouldClear = true; + iter = Object.entries(headers ?? {}); + } + for (let row of iter) { + const name = row[0]; + if (typeof name !== "string") throw new TypeError("expected header name to be a string"); + const values = isReadonlyArray(row[1]) ? row[1] : [row[1]]; + let didClear = false; + for (const value of values) { + if (value === void 0) continue; + if (shouldClear && !didClear) { + didClear = true; + yield [name, null]; + } + yield [name, value]; + } + } +} +const buildHeaders = (newHeaders) => { + const targetHeaders = new Headers(); + const nullHeaders = /* @__PURE__ */ new Set(); + for (const headers of newHeaders) { + const seenHeaders = /* @__PURE__ */ new Set(); + for (const [name, value] of iterateHeaders(headers)) { + if (!httpTokenHeaderName.test(name)) throw new TypeError(`Header name must be a valid HTTP token ["${name}"]`); + const lowerName = name.toLowerCase(); + if (!seenHeaders.has(lowerName)) { + targetHeaders.delete(lowerName); + seenHeaders.add(lowerName); + } + if (value === null) { + targetHeaders.delete(lowerName); + nullHeaders.add(lowerName); + } else { + targetHeaders.append(lowerName, value); + nullHeaders.delete(lowerName); + } + } + } + return { + [brand_privateNullableHeaders]: true, + values: targetHeaders, + nulls: nullHeaders + }; +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/auth/x509-transport-state-browser.mjs +var x509_transport_state_browser_exports = /* @__PURE__ */ __exportAll({ + findRegisteredX509Transport: () => findRegisteredX509Transport$1, + findX509Credential: () => findX509Credential$1, + findX509OAuthError: () => findX509OAuthError$1, + isApprovedX509Client: () => isApprovedX509Client$1, + isRetryableX509IssuerError: () => isRetryableX509IssuerError$1, + isTransientX509ConnectionError: () => isTransientX509ConnectionError$1, + markApprovedX509Client: () => markApprovedX509Client$1, + markRetryableX509IssuerError: () => markRetryableX509IssuerError$1, + markTransientX509ConnectionError: () => markTransientX509ConnectionError$1, + rememberRegisteredX509Transport: () => rememberRegisteredX509Transport$1, + rememberX509Credential: () => rememberX509Credential$1, + rememberX509OAuthError: () => rememberX509OAuthError$1 +}); +/** Browser-safe capability state keeps CommonJS outside the ordinary SDK ESM graph. */ +const registeredX509Transports = /* @__PURE__ */ new WeakMap(); +const transientX509ConnectionErrors = /* @__PURE__ */ new WeakSet(); +const retryableX509IssuerErrors = /* @__PURE__ */ new WeakSet(); +const approvedX509Clients = /* @__PURE__ */ new WeakSet(); +const approvedX509OAuthErrors = /* @__PURE__ */ new WeakMap(); +const approvedX509Credentials = /* @__PURE__ */ new WeakMap(); +/** Looks up an opaque capability without exposing the registry itself. */ +const findRegisteredX509Transport$1 = WeakMap.prototype.get.bind(registeredX509Transports); +/** Records a capability only after its Node-only factory validates the private dispatcher. */ +const rememberRegisteredX509Transport$1 = WeakMap.prototype.set.bind(registeredX509Transports); +/** Privately classifies sanitized issuer errors without exposing transport details. */ +const markTransientX509ConnectionError$1 = WeakSet.prototype.add.bind(transientX509ConnectionErrors); +/** Checks the private transient classification without retaining caller-owned errors. */ +const isTransientX509ConnectionError$1 = WeakSet.prototype.has.bind(transientX509ConnectionErrors); +/** Privately brands retryable issuer failures without exposing classification state. */ +const markRetryableX509IssuerError$1 = WeakSet.prototype.add.bind(retryableX509IssuerErrors); +/** Recognizes trusted issuer failures without evaluating caller-controlled properties. */ +const isRetryableX509IssuerError$1 = WeakSet.prototype.has.bind(retryableX509IssuerErrors); +/** Brands validated clients without exposing their mutable options or authentication fields. */ +const markApprovedX509Client$1 = WeakSet.prototype.add.bind(approvedX509Clients); +/** Recognizes private client ownership without caller-visible markers. */ +const isApprovedX509Client$1 = WeakSet.prototype.has.bind(approvedX509Clients); +/** Stores trusted OAuth metadata without exposing it to unrelated callers. */ +const rememberX509OAuthError$1 = WeakMap.prototype.set.bind(approvedX509OAuthErrors); +/** Retrieves trusted metadata when public OAuth errors cross module formats. */ +const findX509OAuthError$1 = WeakMap.prototype.get.bind(approvedX509OAuthErrors); +/** Privately binds SDK-owned credentials without importing Node or optional transport peers. */ +const rememberX509Credential$1 = WeakMap.prototype.set.bind(approvedX509Credentials); +/** Resolves only credentials registered by the optional Node authentication helper. */ +const findX509Credential$1 = WeakMap.prototype.get.bind(approvedX509Credentials); +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/auth/x509-transport-state.mjs +var import_x509_transport_state = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => { + if (typeof module !== "undefined" && module !== globalThis.module && typeof exports !== "undefined" && module.exports === exports) { + Object.defineProperty(exports, "__esModule", { value: true }); + exports.findX509Credential = exports.rememberX509Credential = exports.findX509OAuthError = exports.rememberX509OAuthError = exports.isApprovedX509Client = exports.markApprovedX509Client = exports.isRetryableX509IssuerError = exports.markRetryableX509IssuerError = exports.isTransientX509ConnectionError = exports.markTransientX509ConnectionError = exports.rememberRegisteredX509Transport = exports.findRegisteredX509Transport = void 0; + /** One lexical capability registry remains authoritative across mixed module formats. */ + const registeredX509Transports = /* @__PURE__ */ new WeakMap(); + const transientX509ConnectionErrors = /* @__PURE__ */ new WeakSet(); + const retryableX509IssuerErrors = /* @__PURE__ */ new WeakSet(); + const approvedX509Clients = /* @__PURE__ */ new WeakSet(); + const approvedX509OAuthErrors = /* @__PURE__ */ new WeakMap(); + const approvedX509Credentials = /* @__PURE__ */ new WeakMap(); + /** Looks up an opaque capability without exposing the registry itself. */ + exports.findRegisteredX509Transport = WeakMap.prototype.get.bind(registeredX509Transports); + /** Records a capability only after the Node-only factory verifies its genuine private dispatcher. */ + exports.rememberRegisteredX509Transport = WeakMap.prototype.set.bind(registeredX509Transports); + /** Privately brands sanitized connection errors shared across CommonJS and ESM clients. */ + exports.markTransientX509ConnectionError = WeakSet.prototype.add.bind(transientX509ConnectionErrors); + /** Recognizes a transient connection without trusting public error properties. */ + exports.isTransientX509ConnectionError = WeakSet.prototype.has.bind(transientX509ConnectionErrors); + /** Privately brands issuer-generated retryable HTTP failures across module formats. */ + exports.markRetryableX509IssuerError = WeakSet.prototype.add.bind(retryableX509IssuerErrors); + /** Recognizes only retryable HTTP errors produced by the trusted certificate exchange. */ + exports.isRetryableX509IssuerError = WeakSet.prototype.has.bind(retryableX509IssuerErrors); + /** Brands only clients whose transport capability was successfully validated. */ + exports.markApprovedX509Client = WeakSet.prototype.add.bind(approvedX509Clients); + /** Recognizes immutable client ownership across mixed CommonJS and ESM helpers. */ + exports.isApprovedX509Client = WeakSet.prototype.has.bind(approvedX509Clients); + /** Records the sanitized OAuth response without trusting mutable public error properties. */ + exports.rememberX509OAuthError = WeakMap.prototype.set.bind(approvedX509OAuthErrors); + /** Retrieves trusted OAuth metadata for public cross-module error normalization. */ + exports.findX509OAuthError = WeakMap.prototype.get.bind(approvedX509OAuthErrors); + /** Privately binds SDK-owned credentials to their immutable identity and approved transport. */ + exports.rememberX509Credential = WeakMap.prototype.set.bind(approvedX509Credentials); + /** Resolves only first-class credentials created by the optional Node transport helper. */ + exports.findX509Credential = WeakMap.prototype.get.bind(approvedX509Credentials); + } +})))(), 1); +const { findRegisteredX509Transport, rememberRegisteredX509Transport, markTransientX509ConnectionError, isTransientX509ConnectionError, markRetryableX509IssuerError, isRetryableX509IssuerError, markApprovedX509Client, isApprovedX509Client, rememberX509OAuthError, findX509OAuthError, rememberX509Credential, findX509Credential } = typeof import_x509_transport_state.findRegisteredX509Transport === "function" ? import_x509_transport_state : x509_transport_state_browser_exports; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/auth/x509-transport-registry.mjs +/** Resolves a previously registered opaque capability without importing an optional transport peer. */ +function resolveX509Transport(value) { + if (!value || typeof value !== "object") throw new OpenAIError("X.509 workload identity requires an approved X.509 transport capability."); + const registered = findRegisteredX509Transport(value); + if (!registered) throw new OpenAIError("X.509 workload identity requires an approved X.509 transport capability."); + return registered; +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/auth/x509-workload-identity-auth.mjs +var _X509WorkloadIdentityAuth_instances; +var _a$3; +var _X509WorkloadIdentityAuth_identityProviderId; +var _X509WorkloadIdentityAuth_serviceAccountId; +var _X509WorkloadIdentityAuth_configuredRefreshBufferMs; +var _X509WorkloadIdentityAuth_configuredRefreshBufferSeconds; +var _X509WorkloadIdentityAuth_organization; +var _X509WorkloadIdentityAuth_project; +var _X509WorkloadIdentityAuth_transport; +var _X509WorkloadIdentityAuth_refreshBufferMs; +var _X509WorkloadIdentityAuth_cachedToken; +var _X509WorkloadIdentityAuth_refresh; +var _X509WorkloadIdentityAuth_tokenGeneration; +var _X509WorkloadIdentityAuth_cancelRequestBody; +var _X509WorkloadIdentityAuth_assignToken; +var _X509WorkloadIdentityAuth_recoverRefreshFailure; +var _X509WorkloadIdentityAuth_fallbackToken; +var _X509WorkloadIdentityAuth_retireRefresh; +var _X509WorkloadIdentityAuth_beginRefresh; +var _X509WorkloadIdentityAuth_refreshToken; +var _X509WorkloadIdentityAuth_preflight; +var _X509WorkloadIdentityAuth_scope; +var _X509WorkloadIdentityAuth_assertTenantHeaders; +const FORBIDDEN_TRANSPORT_OPTIONS = [ + "dispatcher", + "agent", + "client", + "tls", + "proxy" +]; +const headerValue = (headers, name) => Headers.prototype.get.call(headers, name); +const DEFAULT_REFRESH_BUFFER_MS = 12e5; +const FAILED_REFRESH_COOLDOWN_MS = 1e3; +const userAbortError = (signal) => { + const error = new APIUserAbortError(); + Object.defineProperty(error, "cause", { + value: signal.reason, + writable: true, + configurable: true + }); + return error; +}; +function assertSafeHeaders(headers) { + for (const name of Headers.prototype.keys.call(headers)) { + const canonical = name.toLowerCase().split("_").join("-"); + if (canonical !== "authorization" && isSensitiveHeader(canonical) || canonical === "host") throw new OpenAIError("X.509 workload identity cannot send conflicting authentication credentials."); + } +} +function exchangeDeadline(timeout, callerSignal) { + const deadline = new AbortController(); + const timer = timeout === void 0 ? void 0 : setTimeout(() => deadline.abort(new APIConnectionTimeoutError()), timeout); + const timerHandle = timer; + if (typeof timerHandle === "object" && timerHandle !== null && "unref" in timerHandle && typeof timerHandle.unref === "function") timerHandle.unref(); + const cancel = () => deadline.abort(callerSignal?.reason); + callerSignal?.addEventListener("abort", cancel, { once: true }); + if (callerSignal?.aborted) cancel(); + return { + signal: deadline.signal, + dispose: () => { + callerSignal?.removeEventListener("abort", cancel); + if (timer) clearTimeout(timer); + } + }; +} +function waitForRefresh(attempt, signal) { + let abort; + const canceled = new Promise((_resolve, reject) => { + abort = () => reject(signal.reason); + signal.addEventListener("abort", abort, { once: true }); + if (signal.aborted) abort(); + }); + return { + result: Promise.race([attempt.promise, canceled]), + dispose: () => { + if (abort) signal.removeEventListener("abort", abort); + } + }; +} +/** Distinguishes true certificate identities from extensible legacy subject-token identities. */ +function isX509WorkloadIdentity(identity) { + if (!identity || typeof identity !== "object") return false; + let providerOwner = identity; + while (providerOwner !== null && providerOwner !== Object.prototype) { + const provider = Object.getOwnPropertyDescriptor(providerOwner, "provider"); + if (provider) { + if (!("value" in provider) || provider.value !== void 0) return false; + break; + } + providerOwner = Object.getPrototypeOf(providerOwner); + } + let current = identity; + while (current !== null && current !== Object.prototype) { + const discriminator = Object.getOwnPropertyDescriptor(current, "type"); + if (discriminator) { + if (!("value" in discriminator)) throw new OpenAIError("X.509 workload identity type must be a plain data property."); + return discriminator.value === "x509"; + } + current = Object.getPrototypeOf(current); + } + return false; +} +/** Prevents caller options from replacing the immutable transport selected at construction. */ +function assertX509FetchOptions(options) { + if (!options) return; + for (const name of FORBIDDEN_TRANSPORT_OPTIONS) if (hasOwn(options, name)) throw new OpenAIError("X.509 workload identity cannot override its approved transport capability."); + const redirect = Object.getOwnPropertyDescriptor(options, "redirect")?.value; + if (redirect !== void 0 && redirect !== "manual") throw new OpenAIError("X.509 workload identity requests require manual redirects."); +} +/** Rejects caller overrides while allowing the SDK-owned fields on the final RequestInit. */ +function assertX509RequestOptions(options) { + assertX509FetchOptions(options); + if (options && [ + "body", + "headers", + "method", + "signal" + ].some((name) => hasOwn(options, name))) throw new OpenAIError("X.509 workload identity cannot override its request body, headers, method, or signal through fetch options."); +} +/** Validates and snapshots the exact caller options that will reach authenticated dispatch. */ +function snapshotX509RequestOptions(options) { + assertX509RequestOptions(options); + const snapshot = { ...options }; + assertX509RequestOptions(snapshot); + return snapshot; +} +/** Bridges certificate authentication into existing OpenAI auth and fetch hooks without optional peers. */ +var X509WorkloadIdentityAuth = class { + /** Captures one registered, immutable certificate identity and its enrolled selectors. */ + constructor(identity, transport, organization, project) { + _X509WorkloadIdentityAuth_instances.add(this); + _X509WorkloadIdentityAuth_identityProviderId.set(this, void 0); + _X509WorkloadIdentityAuth_serviceAccountId.set(this, void 0); + _X509WorkloadIdentityAuth_configuredRefreshBufferMs.set(this, void 0); + _X509WorkloadIdentityAuth_configuredRefreshBufferSeconds.set(this, void 0); + _X509WorkloadIdentityAuth_organization.set(this, void 0); + _X509WorkloadIdentityAuth_project.set(this, void 0); + _X509WorkloadIdentityAuth_transport.set(this, void 0); + _X509WorkloadIdentityAuth_refreshBufferMs.set(this, void 0); + _X509WorkloadIdentityAuth_cachedToken.set(this, void 0); + _X509WorkloadIdentityAuth_refresh.set(this, void 0); + _X509WorkloadIdentityAuth_tokenGeneration.set(this, 0); + __classPrivateFieldSet(this, _X509WorkloadIdentityAuth_transport, resolveX509Transport(transport), "f"); + __classPrivateFieldSet(this, _X509WorkloadIdentityAuth_identityProviderId, identity.identityProviderId, "f"); + __classPrivateFieldSet(this, _X509WorkloadIdentityAuth_serviceAccountId, identity.serviceAccountId, "f"); + __classPrivateFieldSet(this, _X509WorkloadIdentityAuth_configuredRefreshBufferMs, identity.refreshBufferMs, "f"); + __classPrivateFieldSet(this, _X509WorkloadIdentityAuth_configuredRefreshBufferSeconds, identity.refreshBufferSeconds, "f"); + __classPrivateFieldSet(this, _X509WorkloadIdentityAuth_organization, organization, "f"); + __classPrivateFieldSet(this, _X509WorkloadIdentityAuth_project, project, "f"); + if (__classPrivateFieldGet(this, _X509WorkloadIdentityAuth_configuredRefreshBufferMs, "f") !== void 0 && __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_configuredRefreshBufferSeconds, "f") !== void 0) throw new OpenAIError("X.509 workload identity cannot combine refreshBufferSeconds and refreshBufferMs."); + if (__classPrivateFieldGet(this, _X509WorkloadIdentityAuth_configuredRefreshBufferMs, "f") !== void 0 && (!Number.isSafeInteger(__classPrivateFieldGet(this, _X509WorkloadIdentityAuth_configuredRefreshBufferMs, "f")) || __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_configuredRefreshBufferMs, "f") < 0)) throw new OpenAIError("X.509 workload identity requires a nonnegative integer refreshBufferMs."); + if (__classPrivateFieldGet(this, _X509WorkloadIdentityAuth_configuredRefreshBufferSeconds, "f") !== void 0 && (!Number.isSafeInteger(__classPrivateFieldGet(this, _X509WorkloadIdentityAuth_configuredRefreshBufferSeconds, "f")) || __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_configuredRefreshBufferSeconds, "f") < 0 || !Number.isSafeInteger(__classPrivateFieldGet(this, _X509WorkloadIdentityAuth_configuredRefreshBufferSeconds, "f") * 1e3))) throw new OpenAIError("X.509 workload identity requires a nonnegative integer refreshBufferSeconds."); + __classPrivateFieldSet(this, _X509WorkloadIdentityAuth_refreshBufferMs, __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_configuredRefreshBufferSeconds, "f") === void 0 ? __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_configuredRefreshBufferMs, "f") ?? DEFAULT_REFRESH_BUFFER_MS : __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_configuredRefreshBufferSeconds, "f") * 1e3, "f"); + } + /** Reconstructs the immutable selectors captured before caller-owned identity mutation. */ + identitySnapshot() { + return { + type: "x509", + identityProviderId: __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_identityProviderId, "f"), + serviceAccountId: __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_serviceAccountId, "f"), + ...__classPrivateFieldGet(this, _X509WorkloadIdentityAuth_configuredRefreshBufferMs, "f") === void 0 ? {} : { refreshBufferMs: __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_configuredRefreshBufferMs, "f") }, + ...__classPrivateFieldGet(this, _X509WorkloadIdentityAuth_configuredRefreshBufferSeconds, "f") === void 0 ? {} : { refreshBufferSeconds: __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_configuredRefreshBufferSeconds, "f") } + }; + } + /** Preserves explicitly headerless requests without presenting a certificate to the issuer. */ + static shouldAuthenticate(options, defaultHeaders, requestHeaders = options.headers) { + return !buildHeaders([defaultHeaders, requestHeaders]).nulls.has("authorization"); + } + /** Snapshots each caller-owned header layer once while preserving nulls and precedence. */ + snapshotHeaders(defaultHeaders, requestHeaders) { + const scope = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this); + scope.defaultHeaders ?? (scope.defaultHeaders = buildHeaders([defaultHeaders])); + scope.requestHeaders ?? (scope.requestHeaders = buildHeaders([requestHeaders])); + return this.headerSnapshots(); + } + /** Returns the already rendered caller headers without touching mutable inputs again. */ + headerSnapshots() { + const { defaultHeaders, requestHeaders } = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this); + if (!defaultHeaders || !requestHeaders) throw new OpenAIError("X.509 workload identity requires snapshotted request headers."); + return { + defaultHeaders, + requestHeaders + }; + } + /** Captures enrolled public tenant selectors once before certificate presentation. */ + snapshotTenant(organization, project) { + if (organization !== __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_organization, "f") || project !== __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_project, "f")) throw new OpenAIError("X.509 workload identity cannot override its enrolled organization or project."); + const scope = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this); + scope.tenant = { + organization, + project + }; + return scope.tenant; + } + /** Returns the tenant selectors already approved for this logical request. */ + tenantSnapshot() { + const { tenant } = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this); + if (!tenant) throw new OpenAIError("X.509 workload identity requires snapshotted tenant selectors."); + return tenant; + } + /** Validates and retains the exact destination that authenticated dispatch will use. */ + snapshotAPIURL(value) { + assertX509APIOrigin(value); + __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this).apiURL = value; + } + /** Reads the already-approved destination without rerendering caller-owned request options. */ + requestAPIURL() { + const { apiURL } = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this); + if (apiURL === void 0) throw new OpenAIError("X.509 workload identity requires a snapshotted API destination."); + return apiURL; + } + /** Captures the exact caller settings approved for authenticated dispatch. */ + snapshotRequest(signal, timeout, fetchOptions) { + var _b; + (_b = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this)).request ?? (_b.request = { + signal, + timeout, + fetchOptions + }); + } + /** Returns immutable request settings without invoking caller-owned accessors again. */ + requestSnapshot() { + const { request } = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this); + if (!request) throw new OpenAIError("X.509 workload identity requires snapshotted request settings."); + return request; + } + /** Suspends an already-running network budget during retry-local asynchronous preparation. */ + beginRequestPreparation() { + const scope = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this); + if (scope.deadlineArmed && scope.preparationStartedAt === void 0) { + scope.preparationStartedAt = performance.now(); + scope.preparationWallStartedAt = Date.now(); + } + } + /** Begins local request construction without charging protected hook latency to the network. */ + beginRequestPlanning() { + __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this).phase = "planning"; + } + /** Arms one absolute network deadline only after all local request preparation completes. */ + beginRequestNetwork() { + const scope = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this); + if (!scope.deadlineArmed) { + scope.wallStartedAt = Date.now(); + scope.monotonicStartedAt = performance.now(); + scope.deadlineArmed = true; + } else if (scope.preparationStartedAt !== void 0) { + scope.monotonicStartedAt += performance.now() - scope.preparationStartedAt; + scope.wallStartedAt += Date.now() - (scope.preparationWallStartedAt ?? Date.now()); + delete scope.preparationStartedAt; + delete scope.preparationWallStartedAt; + } + } + /** Keeps certificate authentication outside overridable request construction. */ + isPlanningRequest() { + return __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this).phase === "planning"; + } + /** Approves the final overridden destination and transport before minting a bearer. */ + authorizePlannedRequest(url, request, timeout, allowHookSignal = false) { + const scope = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this); + const headers = Object.getOwnPropertyDescriptor(request, "headers"); + const body = Object.getOwnPropertyDescriptor(request, "body"); + const signal = Object.getOwnPropertyDescriptor(request, "signal"); + const redirect = Object.getOwnPropertyDescriptor(request, "redirect"); + if (scope.phase !== "planning" || !headers || !(headers.value instanceof Headers) || !body && "body" in request || [ + body, + signal, + redirect + ].some((descriptor) => descriptor && !("value" in descriptor))) throw new OpenAIError("X.509 workload identity requires an approved final request."); + this.snapshotAPIURL(url); + assertX509FetchOptions(request); + try { + assertSafeHeaders(headers.value); + } catch { + throw new OpenAIError("X.509 workload identity cannot use caller-supplied authentication credentials."); + } + if (headerValue(headers.value, "Authorization") !== null) throw new OpenAIError("X.509 workload identity cannot use caller-supplied authorization credentials."); + __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_assertTenantHeaders).call(this, headers.value); + if (!allowHookSignal && (signal?.value ?? void 0) !== (this.requestSnapshot().signal ?? void 0)) throw new OpenAIError("X.509 workload identity must preserve its approved request signal."); + const approved = this.requestSnapshot(); + scope.request = { + ...approved, + timeout: Math.min(approved.timeout, timeout) + }; + scope.phase = "authorizing"; + } + /** Owns only SDK-created iterator adapters until authenticated dispatch takes responsibility. */ + ownRequestBody(body, source) { + if (body instanceof ReadableStream && body !== source) __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this).materializedBody = body; + } + /** Recognizes every one-shot upload before issuer authentication or request replay. */ + static isStreamingRequestBody(body) { + return globalThis.ReadableStream !== void 0 && body instanceof globalThis.ReadableStream || typeof body === "object" && body !== null && (Symbol.asyncIterator in body || Symbol.iterator in body && "next" in body && typeof body.next === "function"); + } + /** Retires abandoned upload adapters without masking or blocking their authentication failure. */ + retireRequestBody() { + const scope = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this); + const body = scope.materializedBody; + delete scope.materializedBody; + if (body) __classPrivateFieldGet(_a$3, _a$3, "m", _X509WorkloadIdentityAuth_cancelRequestBody).call(_a$3, body); + } + /** Transfers the dispatched upload while retiring any SDK-owned body replaced by a hook. */ + releaseRequestBody(body) { + const scope = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this); + if (scope.materializedBody === body) delete scope.materializedBody; + else this.retireRequestBody(); + } + /** Retains caller-only cancellation separately from SDK-created deadline controllers. */ + setEffectiveSignal(signal) { + if (signal) __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this).effectiveSignal = signal; + else delete __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this).effectiveSignal; + } + /** Uses protected-hook cancellation when an authenticated attempt enters retry backoff. */ + effectiveSignal() { + const scope = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this); + return scope.effectiveSignal ?? scope.request?.signal; + } + /** Establishes an independent scope even when concurrent requests share caller options. */ + runRequest(operation, requestOwner) { + return __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_transport, "f").run(async () => { + const scope = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_transport, "f").current(); + if (!scope) throw new OpenAIError("X.509 workload identity requires an active certificate request scope."); + scope.owner = this; + scope.requestOwner = requestOwner; + try { + return await operation(); + } finally { + this.retireRequestBody(); + this.releaseRequestCredentials(); + delete scope.requestOwner; + delete scope.owner; + } + }); + } + /** Reports whether a public request-building call already belongs to an active logical operation. */ + inRequest(requestOwner) { + const scope = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_transport, "f").current(); + return scope?.owner === this && scope.requestOwner === requestOwner && scope.phase !== "authorizing"; + } + /** Shares a cache only when the complete, privately snapshotted credential identity matches. */ + matches(other) { + return __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_transport, "f") === __classPrivateFieldGet(other, _X509WorkloadIdentityAuth_transport, "f") && __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_identityProviderId, "f") === __classPrivateFieldGet(other, _X509WorkloadIdentityAuth_identityProviderId, "f") && __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_serviceAccountId, "f") === __classPrivateFieldGet(other, _X509WorkloadIdentityAuth_serviceAccountId, "f") && __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_organization, "f") === __classPrivateFieldGet(other, _X509WorkloadIdentityAuth_organization, "f") && __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_project, "f") === __classPrivateFieldGet(other, _X509WorkloadIdentityAuth_project, "f") && __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_refreshBufferMs, "f") === __classPrivateFieldGet(other, _X509WorkloadIdentityAuth_refreshBufferMs, "f"); + } + /** Binds deferred response parsing to the original logical request and its unchanged deadline. */ + continuation() { + const { wallStartedAt, monotonicStartedAt, deadlineArmed, request, requestOwner, effectiveSignal } = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this); + const scope = { + wallStartedAt, + monotonicStartedAt, + owner: this, + ...deadlineArmed ? { deadlineArmed } : {}, + ...request ? { request } : {}, + ...effectiveSignal ? { effectiveSignal } : {}, + ...requestOwner ? { requestOwner } : {} + }; + return (operation) => __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_transport, "f").resume(scope, async () => { + try { + return await operation(); + } finally { + this.releaseRequestCredentials(); + delete scope.requestOwner; + delete scope.owner; + } + }); + } + /** Removes dispatched bearer material before settled request promises can retain their scope. */ + releaseRequestCredentials() { + const scope = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this); + delete scope.request; + delete scope.phase; + delete scope.deadlineArmed; + delete scope.preparationStartedAt; + delete scope.preparationWallStartedAt; + delete scope.effectiveSignal; + delete scope.materializedBody; + delete scope.apiURL; + delete scope.tenant; + delete scope.token; + delete scope.defaultHeaders; + delete scope.requestHeaders; + delete scope.tokenGeneration; + delete scope.headers; + delete scope.authorization; + } + /** Returns the original authentication start so response consumption shares its request deadline. */ + requestStartedAt(_options) { + return __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_transport, "f").current()?.wallStartedAt; + } + /** Distinguishes issued workload credentials from independent admin or headerless requests. */ + usedWorkloadToken(_options) { + return __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_transport, "f").current()?.token !== void 0; + } + /** Returns the budget left after certificate authentication without starting another timeout. */ + remainingTimeout(_options, timeout) { + const scope = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_transport, "f").current(); + if (scope === void 0) return timeout; + const remaining = timeout - (performance.now() - scope.monotonicStartedAt); + if (remaining <= 0) throw new APIConnectionTimeoutError(); + return remaining; + } + /** Cancels active retry timers promptly without changing public caller-abort semantics. */ + async waitForRetry(duration, signal) { + try { + await __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_transport, "f").sleep(duration, signal); + } catch (error) { + if (signal?.aborted) throw userAbortError(signal); + throw error; + } + } + /** Trusts only issuer or connection failures privately branded by the approved transport. */ + static isRetryableFailure(error) { + return typeof error === "object" && error !== null && (isTransientX509ConnectionError(error) || isRetryableX509IssuerError(error)); + } + /** Reads safe retry hints only from a privately branded, sanitized issuer response. */ + static retryHeaders(error) { + if (!error || typeof error !== "object" || !isRetryableX509IssuerError(error)) return; + const headers = Object.getOwnPropertyDescriptor(error, "headers")?.value; + return headers instanceof Headers ? headers : void 0; + } + /** Exchanges the exact certificate capability selected for the matching API dispatch. */ + async getToken(options, context) { + const callerSignal = context ? context.signal : options?.signal; + if (callerSignal?.aborted) throw userAbortError(callerSignal); + if (options) assertX509RequestOptions(context ? context.fetchOptions : options.fetchOptions); + __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_preflight).call(this, context); + const scope = options ? __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this) : void 0; + const cached = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_cachedToken, "f"); + if (cached && performance.now() < cached.refreshAt && Date.now() < cached.wallRefreshAt) return __classPrivateFieldGet(_a$3, _a$3, "m", _X509WorkloadIdentityAuth_assignToken).call(_a$3, scope, cached); + const { signal, dispose } = exchangeDeadline(context && options ? this.remainingTimeout(options, context.timeout) : context?.timeout, callerSignal); + if (callerSignal?.aborted) { + dispose(); + throw userAbortError(callerSignal); + } + const attempt = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_refresh, "f") ?? __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_beginRefresh).call(this); + attempt.waiters += 1; + const waiter = waitForRefresh(attempt, signal); + try { + const exchanged = await waiter.result; + const refreshed = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_cachedToken, "f"); + if (!refreshed || refreshed.accessToken !== exchanged.accessToken) throw new APIUserAbortError(); + return __classPrivateFieldGet(_a$3, _a$3, "m", _X509WorkloadIdentityAuth_assignToken).call(_a$3, scope, refreshed); + } catch (error) { + return await __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_recoverRefreshFailure).call(this, error, attempt, cached, scope, options, context); + } finally { + waiter.dispose(); + dispose(); + attempt.waiters -= 1; + __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_retireRefresh).call(this, attempt); + } + } + /** Invalidates only the workload-token generation actually rejected by the current request. */ + invalidateToken() { + const rejected = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_transport, "f").current(); + if (!rejected?.token || __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_cachedToken, "f")?.accessToken !== rejected.token || __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_cachedToken, "f").generation !== rejected.tokenGeneration) return; + __classPrivateFieldSet(this, _X509WorkloadIdentityAuth_tokenGeneration, __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_tokenGeneration, "f") + 1, "f"); + __classPrivateFieldSet(this, _X509WorkloadIdentityAuth_cachedToken, void 0, "f"); + const refresh = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_refresh, "f"); + __classPrivateFieldSet(this, _X509WorkloadIdentityAuth_refresh, void 0, "f"); + refresh?.controller.abort(new APIUserAbortError()); + } + /** Binds the minted credential to the original headers before protected request hooks run. */ + bindRequest(options, request, adminAPIKey) { + if (!(request.headers instanceof Headers)) throw new OpenAIError("X.509 workload identity requires the original workload authorization headers."); + const scope = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this); + const { token } = scope; + const security = options.__security ?? { bearerAuth: true }; + let approvedAuthorization = token ? `Bearer ${token}` : null; + if (!token && security.adminAPIKeyAuth && adminAPIKey !== null && headerValue(request.headers, "Authorization") !== null) approvedAuthorization = new Headers({ Authorization: `Bearer ${adminAPIKey}` }).get("Authorization"); + scope.headers = request.headers; + scope.authorization = approvedAuthorization; + this.assertRequest(request); + } + /** Rebinds an equivalent protected-hook container without relaxing final dispatch identity checks. */ + adoptRequestHeaders(request) { + const scope = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_scope).call(this); + const original = scope.headers; + if (!(original instanceof Headers) || !(request.headers instanceof Headers)) throw new OpenAIError("X.509 workload identity must preserve its issued workload authorization."); + scope.headers = request.headers; + try { + this.assertRequest(request); + } catch (error) { + scope.headers = original; + throw error; + } + } + /** Rejects request hooks that replace the selected bearer or its approved header identity. */ + assertRequest(request) { + const { headers } = request; + if (!(headers instanceof Headers)) throw new OpenAIError("X.509 workload identity must preserve its issued workload authorization."); + const scope = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_transport, "f").current(); + if (!scope || scope.headers !== headers || scope.authorization === void 0 || headerValue(headers, "Authorization") !== scope.authorization) throw new OpenAIError("X.509 workload identity must preserve its issued workload authorization."); + __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_assertTenantHeaders).call(this, headers); + assertSafeHeaders(headers); + } + /** Returns a guarded final dispatcher while preserving all existing request hook object identities. */ + fetch() { + return async (input, init = {}) => { + const target = assertX509APIOrigin(typeof input === "string" || input instanceof URL ? input : input.url); + assertX509FetchOptions(init); + this.assertRequest(init); + const approved = init.headers; + if (!(approved instanceof Headers)) throw new OpenAIError("X.509 workload identity must preserve its issued workload authorization."); + const headers = new Headers([...Headers.prototype.entries.call(approved)]); + assertSafeHeaders(headers); + init.headers = headers; + init.redirect = "manual"; + return await __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_transport, "f").dispatch(target, init); + }; + } +}; +_a$3 = X509WorkloadIdentityAuth, _X509WorkloadIdentityAuth_identityProviderId = /* @__PURE__ */ new WeakMap(), _X509WorkloadIdentityAuth_serviceAccountId = /* @__PURE__ */ new WeakMap(), _X509WorkloadIdentityAuth_configuredRefreshBufferMs = /* @__PURE__ */ new WeakMap(), _X509WorkloadIdentityAuth_configuredRefreshBufferSeconds = /* @__PURE__ */ new WeakMap(), _X509WorkloadIdentityAuth_organization = /* @__PURE__ */ new WeakMap(), _X509WorkloadIdentityAuth_project = /* @__PURE__ */ new WeakMap(), _X509WorkloadIdentityAuth_transport = /* @__PURE__ */ new WeakMap(), _X509WorkloadIdentityAuth_refreshBufferMs = /* @__PURE__ */ new WeakMap(), _X509WorkloadIdentityAuth_cachedToken = /* @__PURE__ */ new WeakMap(), _X509WorkloadIdentityAuth_refresh = /* @__PURE__ */ new WeakMap(), _X509WorkloadIdentityAuth_tokenGeneration = /* @__PURE__ */ new WeakMap(), _X509WorkloadIdentityAuth_instances = /* @__PURE__ */ new WeakSet(), _X509WorkloadIdentityAuth_cancelRequestBody = async function _X509WorkloadIdentityAuth_cancelRequestBody(body) { + try { + await CancelReadableStream(body); + } catch {} +}, _X509WorkloadIdentityAuth_assignToken = function _X509WorkloadIdentityAuth_assignToken(scope, token) { + if (scope) { + scope.token = token.accessToken; + scope.tokenGeneration = token.generation; + } + return token.accessToken; +}, _X509WorkloadIdentityAuth_recoverRefreshFailure = async function _X509WorkloadIdentityAuth_recoverRefreshFailure(error, attempt, cached, scope, options, context) { + const callerSignal = context ? context.signal : options?.signal; + if (callerSignal?.aborted) throw userAbortError(callerSignal); + if (attempt.controller.signal.aborted && attempt.generation !== __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_tokenGeneration, "f")) return await this.getToken(options, context); + const fallback = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_fallbackToken).call(this, error, cached, scope); + if (fallback !== void 0) return fallback; + if (error && typeof error === "object" && !(error instanceof OAuthError)) { + const oauth = findX509OAuthError(error); + if (oauth) throw new OAuthError(oauth.status, oauth.error, oauth.headers); + } + throw error; +}, _X509WorkloadIdentityAuth_fallbackToken = function _X509WorkloadIdentityAuth_fallbackToken(error, cached, scope) { + if (!cached || cached !== __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_cachedToken, "f") || performance.now() >= cached.expiresAt || Date.now() >= cached.wallExpiresAt || !_a$3.isRetryableFailure(error)) return; + const headers = _a$3.retryHeaders(error); + const milliseconds = headers?.get("retry-after-ms"); + let requested = milliseconds ? Number(milliseconds) : void 0; + const retryAfter = headers?.get("retry-after"); + if (retryAfter && (requested === void 0 || Number.isNaN(requested))) { + const seconds = Number(retryAfter); + requested = Number.isNaN(seconds) ? Date.parse(retryAfter) - Date.now() : seconds * 1e3; + } + const cooldown = requested !== void 0 && Number.isFinite(requested) && requested >= 0 && requested <= 6e4 ? Math.max(FAILED_REFRESH_COOLDOWN_MS, requested) : FAILED_REFRESH_COOLDOWN_MS; + cached.refreshAt = Math.min(cached.expiresAt, performance.now() + cooldown); + cached.wallRefreshAt = Math.min(cached.wallExpiresAt, Date.now() + cooldown); + return __classPrivateFieldGet(_a$3, _a$3, "m", _X509WorkloadIdentityAuth_assignToken).call(_a$3, scope, cached); +}, _X509WorkloadIdentityAuth_retireRefresh = function _X509WorkloadIdentityAuth_retireRefresh(attempt) { + if (attempt.waiters !== 0 || __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_refresh, "f") !== attempt) return; + queueMicrotask(() => { + if (attempt.waiters === 0 && __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_refresh, "f") === attempt) { + __classPrivateFieldSet(this, _X509WorkloadIdentityAuth_refresh, void 0, "f"); + __classPrivateFieldSet(this, _X509WorkloadIdentityAuth_tokenGeneration, __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_tokenGeneration, "f") + 1, "f"); + attempt.controller.abort(new APIUserAbortError()); + } + }); +}, _X509WorkloadIdentityAuth_beginRefresh = function _X509WorkloadIdentityAuth_beginRefresh() { + const controller = new AbortController(); + const generation = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_tokenGeneration, "f"); + const attempt = { + controller, + generation, + waiters: 0, + promise: __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_instances, "m", _X509WorkloadIdentityAuth_refreshToken).call(this, controller, generation) + }; + __classPrivateFieldSet(this, _X509WorkloadIdentityAuth_refresh, attempt, "f"); + return attempt; +}, _X509WorkloadIdentityAuth_refreshToken = async function _X509WorkloadIdentityAuth_refreshToken(controller, generation) { + const startedAt = performance.now(); + const wallStartedAt = Date.now(); + try { + const token = await __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_transport, "f").exchange(__classPrivateFieldGet(this, _X509WorkloadIdentityAuth_identityProviderId, "f"), __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_serviceAccountId, "f"), controller.signal); + const lifetime = token.expiresIn * 1e3; + const expiresAt = startedAt + lifetime; + const wallExpiresAt = wallStartedAt + lifetime; + if (performance.now() >= expiresAt || Date.now() >= wallExpiresAt) throw new OpenAIError("X.509 workload identity token expired before its exchange completed."); + if (__classPrivateFieldGet(this, _X509WorkloadIdentityAuth_tokenGeneration, "f") !== generation || controller.signal.aborted || __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_refresh, "f")?.controller !== controller) throw new APIUserAbortError(); + __classPrivateFieldSet(this, _X509WorkloadIdentityAuth_tokenGeneration, __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_tokenGeneration, "f") + 1, "f"); + __classPrivateFieldSet(this, _X509WorkloadIdentityAuth_cachedToken, { + accessToken: token.accessToken, + generation: __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_tokenGeneration, "f"), + expiresAt, + refreshAt: expiresAt - Math.min(__classPrivateFieldGet(this, _X509WorkloadIdentityAuth_refreshBufferMs, "f"), lifetime / 2), + wallExpiresAt, + wallRefreshAt: wallExpiresAt - Math.min(__classPrivateFieldGet(this, _X509WorkloadIdentityAuth_refreshBufferMs, "f"), lifetime / 2) + }, "f"); + return token; + } finally { + if (__classPrivateFieldGet(this, _X509WorkloadIdentityAuth_refresh, "f")?.controller === controller) __classPrivateFieldSet(this, _X509WorkloadIdentityAuth_refresh, void 0, "f"); + } +}, _X509WorkloadIdentityAuth_preflight = function _X509WorkloadIdentityAuth_preflight(context) { + if (!context) return; + if (context.organization !== __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_organization, "f") || context.project !== __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_project, "f")) throw new OpenAIError("X.509 workload identity cannot override its enrolled organization or project."); + assertX509APIOrigin(context.apiURL); + const supplied = buildHeaders([context.defaultHeaders, context.requestHeaders]); + if (__classPrivateFieldGet(this, _X509WorkloadIdentityAuth_organization, "f") !== null && supplied.nulls.has("openai-organization") || __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_project, "f") !== null && supplied.nulls.has("openai-project")) throw new OpenAIError("X.509 workload identity cannot omit its enrolled organization or project."); + for (const name of supplied.values.keys()) { + const canonical = name.toLowerCase().split("_").join("-"); + if ((canonical === "openai-organization" || canonical === "openai-project") && (name !== canonical || headerValue(supplied.values, name) !== (canonical === "openai-organization" ? context.organization : context.project))) throw new OpenAIError("X.509 workload identity cannot override its enrolled organization or project."); + if (isSensitiveHeader(canonical) || canonical === "host") throw new OpenAIError("X.509 workload identity cannot use caller-supplied authentication credentials."); + } +}, _X509WorkloadIdentityAuth_scope = function _X509WorkloadIdentityAuth_scope() { + const scope = __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_transport, "f").current(); + if (!scope || scope.owner !== this) throw new OpenAIError("X.509 workload identity requires an active certificate request scope."); + return scope; +}, _X509WorkloadIdentityAuth_assertTenantHeaders = function _X509WorkloadIdentityAuth_assertTenantHeaders(headers) { + if (headerValue(headers, "OpenAI-Organization") !== __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_organization, "f") || headerValue(headers, "OpenAI-Project") !== __classPrivateFieldGet(this, _X509WorkloadIdentityAuth_project, "f")) throw new OpenAIError("X.509 workload identity cannot override its enrolled organization or project."); + for (const name of Headers.prototype.keys.call(headers)) { + const canonical = name.toLowerCase().split("_").join("-"); + if ((canonical === "openai-organization" || canonical === "openai-project") && name !== canonical) throw new OpenAIError("X.509 workload identity cannot override its enrolled organization or project."); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/auth/x509-credential-options.mjs +/** Validates one privately registered credential and suppresses ambient legacy authentication. */ +function normalizeX509CredentialOptions(options) { + const { credential } = options; + if (credential === void 0) return { + credential, + options + }; + const registered = findX509Credential(credential); + if (!registered) throw new OpenAIError("An X.509 credential must be created by the SDK authentication helper."); + const conflicting = [ + "apiKey", + "adminAPIKey", + "workloadIdentity", + "x509Transport" + ].filter((name) => { + const value = options[name]; + return value !== null && value !== void 0; + }); + if (conflicting.length > 0) throw new OpenAIError(`The \`credential\` option cannot be combined with ${conflicting.map((name) => `\`${name}\``).join(", ")}.`); + return { + credential, + options: { + ...options, + apiKey: null, + adminAPIKey: null, + baseURL: options.baseURL ?? null, + organization: options.organization ?? null, + project: options.project ?? null, + workloadIdentity: registered.identity, + x509Transport: registered.transport + } + }; +} +/** Distinguishes explicitly supplied ordinary credentials from nullish inheritance. */ +function overridesOrdinaryAuthentication({ apiKey, adminAPIKey }) { + return apiKey !== null && apiKey !== void 0 || adminAPIKey !== null && adminAPIKey !== void 0; +} +/** Keeps origin-bound configuration with its owning provider during a client clone. */ +function prepareProviderClone(inherited, overrides) { + const inheritedProvider = inherited.provider; + const replacingProvider = overrides.credential ?? overrides.workloadIdentity; + const provider = overrides.provider ?? (replacingProvider ? void 0 : inheritedProvider); + if (provider !== inheritedProvider) { + delete inherited.baseURL; + delete inherited.organization; + delete inherited.project; + delete inherited.defaultHeaders; + delete inherited.defaultQuery; + delete inherited.fetchOptions; + delete inherited.fetch; + } + if (provider) { + delete inherited.apiKey; + delete inherited.adminAPIKey; + delete inherited.credential; + delete inherited.workloadIdentity; + delete inherited.x509Transport; + delete inherited.baseURL; + } + return provider; +} +/** Reconciles one client's credential and provider ownership before cloning its options. */ +function prepareX509ClientClone(inherited, overrides, credential, currentlyX509) { + const nextIdentity = hasOwn(overrides, "workloadIdentity") ? overrides.workloadIdentity : inherited.workloadIdentity; + const dropping = credential !== void 0 && (overridesOrdinaryAuthentication(overrides) && overrides.workloadIdentity === void 0 || overrides.provider !== void 0); + if (credential !== void 0 && hasOwn(overrides, "workloadIdentity")) delete inherited.x509Transport; + const inheritedCredential = credential !== void 0 && !dropping && overrides.credential === void 0 && !hasOwn(overrides, "workloadIdentity") && !hasOwn(overrides, "x509Transport") ? credential : void 0; + const nextCredential = overrides.credential === void 0 ? inheritedCredential : overrides.credential; + const nextX509 = nextCredential !== void 0 || !dropping && isX509WorkloadIdentity(nextIdentity); + if (currentlyX509 !== nextX509) { + delete inherited.fetch; + delete inherited.baseURL; + delete inherited.organization; + delete inherited.project; + delete inherited.defaultHeaders; + delete inherited.defaultQuery; + delete inherited.fetchOptions; + if (nextX509) inherited.apiKey = null; + else { + delete inherited.x509Transport; + if (dropping) delete inherited.workloadIdentity; + } + } + if (nextCredential !== void 0) { + delete inherited.apiKey; + delete inherited.adminAPIKey; + delete inherited.workloadIdentity; + delete inherited.x509Transport; + inherited.credential = nextCredential; + if (overrides.credential !== void 0) { + delete inherited.organization; + delete inherited.project; + delete inherited.defaultHeaders; + delete inherited.defaultQuery; + delete inherited.fetchOptions; + } + } + return { + credential: nextCredential, + provider: prepareProviderClone(inherited, overrides) + }; +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/uploads.mjs +const brand_privateStreamingFile = /* @__PURE__ */ Symbol("brand.privateStreamingFile"); +/** +* Wrap a stream as an uploadable file without reading it into memory. +* +* Unlike {@link toFile}, this helper does not create a web `File`, because the `File` constructor +* must consume all of its contents up front. The stream is instead encoded lazily as multipart +* form data when the request is sent. +* +* @param data Async-iterable or readable-stream chunks containing text, binary data, or blobs. +* @param name Non-empty logical/source filename. Ordinary uploads send only its basename; Skills +* uploads may preserve a validated relative path with normalized forward slashes. +* @param options Optional MIME type for the streaming file. +* @throws {TypeError} If `name` is empty or the content type contains control characters. +*/ +function toStreamingFile(data, name, options) { + if (typeof name !== "string" || !name) throw new TypeError("toStreamingFile requires a non-empty file name"); + const type = options?.type; + if (type) validateStreamingFileType(type); + return { + [brand_privateStreamingFile]: true, + data, + name, + ...type ? { type } : {} + }; +} +/** +* Verifies that the current runtime exposes the global `File` constructor. +* +* @throws {Error} If `File` is unavailable; older Node.js runtimes receive an +* additional upgrade or `node:buffer` compatibility suggestion. +*/ +const checkFileSupport = () => { + if (typeof File === "undefined") { + const { process } = globalThis; + const isOldNode = typeof process?.versions?.node === "string" && Number.parseInt(process.versions.node.split("."), 10) < 20; + throw new Error("`File` is not defined as a global, which is required for file uploads." + (isOldNode ? " Update to a supported Node.js LTS release, or set `globalThis.File` to `import('node:buffer').File`." : "")); + } +}; +/** +* Construct a `File` instance. This is used to ensure a helpful error is thrown +* for environments that don't define a global `File` yet. +* +* A missing filename becomes `unknown_file`. +*/ +function makeFile(fileBits, fileName, options) { + checkFileSupport(); + return new File(fileBits, fileName ?? "unknown_file", options); +} +/** +* Infers a filename from an object's `name`, `url`, `filename`, or `path` value. +* +* Directory components separated by either `/` or `\\` are discarded unless an +* explicitly supplied `name` or `filename` opts into preserving its path. Preserved +* paths must be safe and relative, and use forward slashes. Paths inferred from URLs and filesystem streams +* discard their directories. URL filenames decode valid UTF-8 percent escapes, +* except that ASCII control characters stay escaped for multipart compatibility. +* A basename stays encoded if decoding would introduce literal multipart escape sequences. +*/ +function getName(value, options) { + if (typeof value !== "object" || value === null) return; + const name = "name" in value ? value.name : void 0; + const explicitName = name && String(name) || "filename" in value && value.filename && String(value.filename); + if (explicitName) return options?.stripFilename === false ? normalizeFilenamePath(explicitName) : basename(explicitName); + const url = "url" in value && value.url && String(value.url); + if (url) try { + const filename = basename(new URL(url).pathname); + return filename === void 0 ? void 0 : basename(decodeURLFilename(filename)); + } catch { + return basename(url); + } + const path = "path" in value && value.path && String(value.path); + return path ? basename(path) : void 0; +} +function basename(value) { + return value.split(/[\\/]/).pop() || void 0; +} +function decodeURLFilename(filename) { + try { + const decodedFilename = decodeURIComponent(filename); + if (/%(?:0[AD]|22)/i.test(decodedFilename)) return filename; + return decodedFilename.replace(/[\u0000-\u001F\u007F]/gu, encodeURIComponent); + } catch { + return filename; + } +} +function normalizeFilenamePath(value) { + const normalized = value.replace(/\\/g, "/"); + if (normalized.startsWith("/") || /^[A-Za-z]:/.test(normalized) || normalized.split("/").includes("..")) throw new TypeError("Upload file name must be a safe relative path without parent directory segments"); + return normalized; +} +const arrayBufferByteLengthGetter$1 = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength")?.get; +/** Recognizes native ArrayBuffers across realms without trusting their prototype or string tag. */ +function isArrayBuffer(value) { + try { + return arrayBufferByteLengthGetter$1?.call(value) !== void 0; + } catch { + return false; + } +} +/** Identifies objects that expose a callable `Symbol.asyncIterator` method. */ +const isAsyncIterable = (value) => value != null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function"; +/** +* Converts a request to multipart form data when its body contains an upload. +* +* Uploads include files, blobs, responses, async iterables, readable +* streams, and {@link StreamingFile} values anywhere in a nested body. Bodies +* containing streaming values are encoded lazily; other uploads use `FormData`. +* Requests without uploads are returned unchanged. +*/ +const maybeMultipartFormRequestOptions = async (opts, fetch, formOptions) => { + if (!hasUploadableValue(opts.body)) return opts; + if (hasStreamingUploadableValue(opts.body)) return createStreamingFormRequestOptions(opts, formOptions); + return { + ...opts, + body: await createForm(opts.body, fetch, formOptions) + }; +}; +/** +* Encodes a request body as multipart form data even when no file is present. +* +* Streaming uploads produce a lazy multipart `ReadableStream` and an explicit +* boundary header; other values are materialized into platform `FormData`. +*/ +const multipartFormRequestOptions = async (opts, fetch, formOptions) => { + if (hasStreamingUploadableValue(opts.body)) return createStreamingFormRequestOptions(opts, formOptions); + return { + ...opts, + body: await createForm(opts.body, fetch, formOptions) + }; +}; +const supportsFormDataMap = /* @__PURE__ */ new WeakMap(); +/** +* node-fetch doesn't support the global FormData object in recent node versions. Instead of sending +* properly-encoded form data, it just stringifies the object, resulting in a request body of "[object FormData]". +* This function detects if the fetch function provided supports the global FormData object to avoid +* confusing error messages later on. +*/ +function supportsFormData(fetchObject) { + const fetch = typeof fetchObject === "function" ? fetchObject : fetchObject.fetch; + const cached = supportsFormDataMap.get(fetch); + if (cached) return cached; + const promise = (async () => { + try { + let FetchResponse; + if ("Response" in fetch) FetchResponse = fetch.Response; + else { + const response = await fetch("data:,"); + await response.arrayBuffer(); + FetchResponse = response.constructor; + } + const data = new FormData(); + if (data.toString() === await new FetchResponse(data).text()) return false; + return true; + } catch { + return true; + } + })(); + supportsFormDataMap.set(fetch, promise); + return promise; +} +/** +* Materializes an object into platform `FormData` after verifying fetch support. +* +* Strings, numbers, and booleans become text fields; responses, blobs, +* and async byte sources become file fields. Arrays and nested objects use +* bracketed field names, while `undefined` values are omitted. +* +* @throws {TypeError} If the fetch implementation cannot encode global +* `FormData`, a field is `null`, or a field has an unsupported value. +*/ +const createForm = async (body, fetch, options = {}) => { + if (!await supportsFormData(fetch)) throw new TypeError("The provided fetch function does not support file uploads with the current global FormData class."); + const form = new FormData(); + await Promise.all(Object.entries(body || {}).map(([key, value]) => addFormValue(form, key, value, options))); + return form; +}; +const isBlob = (value) => value instanceof Blob; +const isReadableStream = (value) => typeof value === "object" && value !== null && "getReader" in value && typeof value.getReader === "function"; +const isStreamingFile = (value) => typeof value === "object" && value !== null && brand_privateStreamingFile in value; +const isUploadable = (value) => typeof value === "object" && value !== null && (value instanceof Response || isAsyncIterable(value) || isReadableStream(value) || isStreamingFile(value) || isBlob(value)); +const hasStreamingUploadableValue = (value) => { + if (isStreamingFile(value) || isAsyncIterable(value) || isReadableStream(value)) return true; + if (Array.isArray(value)) return value.some(hasStreamingUploadableValue); + if (value && typeof value === "object" && !isBlob(value) && !(value instanceof Response)) { + for (const k of Object.keys(value)) if (hasStreamingUploadableValue(value[k])) return true; + } + return false; +}; +const hasUploadableValue = (value) => { + if (isUploadable(value)) return true; + if (Array.isArray(value)) return value.some(hasUploadableValue); + if (value && typeof value === "object") { + for (const k of Object.keys(value)) if (hasUploadableValue(value[k])) return true; + } + return false; +}; +const snapshotPreservedUploadEntries = (entries, filenames) => { + const snapshot = []; + for (const entry of entries) { + if (isUploadable(entry.value) && !filenames.has(entry.value)) filenames.set(entry.value, getStreamingFileName(entry.value, { stripFilenames: false })); + snapshot.push(entry); + } + return snapshot; +}; +const createStreamingFormRequestOptions = (opts, options = {}) => { + const entries = iterateFormEntries(opts.body); + const preservedFilenames = options.stripFilenames === false ? /* @__PURE__ */ new WeakMap() : void 0; + const multipartEntries = preservedFilenames ? snapshotPreservedUploadEntries(entries, preservedFilenames) : entries; + const boundary = `openai-${Math.random().toString(36).slice(2)}`; + const body = ReadableStreamFrom(iterateMultipartBody(multipartEntries, boundary, options, preservedFilenames)); + return { + ...opts, + body, + headers: buildHeaders([{ "content-type": `multipart/form-data; boundary=${boundary}` }, opts.headers]) + }; +}; +async function* iterateMultipartBody(entries, boundary, options, preservedFilenames) { + for await (const { key, value } of entries) { + if (isUploadable(value)) { + const filename = preservedFilenames?.get(value) ?? getStreamingFileName(value, options); + const type = getStreamingFileType(value); + yield encodeUTF8(`--${boundary}\r\n`); + yield encodeUTF8(`Content-Disposition: form-data; name="${escapeHeaderValue(key)}"; filename="${escapeHeaderValue(filename)}"\r\nContent-Type: ${type}\r\n\r\n`); + yield* iterateBytes(getStreamingFileData(value)); + } else { + yield encodeUTF8(`--${boundary}\r\n`); + yield encodeUTF8(`Content-Disposition: form-data; name="${escapeHeaderValue(key)}"\r\n\r\n${String(value)}`); + } + yield encodeUTF8("\r\n"); + } + yield encodeUTF8(`--${boundary}--\r\n`); +} +function* iterateFormEntries(body) { + if (!body || typeof body !== "object") return; + for (const [key, value] of Object.entries(body)) yield* iterateFormValue(key, value); +} +function* iterateFormValue(key, value) { + if (value === void 0) return; + if (value == null) throw new TypeError(`Received null for "${key}"; to pass null in FormData, you must use the string 'null'`); + if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || isUploadable(value)) yield { + key, + value + }; + else if (Array.isArray(value)) for (const entry of value) yield* iterateFormValue(key + "[]", entry); + else if (typeof value === "object") for (const [name, prop] of Object.entries(value)) yield* iterateFormValue(`${key}[${name}]`, prop); + else throw new TypeError(`Invalid value given to form, expected a string, number, boolean, object, Array, File or Blob but got ${value} instead`); +} +function getStreamingFileName(value, options) { + if (isStreamingFile(value)) { + const { name } = value; + if (typeof name !== "string" || !name) throw new TypeError("Streaming upload file name must be a non-empty string"); + return options.stripFilenames === false ? normalizeFilenamePath(name) : basename(name) ?? "unknown_file"; + } + return getName(value, { stripFilename: options.stripFilenames }) ?? "unknown_file"; +} +function getStreamingFileType(value) { + let type; + if (isStreamingFile(value) || isBlob(value)) ({type} = value); + else if (value instanceof Response) type = value.headers.get("content-type") ?? void 0; + return validateStreamingFileType(type || "application/octet-stream"); +} +function validateStreamingFileType(type) { + if (typeof type !== "string") throw new TypeError("Streaming upload content type must be a string"); + for (let index = 0; index < type.length; index += 1) { + const character = type.codePointAt(index) ?? 0; + if (character <= 31 || character === 127) throw new TypeError("Streaming upload content type must not contain control characters"); + } + return type; +} +function getStreamingFileData(value) { + if (isStreamingFile(value)) return value.data; + return value; +} +async function* iterateBytes(value) { + if (typeof value === "string") yield encodeUTF8(value); + else if (ArrayBuffer.isView(value)) yield new Uint8Array(value.buffer, value.byteOffset, value.byteLength); + else if (isArrayBuffer(value)) yield new Uint8Array(value); + else if (value instanceof Response) yield* iterateBytes(value.body || await value.blob()); + else if (value instanceof Blob) { + if (typeof value.stream === "function") yield* iterateBytes(value.stream()); + else yield new Uint8Array(await value.arrayBuffer()); + } else if (isReadableStream(value)) for await (const chunk of ReadableStreamToAsyncIterable(value)) yield* iterateBytes(chunk); + else if (isAsyncIterable(value)) for await (const chunk of value) yield* iterateBytes(chunk); + else throw new TypeError(`Invalid streaming file chunk: ${String(value)}`); +} +function escapeHeaderValue(value) { + return Array.from(value, (character) => { + const codePoint = character.codePointAt(0) ?? 0; + return codePoint <= 31 || codePoint === 127 || character === "\"" || character === "\\" ? encodeURIComponent(character) : character; + }).join(""); +} +const addFormValue = async (form, key, value, options) => { + if (value === void 0) return; + if (value == null) throw new TypeError(`Received null for "${key}"; to pass null in FormData, you must use the string 'null'`); + if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") form.append(key, String(value)); + else if (value instanceof Response) { + const blob = await value.blob(); + form.append(key, makeFile([blob], getName(value, { stripFilename: options.stripFilenames }), { type: blob.type })); + } else if (isAsyncIterable(value)) form.append(key, makeFile([await new Response(ReadableStreamFrom(value)).blob()], getName(value, { stripFilename: options.stripFilenames }))); + else if (isBlob(value)) { + const filename = getName(value, { stripFilename: options.stripFilenames }); + if (filename === void 0) form.append(key, value); + else form.append(key, value, filename); + } else if (Array.isArray(value)) { + const entries = await Promise.all(value.map(async (entry) => { + const entryForm = new FormData(); + await addFormValue(entryForm, key + "[]", entry, options); + return entryForm; + })); + for (const entryForm of entries) { + if (!entryForm) continue; + for (const [entryKey, entryValue] of entryForm.entries()) form.append(entryKey, entryValue); + } + } else if (typeof value === "object") await Promise.all(Object.entries(value).map(([name, prop]) => addFormValue(form, `${key}[${name}]`, prop, options))); + else throw new TypeError(`Invalid value given to form, expected a string, number, boolean, object, Array, File or Blob but got ${value} instead`); +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/to-file.mjs +/** +* This check adds the arrayBuffer() method type because it is available and used at runtime +*/ +const isBlobLike = (value) => value != null && typeof value === "object" && typeof value.size === "number" && typeof value.type === "string" && typeof value.text === "function" && typeof value.slice === "function" && typeof value.arrayBuffer === "function"; +/** +* This check adds the arrayBuffer() method type because it is available and used at runtime +*/ +const isFileLike = (value) => value != null && typeof value === "object" && typeof value.name === "string" && typeof value.lastModified === "number" && isBlobLike(value); +const isResponseLike = (value) => value != null && typeof value === "object" && typeof value.url === "string" && typeof value.blob === "function"; +const hasFilePropertyOverrides = (value, options) => options?.type != null && options.type !== value.type || options?.lastModified != null && options.lastModified !== value.lastModified || options?.endings != null; +const canReuseNativeFile = (value, name, options) => (name == null || name === value.name) && !hasFilePropertyOverrides(value, options); +/** +* Buffers compatible content into a native {@link File} for an SDK upload. +* +* Existing native `File` objects are returned unchanged when their effective +* filename and metadata are unchanged. Renamed native files reuse the original +* file contents without buffering and retain their MIME type and modification +* time unless explicitly overridden. Other filenames are inferred from response +* URLs or input metadata when omitted or null, falling back to `unknown_file`. +* An explicit empty filename is preserved. Responses, +* native or compatible `Blob` values, and compatible non-native files supply +* their MIME type unless `options.type` provides an explicit override. +* +* @param value An existing file, response, binary buffer, Blob-like object, async +* stream of file parts, or a promise resolving to one of those values. +* @param name Optional filename overriding inferred metadata or an existing filename. +* @param options Optional file metadata, including MIME type and modification time. +* @returns A native `File` containing the complete buffered input. +* @throws {Error} If the runtime lacks a global `File` constructor or the input +* cannot be converted into file contents. +*/ +async function toFile(value, name, options) { + checkFileSupport(); + value = await value; + if (isFileLike(value)) { + const fileOptions = { + ...options, + type: options?.type ?? value.type, + lastModified: options?.lastModified ?? value.lastModified + }; + if (value instanceof File) { + if (canReuseNativeFile(value, name, options)) return value; + return makeFile([value], name ?? value.name, fileOptions); + } + return makeFile([await value.arrayBuffer()], name ?? value.name, fileOptions); + } + if (isResponseLike(value)) { + const blob = await value.blob(); + name ?? (name = getName(value)); + const responseOptions = options?.type === void 0 && blob.type ? { + ...options, + type: blob.type + } : options; + return makeFile(await getBytes(blob), name, responseOptions); + } + const parts = await getBytes(value); + name ?? (name = getName(value)); + if (options?.type === void 0) { + const typedPart = parts.find((part) => typeof part === "object" && "type" in part && !!part.type); + if (typedPart) options = { + ...options, + type: typedPart.type + }; + } + return makeFile(parts, name, options); +} +async function getBytes(value) { + const parts = []; + if (typeof value === "string" || ArrayBuffer.isView(value) || isArrayBuffer(value)) parts.push(value); + else if (isBlobLike(value)) parts.push(value instanceof Blob ? value : new Blob([await value.arrayBuffer()], { type: value.type })); + else if (isAsyncIterable(value)) for await (const chunk of value) parts.push(...await getBytes(chunk)); + else { + const constructor = value?.constructor?.name; + throw new Error(`Unexpected data type: ${typeof value}${constructor ? `; constructor: ${constructor}` : ""}${propsForError(value)}`); + } + return parts; +} +function propsForError(value) { + if (typeof value !== "object" || value === null) return ""; + return `; props: [${Object.getOwnPropertyNames(value).map((p) => `"${p}"`).join(", ")}]`; +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/core/resource.mjs +var APIResource = class { + constructor(client) { + this._client = client; + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/utils/path.mjs +/** +* Percent-encodes a single URI path parameter while preserving RFC 3986 path characters. +* +* Slash, question-mark, and hash characters are encoded so an interpolated value +* cannot create another path segment, query string, or fragment. +* +* Taken from https://datatracker.ietf.org/doc/html/rfc3986#section-3.3: +* > unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~" +* > sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "=" +* > pchar = unreserved / pct-encoded / sub-delims / ":" / "@" +*/ +function encodeURIPath(str) { + return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent); +} +const EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null)); +/** +* Creates a template tag that safely interpolates SDK resource paths. +* +* Path values use the supplied encoder; values after a literal `?` or `#` use +* `encodeURIComponent`. Nullish values, ordinary objects, and literal or +* percent-encoded `.`/`..` path segments are rejected with an SDK error. +*/ +const createPathTagFunction = (pathEncoder = encodeURIPath) => function path(statics, ...params) { + if (statics.length === 1) return statics[0]; + let postPath = false; + const invalidSegments = []; + let path = ""; + for (let index = 0; index < statics.length; index += 1) if (index in statics) { + const currentValue = statics[index]; + if (/[?#]/.test(currentValue)) postPath = true; + const value = params[index]; + let encoded = (postPath ? encodeURIComponent : pathEncoder)("" + value); + if (index !== params.length && (value == null || typeof value === "object" && value.toString === Object.getPrototypeOf(Object.getPrototypeOf(value.hasOwnProperty ?? EMPTY) ?? EMPTY)?.toString)) { + encoded = value + ""; + invalidSegments.push({ + start: path.length + currentValue.length, + length: encoded.length, + error: `Value of type ${Object.prototype.toString.call(value).slice(8, -1)} is not a valid path parameter` + }); + } + path += currentValue + (index === params.length ? "" : encoded); + } + const pathOnly = path.split(/[?#]/, 1)[0]; + const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi; + let match; + while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) invalidSegments.push({ + start: match.index, + length: match[0].length, + error: `Value "${match[0]}" can't be safely passed as a path parameter` + }); + invalidSegments.sort((a, b) => a.start - b.start); + if (invalidSegments.length > 0) { + let lastEnd = 0; + let underline = ""; + for (const segment of invalidSegments) { + const spaces = " ".repeat(segment.start - lastEnd); + const arrows = "^".repeat(segment.length); + lastEnd = segment.start + segment.length; + underline += spaces + arrows; + } + throw new OpenAIError(`Path parameters result in path with invalid segments:\n${invalidSegments.map((e) => e.error).join("\n")}\n${path}\n${underline}`); + } + return path; +}; +/** +* Template tag that encodes resource-path parameters and rejects traversal segments. +* +* Values inside query strings and fragments are encoded as URI components. +*/ +const path = /* @__PURE__ */ createPathTagFunction(encodeURIPath); +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/chat/completions/messages.mjs +function resolveResourceRequestOptions$105(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$57 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$57(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$57.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$57.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +/** +* Given a list of messages comprising a conversation, the model will return a response. +*/ +var Messages$1 = class extends APIResource { + list(completionID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$57(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/chat/completions/${completionID}/messages`, CursorPage, resolveResourceRequestOptions$105(options, (options) => ({ + query, + ...options, + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/chat-completions/streaming.mjs +function normalizeChatCompletionChunk(chunk) { + if (!Array.isArray(chunk?.choices)) return chunk; + return { + ...chunk, + choices: chunk.choices.map((choice) => ({ + ...choice, + finish_reason: choice.finish_reason ?? null + })) + }; +} +function normalizeChatCompletionStream(stream) { + const iterator = stream[Symbol.asyncIterator].bind(stream); + stream[Symbol.asyncIterator] = async function* normalizedChunks() { + const source = { [Symbol.asyncIterator]: iterator }; + for await (const chunk of source) yield normalizeChatCompletionChunk(chunk); + }; + return stream; +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/parser.mjs +/** Returns whether an optional chat completion tool contains a function-tool definition. */ +function isChatCompletionFunctionTool(tool) { + return tool !== void 0 && "function" in tool && tool.function !== void 0; +} +/** +* Whether the given format was built by an SDK helper (e.g. `zodResponseFormat()`) +* and therefore carries its own `$parseRaw` callback. +* +* Prefer {@link isParseableResponseFormat} when deciding whether output should be +* parsed at all; raw `{ type: 'json_schema' }` formats are parsed too, but are not +* branded. +*/ +function isAutoParsableResponseFormat(response_format) { + return response_format?.["$brand"] === "auto-parseable-response-format"; +} +/** +* The canonical definition of an auto-parseable response format, covering both the +* Chat Completions `response_format` and the Responses `text.format` shapes. +* +* Every gate that decides whether output should be parsed must go through this +* predicate so the runtime, the streaming events and +* {@link ExtractParsedContentFromParams} cannot drift apart. +*/ +function isParseableResponseFormat(format) { + return isAutoParsableResponseFormat(format) || format?.type === "json_schema"; +} +/** +* The canonical parser for auto-parseable response formats. This is the only place +* that chooses between an existing `$parseRaw` callback and generic `JSON.parse()`. +* +* Returns `null` for formats that are not auto-parseable. +*/ +function parseResponseFormatContent(format, content) { + if (!isParseableResponseFormat(format)) return null; + if (typeof format === "object" && format !== null && "$parseRaw" in format && typeof format.$parseRaw === "function") return format.$parseRaw(content); + try { + return JSON.parse(content); + } catch (error) { + if (error instanceof SyntaxError) throw new SyntaxError("Error reading response: invalid structured output JSON."); + throw error; + } +} +/** Returns whether a Chat Completions tool carries the SDK's argument-parser marker. */ +function isAutoParsableTool$1(tool) { + return tool?.["$brand"] === "auto-parseable-tool"; +} +/** +* Adds parsed-content fields to a chat completion, invoking parsers only when the +* request includes an auto-parseable response format or a strict function tool. +*/ +function maybeParseChatCompletion(completion, params) { + if (!params || !hasAutoParseableInput$1(params)) return { + ...completion, + choices: completion.choices.map((choice) => ({ + ...choice, + message: { + ...choice.message, + parsed: null, + ...choice.message.tool_calls ? { tool_calls: choice.message.tool_calls } : void 0 + } + })) + }; + return parseChatCompletion(completion, params); +} +/** +* Parses structured assistant content and strict function-tool arguments. +* +* @throws {LengthFinishReasonError} If generation stopped at its token limit. +* @throws {ContentFilterFinishReasonError} If generation stopped because of content filtering. +* @throws {OpenAIError} If the completion contains an unsupported tool-call type. +*/ +function parseChatCompletion(completion, params) { + const choices = completion.choices.map((choice) => { + if (choice.finish_reason === "length") throw new LengthFinishReasonError(); + if (choice.finish_reason === "content_filter") throw new ContentFilterFinishReasonError(); + return { + ...choice, + message: { + ...choice.message, + ...choice.message.tool_calls ? { tool_calls: choice.message.tool_calls?.map((toolCall) => parseToolCall$1(params, toolCall)) ?? void 0 } : void 0, + parsed: choice.message.content !== null && choice.message.content !== void 0 && !choice.message.refusal && (choice.message.content !== "" || !choice.message.tool_calls?.length && !choice.message.function_call) ? parseResponseFormat(params, choice.message.content) : null + } + }; + }); + return { + ...completion, + choices + }; +} +function parseResponseFormat(params, content) { + return parseResponseFormatContent(params.response_format, content); +} +function parseToolCall$1(params, toolCall) { + if (toolCall.type === "custom") return toolCall; + if (toolCall.type !== "function") { + const unsupportedType = toolCall.type; + throw new OpenAIError(`Currently only \`function\` and \`custom\` tool calls are supported; Received \`${unsupportedType}\``); + } + const inputTool = params.tools?.find((inputTool) => isChatCompletionFunctionTool(inputTool) && inputTool.function?.name === toolCall.function.name); + let parsedArguments = null; + if (isAutoParsableTool$1(inputTool)) parsedArguments = inputTool.$parseRaw(toolCall.function.arguments); + else if (inputTool?.function.strict) parsedArguments = parseResponseFormatContent({ + type: "json_schema", + $parseRaw: void 0 + }, toolCall.function.arguments); + return { + ...toolCall, + function: { + ...toolCall.function, + parsed_arguments: parsedArguments + } + }; +} +/** Returns whether a tool call matches a strict or auto-parseable function in the request. */ +function shouldParseToolCall(params, toolCall) { + if (!params || !("tools" in params) || !params.tools || toolCall.type !== "function") return false; + const inputTool = params.tools?.find((inputTool) => isChatCompletionFunctionTool(inputTool) && inputTool.function?.name === toolCall.function?.name); + return isChatCompletionFunctionTool(inputTool) && (isAutoParsableTool$1(inputTool) || inputTool?.function.strict || false); +} +/** Returns whether the request contains an auto-parseable response format or strict function tool. */ +function hasAutoParseableInput$1(params) { + if (isParseableResponseFormat(params.response_format)) return true; + return params.tools?.some((t) => isAutoParsableTool$1(t) || t.type === "function" && t.function.strict === true) ?? false; +} +/** +* Validates strict function tools while preserving supported custom tools. +* +* @throws {OpenAIError} If a tool is unsupported or a function is missing `strict: true`. +*/ +function validateInputTools(tools) { + for (const tool of tools ?? []) { + if (tool.type === "custom") continue; + if (tool.type !== "function") { + const unsupportedType = tool.type; + throw new OpenAIError(`Currently only \`function\` and \`custom\` tool types are supported; Received \`${unsupportedType}\``); + } + if (tool.function.strict !== true) throw new OpenAIError(`The \`${tool.function.name}\` tool is not marked with \`strict: true\`. Only strict function tools can be auto-parsed`); + } +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/chatCompletionUtils.mjs +/** Returns whether a conversation message was produced by the assistant. */ +const isAssistantMessage = (message) => message?.role === "assistant"; +/** Returns whether a conversation message contains the result of a tool call. */ +const isToolMessage = (message) => message?.role === "tool"; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/EventStream.mjs +var _EventStream_instances; +var _EventStream_connectedPromise; +var _EventStream_resolveConnectedPromise; +var _EventStream_rejectConnectedPromise; +var _EventStream_endPromise; +var _EventStream_resolveEndPromise; +var _EventStream_rejectEndPromise; +var _EventStream_listeners; +var _EventStream_abortListeners; +var _EventStream_emittedListenerRegistrations; +var _EventStream_pendingListenerCleanup; +var _EventStream_pendingBufferedEventChecks; +var _EventStream_listenerDispatchDepth; +var _EventStream_ended; +var _EventStream_errored; +var _EventStream_aborted; +var _EventStream_catchingPromiseCreated; +var _EventStream_terminalFailure; +var _EventStream_abortFromSignal; +var _EventStream_removeAbortListeners; +var _EventStream_onceForEmitted; +var _EventStream_removeEmittedListener; +var _EventStream_cleanupEmittedListeners; +var _EventStream_handleError; +var _EventStream_settleTerminalEvent; +const MAX_BUFFERED_ITERATOR_EVENTS = 4096; +const MAX_BUFFERED_ITERATOR_BYTES = 8388608; +const MAX_INSPECTABLE_TYPED_ARRAY_ELEMENTS = 4096; +const MAX_BUFFERED_EVENT_DEPTH = 256; +const bufferedJSONStringify = JSON.stringify; +const bufferedJSONParse = JSON.parse; +const sdkOwnedBufferedEventArguments = /* @__PURE__ */ new WeakSet(); +const typedArrayBufferGetter = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), "buffer")?.get; +const typedArrayLengthGetter = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), "length")?.get; +const dataViewBufferGetter = Object.getOwnPropertyDescriptor(DataView.prototype, "buffer")?.get; +const symbolDescriptionGetter = Object.getOwnPropertyDescriptor(Symbol.prototype, "description")?.get; +const dateTimestampGetter = Date.prototype.getTime; +const arrayBufferByteLengthGetter = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength")?.get; +const sharedArrayBufferByteLengthGetter = typeof SharedArrayBuffer === "function" ? Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, "byteLength")?.get : void 0; +const errorStackDescriptor = Object.getOwnPropertyDescriptor(/* @__PURE__ */ new Error("native stack descriptor"), "stack"); +const functionToString = Function.prototype.toString; +const objectToString = Object.prototype.toString; +const errorBrandDescriptor = Object.getOwnPropertyDescriptor(Error, "isError"); +const nativeErrorBrand = errorBrandDescriptor && "value" in errorBrandDescriptor && typeof errorBrandDescriptor.value === "function" ? errorBrandDescriptor.value : void 0; +const nativeErrorConstructorSource = functionToString.call(Error); +const nativeDateConstructorSource = functionToString.call(Date); +const nativeFunctionConstructorSource = functionToString.call(Function); +const trustedIntrinsicPrototypes = /* @__PURE__ */ new Set([ + APIConnectionError.prototype, + APIConnectionTimeoutError.prototype, + APIError.prototype, + OpenAIError.prototype, + APIUserAbortError.prototype, + AuthenticationError.prototype, + BadRequestError.prototype, + ConflictError.prototype, + ContentFilterFinishReasonError.prototype, + InternalServerError.prototype, + InvalidWebhookSignatureError.prototype, + LengthFinishReasonError.prototype, + NotFoundError.prototype, + OAuthError.prototype, + PermissionDeniedError.prototype, + RateLimitError.prototype, + SubjectTokenProviderError.prototype, + UnprocessableEntityError.prototype +]); +const trustedNativeConstructorSources = /* @__PURE__ */ new Set(); +const canonicalIntrinsicDescriptors = /* @__PURE__ */ new Map(); +const foreignErrorStackDescriptors = /* @__PURE__ */ new WeakMap(); +function captureNativeProxyDetector() { + if (typeof process === "undefined") return; + try { + const loader = Object.getOwnPropertyDescriptor(process, "getBuiltinModule"); + if (!loader || !("value" in loader) || typeof loader.value !== "function") return; + const util = Reflect.apply(loader.value, process, ["node:util"]); + if (typeof util !== "object" || util === null) return; + const types = Object.getOwnPropertyDescriptor(util, "types"); + if (!types || !("value" in types) || typeof types.value !== "object" || types.value === null) return; + const detector = Object.getOwnPropertyDescriptor(types.value, "isProxy"); + if (!detector || !("value" in detector) || typeof detector.value !== "function") return; + return detector.value; + } catch { + return; + } +} +const nativeProxyDetector = captureNativeProxyDetector(); +function rememberTrustedIntrinsic(constructor) { + if (typeof constructor !== "function") return; + const prototypeDescriptor = Object.getOwnPropertyDescriptor(constructor, "prototype"); + if (!prototypeDescriptor || !("value" in prototypeDescriptor) || typeof prototypeDescriptor.value !== "object" && typeof prototypeDescriptor.value !== "function") return; + trustedIntrinsicPrototypes.add(prototypeDescriptor.value); + const source = functionToString.call(constructor); + if (/^function [A-Za-z_$][\w$]*\(\) \{ \[native code\] \}$/u.test(source) && prototypeDescriptor.configurable === false && prototypeDescriptor.writable === false) { + trustedNativeConstructorSources.add(source); + const descriptors = /* @__PURE__ */ new Map(); + for (const key of Reflect.ownKeys(prototypeDescriptor.value)) { + const descriptor = Object.getOwnPropertyDescriptor(prototypeDescriptor.value, key); + if (descriptor) descriptors.set(key, descriptor); + } + canonicalIntrinsicDescriptors.set(source, descriptors); + } +} +for (const constructor of [ + Object, + Function, + Array, + Date, + Map, + Set, + ArrayBuffer, + DataView, + Error, + EvalError, + RangeError, + ReferenceError, + SyntaxError, + TypeError, + URIError, + Uint8Array, + Uint8ClampedArray, + Uint16Array, + Uint32Array, + Int8Array, + Int16Array, + Int32Array, + Float32Array, + Float64Array +]) rememberTrustedIntrinsic(constructor); +for (const name of [ + "SharedArrayBuffer", + "AggregateError", + "Float16Array", + "BigInt64Array", + "BigUint64Array", + "Blob", + "File", + "Headers" +]) { + const descriptor = Object.getOwnPropertyDescriptor(globalThis, name); + if (descriptor && "value" in descriptor) rememberTrustedIntrinsic(descriptor.value); +} +const typedArrayConstructorDescriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), "constructor"); +if (typedArrayConstructorDescriptor && "value" in typedArrayConstructorDescriptor) rememberTrustedIntrinsic(typedArrayConstructorDescriptor.value); +if (typeof Buffer === "function") rememberTrustedIntrinsic(Buffer); +const blobInternalHandlePrototype = (() => { + if (typeof Blob !== "function") return; + try { + const blob = new Blob([]); + for (const key of Object.getOwnPropertySymbols(blob)) { + const descriptor = Object.getOwnPropertyDescriptor(blob, key); + if (descriptor && "value" in descriptor && typeof descriptor.value === "object" && descriptor.value) return Object.getPrototypeOf(descriptor.value); + } + } catch { + return; + } +})(); +const mapEntries = Map.prototype.entries; +const setValues = Set.prototype.values; +const headersEntriesDescriptor = typeof Headers === "function" ? Object.getOwnPropertyDescriptor(Headers.prototype, "entries") : void 0; +const headersEntries = headersEntriesDescriptor && "value" in headersEntriesDescriptor && typeof headersEntriesDescriptor.value === "function" ? headersEntriesDescriptor.value : void 0; +const retainedStorageBrands = /* @__PURE__ */ new Set([ + "ArrayBuffer", + "SharedArrayBuffer", + "Blob", + "File", + "Map", + "Date", + "Set", + "Headers" +]); +function getTrustedForeignIntrinsic(prototype) { + const descriptor = Object.getOwnPropertyDescriptor(prototype, "constructor"); + if (!descriptor || !("value" in descriptor) || typeof descriptor.value !== "function") return; + const constructor = descriptor.value; + const source = functionToString.call(constructor); + const descriptors = canonicalIntrinsicDescriptors.get(source); + if (!trustedNativeConstructorSources.has(source) || !descriptors) return; + const constructorPrototype = Object.getOwnPropertyDescriptor(constructor, "prototype"); + if (!constructorPrototype || !("value" in constructorPrototype) || constructorPrototype.value !== prototype || constructorPrototype.configurable !== false || constructorPrototype.writable !== false) return; + return { + constructor, + descriptors, + functionPrototype: Object.getPrototypeOf(constructor) + }; +} +function isTrustedIntrinsicPrototype(prototype) { + return trustedIntrinsicPrototypes.has(prototype) || getTrustedForeignIntrinsic(prototype) !== void 0; +} +function isCanonicalIntrinsicFunction(value, canonical, functionPrototype) { + if (canonical === void 0) return value === void 0; + if (typeof value !== "function" || typeof canonical !== "function") return false; + const source = functionToString.call(canonical); + if (functionToString.call(value) !== source) return false; + const actualFunctionPrototype = Object.getPrototypeOf(value); + if (actualFunctionPrototype === functionPrototype) return true; + if (!/^function [A-Za-z_$][\w$]*\(\) \{ \[native code\] \}$/u.test(source)) return false; + const intrinsic = getTrustedForeignIntrinsic(actualFunctionPrototype); + return intrinsic !== void 0 && functionToString.call(intrinsic.constructor) === nativeFunctionConstructorSource; +} +function isCanonicalIntrinsicDescriptor(descriptor, canonical, functionPrototype) { + if (!canonical || descriptor.configurable !== canonical.configurable || descriptor.enumerable !== canonical.enumerable || "value" in descriptor !== "value" in canonical) return false; + if ("value" in descriptor && "value" in canonical) { + if (descriptor.writable !== canonical.writable) return false; + if (typeof canonical.value === "function") return isCanonicalIntrinsicFunction(descriptor.value, canonical.value, functionPrototype); + if (canonical.value !== null && typeof canonical.value === "object") return false; + return Object.is(descriptor.value, canonical.value); + } + return isCanonicalIntrinsicFunction(descriptor.get, canonical.get, functionPrototype) && isCanonicalIntrinsicFunction(descriptor.set, canonical.set, functionPrototype); +} +function hasNativeErrorBrand(current) { + if (nativeErrorBrand) return nativeErrorBrand.call(Error, current); + let prototype = current; + for (let depth = 0; prototype !== null && depth < MAX_BUFFERED_EVENT_DEPTH; depth += 1) { + if (Object.getOwnPropertyDescriptor(prototype, Symbol.toStringTag)) return false; + prototype = Object.getPrototypeOf(prototype); + } + return prototype === null && objectToString.call(current) === "[object Error]"; +} +function getVerifiedForeignErrorConstructor(current, stackDescriptor) { + if (typeof stackDescriptor.get !== "function" || typeof stackDescriptor.set !== "function") return; + let prototype = Object.getPrototypeOf(current); + for (let depth = 0; prototype !== null && depth < MAX_BUFFERED_EVENT_DEPTH; depth += 1) { + const descriptor = Object.getOwnPropertyDescriptor(prototype, "constructor"); + if (descriptor && "value" in descriptor && typeof descriptor.value === "function") { + const constructor = descriptor.value; + if (functionToString.call(constructor) === nativeErrorConstructorSource && isTrustedIntrinsicPrototype(prototype)) { + const functionPrototype = Object.getPrototypeOf(constructor); + if (Object.getPrototypeOf(stackDescriptor.get) === functionPrototype && Object.getPrototypeOf(stackDescriptor.set) === functionPrototype) return { + constructor, + prototype + }; + return; + } + } + prototype = Object.getPrototypeOf(prototype); + } +} +function isTrustedNativeErrorStack(current, descriptor) { + if (!hasNativeErrorBrand(current)) return false; + if (errorStackDescriptor && !("value" in errorStackDescriptor) && typeof errorStackDescriptor.get === "function" && Object.prototype.isPrototypeOf.call(Error.prototype, current) && descriptor.get === errorStackDescriptor.get && descriptor.set === errorStackDescriptor.set) return true; + const verified = getVerifiedForeignErrorConstructor(current, descriptor); + if (!verified) return false; + let canonicalDescriptor = foreignErrorStackDescriptors.get(verified.prototype); + if (!canonicalDescriptor) { + const canonical = Reflect.construct(verified.constructor, []); + if (typeof canonical !== "object" || canonical === null || !hasNativeErrorBrand(canonical) || Object.getPrototypeOf(canonical) !== verified.prototype) return false; + canonicalDescriptor = Object.getOwnPropertyDescriptor(canonical, "stack"); + if (!canonicalDescriptor || "value" in canonicalDescriptor || typeof canonicalDescriptor.get !== "function" || typeof canonicalDescriptor.set !== "function") return false; + foreignErrorStackDescriptors.set(verified.prototype, canonicalDescriptor); + } + return descriptor.get === canonicalDescriptor.get && descriptor.set === canonicalDescriptor.set; +} +function createEventQueue() { + let entries = []; + let head = 0; + return { + get length() { + return entries.length - head; + }, + enqueue(value) { + entries.push(value); + }, + dequeue() { + if (head === entries.length) return; + const value = entries[head]; + entries[head] = void 0; + head += 1; + if (head === entries.length) { + entries = []; + head = 0; + } else if (head >= 1024 && head * 2 >= entries.length) { + entries = entries.slice(head); + head = 0; + } + return value; + }, + clear() { + entries = []; + head = 0; + } + }; +} +function getRetainedStorageBrand(current) { + let prototype = Object.getPrototypeOf(current); + for (let depth = 0; prototype !== null && depth < MAX_BUFFERED_EVENT_DEPTH; depth += 1) { + if (prototype === Date.prototype) return "Date"; + if (!trustedIntrinsicPrototypes.has(prototype)) { + const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor"); + if (constructor && "value" in constructor && typeof constructor.value === "function" && functionToString.call(constructor.value) === nativeDateConstructorSource && getTrustedForeignIntrinsic(prototype)) return "Date"; + } + const descriptor = Object.getOwnPropertyDescriptor(prototype, Symbol.toStringTag); + if (descriptor && "value" in descriptor && typeof descriptor.value === "string" && retainedStorageBrands.has(descriptor.value)) return descriptor.value; + prototype = Object.getPrototypeOf(prototype); + } +} +function estimateRetainedBufferBytes(current, visit, depth) { + if (ArrayBuffer.isView(current)) { + let buffer; + let kind = "typed-array"; + try { + buffer = typedArrayBufferGetter?.call(current); + } catch { + kind = "data-view"; + buffer = dataViewBufferGetter?.call(current); + } + if (typeof buffer !== "object" || buffer === null) return { + bytes: Number.POSITIVE_INFINITY, + kind + }; + visit(buffer, depth + 1); + return { + bytes: 0, + kind + }; + } + const brand = getRetainedStorageBrand(current); + if (!brand) return; + let getter; + const kind = "buffer"; + switch (brand) { + case "ArrayBuffer": + getter = arrayBufferByteLengthGetter; + break; + case "SharedArrayBuffer": + getter = sharedArrayBufferByteLengthGetter; + break; + case "Blob": + case "File": return { + bytes: Number.POSITIVE_INFINITY, + kind: "blob" + }; + case "Map": return { + bytes: 0, + kind: "map" + }; + case "Date": + Reflect.apply(dateTimestampGetter, current, []); + return { + bytes: 8, + kind: "date" + }; + case "Set": return { + bytes: 0, + kind: "set" + }; + case "Headers": return { + bytes: 0, + kind: "headers" + }; + default: return; + } + const bytes = getter?.call(current); + return { + bytes: typeof bytes === "number" && Number.isSafeInteger(bytes) && bytes >= 0 ? bytes : Number.POSITIVE_INFINITY, + kind + }; +} +function visitHiddenEventValues(current, kind, visit) { + if (kind === "map") { + for (const [key, entry] of mapEntries.call(current)) if (!visit(key, 8) || !visit(entry, 8)) return false; + } + if (kind === "set") { + for (const entry of setValues.call(current)) if (!visit(entry, 8)) return false; + } + if (kind === "headers") { + if (!headersEntries) return false; + for (const [name, value] of headersEntries.call(current)) if (!visit(name, 8) || !visit(value, 8)) return false; + } + return true; +} +function getInspectableEventKeys(current, kind, availableBytes) { + if (Array.isArray(current)) { + const descriptor = Object.getOwnPropertyDescriptor(current, "length"); + const length = descriptor && "value" in descriptor ? descriptor.value : void 0; + if (typeof length !== "number" || !Number.isSafeInteger(length) || length < 0 || length > Math.floor(availableBytes / 16)) return; + } + if (kind !== "typed-array") return Reflect.ownKeys(current); + const length = typedArrayLengthGetter?.call(current); + if (typeof length !== "number" || !Number.isSafeInteger(length) || length < 0 || length > MAX_INSPECTABLE_TYPED_ARRAY_ELEMENTS) return; + return Reflect.ownKeys(current).filter((key) => { + if (typeof key !== "string") return true; + const index = Number(key); + return !Number.isInteger(index) || index < 0 || index >= length || String(index) !== key; + }); +} +function visitInspectableEventProperties(current, kind, depth, availableBytes, charge, visit) { + const keys = getInspectableEventKeys(current, kind, availableBytes()); + if (keys === void 0) return false; + for (const key of keys) { + if (!charge(typeof key === "string" ? key.length * 2 + 8 : 8)) return false; + if (typeof key === "symbol") visit(key, depth + 1); + const descriptor = Object.getOwnPropertyDescriptor(current, key); + if (!descriptor) return false; + if (!("value" in descriptor)) { + if (key === "stack" && isTrustedNativeErrorStack(current, descriptor)) continue; + return false; + } + visit(descriptor.value, depth + 1, kind === "blob"); + } + return true; +} +function visitRetainedEventPrototypes(current, depth, isBlobInternalHandle, visited, availableBytes, charge, visit, retainPrototype) { + let prototype = Object.getPrototypeOf(current); + for (let prototypeDepth = depth + 1; prototype !== null; prototypeDepth += 1) { + if (prototypeDepth >= MAX_BUFFERED_EVENT_DEPTH) return false; + if (trustedIntrinsicPrototypes.has(prototype) || isBlobInternalHandle && prototype === blobInternalHandlePrototype) return true; + if (visited.has(prototype)) { + visit(prototype, prototypeDepth); + return availableBytes() >= 0; + } + visited.add(prototype); + const retainedPrototype = prototype; + if (!retainPrototype(retainedPrototype, () => { + if (!charge(16)) return false; + const intrinsic = getTrustedForeignIntrinsic(retainedPrototype); + if (!intrinsic) return visitInspectableEventProperties(retainedPrototype, void 0, prototypeDepth, availableBytes, charge, visit); + for (const key of Reflect.ownKeys(retainedPrototype)) { + const descriptor = Object.getOwnPropertyDescriptor(retainedPrototype, key); + if (!descriptor) return false; + if (isCanonicalIntrinsicDescriptor(descriptor, intrinsic.descriptors.get(key), intrinsic.functionPrototype)) continue; + if (!charge(typeof key === "string" ? key.length * 2 + 8 : 8) || !("value" in descriptor)) return false; + if (typeof key === "symbol") visit(key, prototypeDepth + 1); + visit(descriptor.value, prototypeDepth + 1); + } + return availableBytes() >= 0; + })) return false; + prototype = Object.getPrototypeOf(retainedPrototype); + } + return true; +} +const BUFFERED_LEDGER_ENTRY_BYTES = 32; +const BUFFERED_LEDGER_NODE_BYTES = 32; +const BUFFERED_LEDGER_EDGE_BYTES = 8; +const BUFFERED_LEDGER_OWNER_BYTES = 16; +const MAX_BUFFERED_LEDGER_RECONCILIATION_WORK = 131072; +function inspectBufferedEventGraph(value, remainingBytes) { + let bytes = 0; + let scalarBytes = 0; + const visited = /* @__PURE__ */ new WeakSet(); + const visitedSymbols = /* @__PURE__ */ new Set(); + const roots = /* @__PURE__ */ new Set(); + const nodes = /* @__PURE__ */ new Map(); + let activeNode; + const availableBytes = () => remainingBytes - bytes; + const charge = (amount) => { + if (!Number.isSafeInteger(amount) || amount < 0) { + bytes = remainingBytes + 1; + return false; + } + bytes += amount; + if (activeNode) activeNode.bytes += amount; + else scalarBytes += amount; + return bytes <= remainingBytes; + }; + const addIdentity = (identity) => { + if (activeNode) activeNode.edges.add(identity); + else roots.add(identity); + }; + const retainIdentity = (identity, inspect) => { + addIdentity(identity); + const node = { + bytes: 0, + edges: /* @__PURE__ */ new Set() + }; + nodes.set(identity, node); + const previous = activeNode; + activeNode = node; + try { + return inspect(); + } finally { + activeNode = previous; + } + }; + const visitSymbol = (current) => { + if (visitedSymbols.has(current)) { + addIdentity(current); + charge(8); + return; + } + visitedSymbols.add(current); + if (!retainIdentity(current, () => { + if (!symbolDescriptionGetter) return false; + const description = Reflect.apply(symbolDescriptionGetter, current, []); + return charge(8 + (description?.length ?? 0) * 2); + })) bytes = remainingBytes + 1; + }; + const visit = (current, depth, isBlobInternalHandle = false) => { + if (bytes > remainingBytes) return; + if (typeof current === "string") { + charge(current.length * 2); + return; + } + if (typeof current === "symbol") { + visitSymbol(current); + return; + } + if (typeof current === "function") { + bytes = remainingBytes + 1; + return; + } + if (current === null || typeof current !== "object") { + charge(8); + return; + } + if (nativeProxyDetector?.(current)) { + bytes = remainingBytes + 1; + return; + } + if (depth >= MAX_BUFFERED_EVENT_DEPTH) { + bytes = remainingBytes + 1; + return; + } + if (visited.has(current)) { + addIdentity(current); + charge(8); + return; + } + visited.add(current); + if (!retainIdentity(current, () => { + if (!charge(16)) return false; + const retainedStorage = estimateRetainedBufferBytes(current, visit, depth); + if (!visitRetainedEventPrototypes(current, depth, isBlobInternalHandle, visited, availableBytes, charge, visit, retainIdentity)) return false; + if (retainedStorage !== void 0 && !charge(retainedStorage.bytes)) return false; + if (!visitHiddenEventValues(current, retainedStorage?.kind, (hiddenValue, overhead) => { + if (!charge(overhead)) return false; + visit(hiddenValue, depth + 1); + return bytes <= remainingBytes; + })) return false; + return visitInspectableEventProperties(current, retainedStorage?.kind, depth, availableBytes, charge, visit); + })) bytes = remainingBytes + 1; + }; + try { + visit(value, 0); + } catch { + return; + } + return bytes <= remainingBytes ? { + scalarBytes, + roots, + nodes + } : void 0; +} +function areBufferedRetainedEdgesEqual(first, second) { + if (first.size !== second.size) return false; + for (const identity of first) if (!second.has(identity)) return false; + return true; +} +function getBufferedLedgerNodeBytes(node, owners) { + return node.bytes + BUFFERED_LEDGER_NODE_BYTES + node.edges.size * BUFFERED_LEDGER_EDGE_BYTES + owners * BUFFERED_LEDGER_OWNER_BYTES; +} +function getBufferedLedgerEntryBytes(entry) { + return BUFFERED_LEDGER_ENTRY_BYTES + entry.scalarBytes + entry.roots.size * BUFFERED_LEDGER_EDGE_BYTES; +} +function collectBufferedLedgerIdentities(roots, candidate, records, work) { + const identities = /* @__PURE__ */ new Set(); + const pending = [...roots]; + while (pending.length) { + work.remaining -= 1; + if (work.remaining < 0) return; + const identity = pending.pop(); + if (identities.has(identity)) continue; + const node = candidate.get(identity) ?? records.get(identity); + if (!node) return; + identities.add(identity); + for (const edge of node.edges) pending.push(edge); + } + return identities; +} +function getBufferedLedgerChange(identity, graph, records, changes, node) { + const existing = changes.get(identity); + if (existing) { + if (node) existing.node = node; + return existing; + } + const current = node ?? graph.nodes.get(identity) ?? records.get(identity); + if (!current) return; + const update = { + node: current, + ownerDelta: 0 + }; + changes.set(identity, update); + return update; +} +function findBufferedLedgerAffectedOwners(entry, graph, records, changes, work) { + const affected = /* @__PURE__ */ new Set([entry]); + for (const [identity, node] of graph.nodes) { + work.remaining -= 1; + if (work.remaining < 0) return; + const previous = records.get(identity); + if (!previous) continue; + const changedEdges = !areBufferedRetainedEdgesEqual(previous.edges, node.edges); + if (previous.bytes !== node.bytes || changedEdges) getBufferedLedgerChange(identity, graph, records, changes, node); + if (!changedEdges) continue; + for (const owner of previous.owners) { + work.remaining -= 1; + if (work.remaining < 0) return; + affected.add(owner); + } + } + return affected; +} +function updateBufferedLedgerMembershipChanges(owner, next, graph, records, changes, work) { + for (const identity of owner.identities) { + work.remaining -= 1; + if (work.remaining < 0) return false; + if (!next.has(identity)) { + const update = getBufferedLedgerChange(identity, graph, records, changes); + if (!update) return false; + update.ownerDelta -= 1; + } + } + for (const identity of next) { + work.remaining -= 1; + if (work.remaining < 0) return false; + if (!owner.identities.has(identity)) { + const update = getBufferedLedgerChange(identity, graph, records, changes); + if (!update) return false; + update.ownerDelta += 1; + } + } + return true; +} +function collectBufferedLedgerMemberships(entry, graph, affected, records, changes, work) { + const memberships = /* @__PURE__ */ new Map(); + for (const owner of affected) { + const next = collectBufferedLedgerIdentities(owner === entry ? graph.roots : owner.roots, graph.nodes, records, work); + if (!next || !updateBufferedLedgerMembershipChanges(owner, next, graph, records, changes, work)) return; + memberships.set(owner, next); + } + return memberships; +} +function projectBufferedLedgerBytes(currentBytes, entry, graph, isNew, changes, records) { + let projected = currentBytes - (isNew ? 0 : getBufferedLedgerEntryBytes(entry)) + getBufferedLedgerEntryBytes(graph); + for (const [identity, update] of changes) { + const previous = records.get(identity); + const owners = (previous?.owners.size ?? 0) + update.ownerDelta; + if (owners < 0) return; + if (previous) projected -= getBufferedLedgerNodeBytes(previous, previous.owners.size); + if (owners) projected += getBufferedLedgerNodeBytes(update.node, owners); + } + return Number.isSafeInteger(projected) && projected >= 0 && projected <= MAX_BUFFERED_ITERATOR_BYTES ? projected : void 0; +} +function applyBufferedLedgerChanges(records, changes, memberships) { + for (const [identity, update] of changes) { + const previous = records.get(identity); + if (!((previous?.owners.size ?? 0) + update.ownerDelta)) continue; + if (previous) { + previous.bytes = update.node.bytes; + previous.edges = update.node.edges; + } else records.set(identity, { + bytes: update.node.bytes, + edges: update.node.edges, + owners: /* @__PURE__ */ new Set() + }); + } + for (const [owner, next] of memberships) { + for (const identity of owner.identities) if (!next.has(identity)) records.get(identity)?.owners.delete(owner); + for (const identity of next) if (!owner.identities.has(identity)) records.get(identity).owners.add(owner); + owner.identities = next; + } + for (const identity of changes.keys()) if (records.get(identity)?.owners.size === 0) records.delete(identity); +} +/** +* Account for queue-owned identities once while charging bounded ownership and +* edge metadata. Shared topology changes are reconciled for every queued owner. +*/ +function createBufferedEventLedger() { + const records = /* @__PURE__ */ new Map(); + let bytes = 0; + const reconcile = (entry, graph, isNew) => { + const work = { remaining: MAX_BUFFERED_LEDGER_RECONCILIATION_WORK }; + const changes = /* @__PURE__ */ new Map(); + const affected = findBufferedLedgerAffectedOwners(entry, graph, records, changes, work); + if (!affected) return false; + const memberships = collectBufferedLedgerMemberships(entry, graph, affected, records, changes, work); + if (!memberships) return false; + const projectedBytes = projectBufferedLedgerBytes(bytes, entry, graph, isNew, changes, records); + if (projectedBytes === void 0) return false; + applyBufferedLedgerChanges(records, changes, memberships); + entry.scalarBytes = graph.scalarBytes; + entry.roots = graph.roots; + bytes = projectedBytes; + return true; + }; + const release = (entry) => { + bytes -= getBufferedLedgerEntryBytes(entry); + for (const identity of entry.identities) { + const record = records.get(identity); + if (!record?.owners.delete(entry)) continue; + bytes -= BUFFERED_LEDGER_OWNER_BYTES; + if (record.owners.size === 0) { + bytes -= getBufferedLedgerNodeBytes(record, 0); + records.delete(identity); + } + } + entry.identities.clear(); + }; + return { + retain(graph) { + const entry = { + scalarBytes: 0, + roots: /* @__PURE__ */ new Set(), + identities: /* @__PURE__ */ new Set() + }; + return reconcile(entry, graph, true) ? entry : void 0; + }, + refresh(entry, graph) { + return reconcile(entry, graph, false); + }, + release, + clear() { + records.clear(); + bytes = 0; + } + }; +} +/** An abortable event stream with typed listeners, asynchronous iteration, and lifecycle state. */ +var EventStream = class { + /** Creates an unstarted stream with independent connection and completion lifecycle promises. */ + constructor() { + _EventStream_instances.add(this); + /** Controls the underlying request; aborting this controller cancels the stream. */ + this.controller = new AbortController(); + _EventStream_connectedPromise.set(this, void 0); + _EventStream_resolveConnectedPromise.set(this, () => void 0); + _EventStream_rejectConnectedPromise.set(this, () => void 0); + _EventStream_endPromise.set(this, void 0); + _EventStream_resolveEndPromise.set(this, () => void 0); + _EventStream_rejectEndPromise.set(this, () => void 0); + _EventStream_listeners.set(this, Object.create(null)); + _EventStream_abortListeners.set(this, []); + _EventStream_emittedListenerRegistrations.set(this, /* @__PURE__ */ new WeakMap()); + _EventStream_pendingListenerCleanup.set(this, /* @__PURE__ */ new Set()); + _EventStream_pendingBufferedEventChecks.set(this, /* @__PURE__ */ new Set()); + _EventStream_listenerDispatchDepth.set(this, 0); + _EventStream_ended.set(this, false); + _EventStream_errored.set(this, false); + _EventStream_aborted.set(this, false); + _EventStream_catchingPromiseCreated.set(this, false); + _EventStream_terminalFailure.set(this, void 0); + __classPrivateFieldSet(this, _EventStream_connectedPromise, new Promise((resolve, reject) => { + __classPrivateFieldSet(this, _EventStream_resolveConnectedPromise, resolve, "f"); + __classPrivateFieldSet(this, _EventStream_rejectConnectedPromise, reject, "f"); + }), "f"); + __classPrivateFieldSet(this, _EventStream_endPromise, new Promise((resolve, reject) => { + __classPrivateFieldSet(this, _EventStream_resolveEndPromise, resolve, "f"); + __classPrivateFieldSet(this, _EventStream_rejectEndPromise, reject, "f"); + }), "f"); + __classPrivateFieldGet(this, _EventStream_connectedPromise, "f").catch(() => void 0); + __classPrivateFieldGet(this, _EventStream_endPromise, "f").catch(() => void 0); + } + _run(executor) { + setTimeout(() => { + let failed = false; + Promise.resolve().then(executor).catch((error) => { + failed = true; + __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_handleError).call(this, error); + }).then(() => { + if (failed) return; + try { + this._emitFinal(); + } catch (error) { + __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_handleError).call(this, error); + return; + } + this._emit("end"); + }); + }, 0); + } + _connected() { + if (this.ended) return; + __classPrivateFieldGet(this, _EventStream_resolveConnectedPromise, "f").call(this); + this._emit("connect"); + } + /** Whether the stream has finished successfully, failed, or been aborted. */ + get ended() { + return __classPrivateFieldGet(this, _EventStream_ended, "f"); + } + /** Whether an error or user cancellation has been observed. */ + get errored() { + return __classPrivateFieldGet(this, _EventStream_errored, "f"); + } + /** Whether the stream ended because its request was cancelled. */ + get aborted() { + return __classPrivateFieldGet(this, _EventStream_aborted, "f"); + } + /** + * Cancels the underlying request; {@link done} and {@link events} observe cancellation. + * Promises returned by {@link emitted} for other events may remain pending. + */ + abort() { + this.controller.abort(); + } + /** Creates a user-abort error retaining this runner's cancellation reason. */ + _userAbortError() { + const error = new APIUserAbortError(); + Object.defineProperty(error, "cause", { + value: this.controller.signal.reason, + writable: true, + configurable: true + }); + return error; + } + _listenForAbort(signal) { + if (!signal || this.ended) return; + if (signal.aborted) { + __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_abortFromSignal).call(this, signal); + return; + } + if (__classPrivateFieldGet(this, _EventStream_abortListeners, "f").some((registration) => registration.signal === signal)) return; + const listener = () => __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_abortFromSignal).call(this, signal); + signal.addEventListener("abort", listener, { once: true }); + __classPrivateFieldGet(this, _EventStream_abortListeners, "f").push({ + signal, + listener + }); + } + /** + * 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 stream, so that listener registration calls can be chained. + */ + on(event, listener) { + var _a; + ((_a = __classPrivateFieldGet(this, _EventStream_listeners, "f"))[event] || (_a[event] = [])).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 stream, so that listener registration calls can be chained. + */ + off(event, listener) { + const listeners = __classPrivateFieldGet(this, _EventStream_listeners, "f")[event]; + if (!listeners) return this; + const emittedRegistration = __classPrivateFieldGet(this, _EventStream_emittedListenerRegistrations, "f").get(listener); + if (emittedRegistration?.event === event && !emittedRegistration.registration.removed && !emittedRegistration.registration.detached) { + __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_removeEmittedListener).call(this, event, emittedRegistration.registration); + return this; + } + const index = listeners.findIndex((l) => !l.removed && l.listener === listener); + if (index !== -1) 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 stream, so that listener registration calls can be chained. + */ + once(event, listener) { + var _a; + ((_a = __classPrivateFieldGet(this, _EventStream_listeners, "f"))[event] || (_a[event] = [])).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. + * Events without arguments resolve to `undefined`, single-argument events resolve + * to that argument, and events with multiple arguments resolve to an argument tuple. + * + * @returns A promise for the next event, or a rejection if an error occurs first. + * Requesting the `error` event resolves with the emitted error instead. + * + * Example: + * + * const message = await stream.emitted('message') // rejects if the stream errors + */ + emitted(event) { + return new Promise((resolve, reject) => { + __classPrivateFieldSet(this, _EventStream_catchingPromiseCreated, true, "f"); + const onError = (error) => { + this.off(event, onEvent); + reject(error); + }; + const onEvent = (...values) => { + if (event !== "error") this.off("error", onError); + resolve(values.length > 1 ? values : values[0]); + }; + if (event !== "error") __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_onceForEmitted).call(this, "error", onError); + __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_onceForEmitted).call(this, event, onEvent); + }); + } + /** + * Returns an async iterator that yields every time the event is triggered. + * The iterator ends when the stream ends and rejects if the stream errors + * or is aborted. If you request the 'error' or 'abort' event, the iterator + * yields that event instead of rejecting. + * + * Example: + * + * for await (const [message] of stream.events('message')) { + * await processMessage(message); + * } + */ + events(event) { + return this._createIterator((push) => { + const onEvent = (...args) => { + sdkOwnedBufferedEventArguments.add(args); + try { + push(args); + } finally { + sdkOwnedBufferedEventArguments.delete(args); + } + }; + this.on(event, onEvent); + return () => this.off(event, onEvent); + }, { + rejectOnError: event !== "error", + rejectOnAbort: event !== "abort" + }); + } + /** + * Shared buffered async-iterator adapter over this stream's events. + * + * `attach` registers the producer listener(s) with the given `push` and + * returns a cleanup function that removes them. Termination is handled + * here: the iterator ends when the stream ends, listeners are removed on + * end/return, and a terminal error is retained until buffered values have + * drained so it is surfaced even when no reader was waiting when it fired. + * Detached consumers have bounded event and byte queues; exceeding either + * limit fails the stream and aborts its underlying request. Detached queues + * also reject accessor-backed payloads because getter closures cannot be + * safely sized without executing untrusted code. + */ + _createIterator(attach, { rejectOnError = true, rejectOnAbort = true, onReturn } = {}) { + const pushQueue = createEventQueue(); + const bufferedEventSizes = createEventQueue(); + const readQueue = createEventQueue(); + const bufferedLedger = createBufferedEventLedger(); + let ended = this.ended; + let failure; + let failureDelivered = false; + let detach = () => void 0; + const doneResult = () => ({ + value: void 0, + done: true + }); + const finishReaders = () => { + while (readQueue.length) readQueue.dequeue().resolve(doneResult()); + }; + const rejectReader = () => { + if (!failure || failureDelivered || !readQueue.length) return; + failureDelivered = true; + readQueue.dequeue().reject(failure); + }; + const cleanup = () => { + detach(); + this.off("end", onEnd); + if (rejectOnError) this.off("error", onFailure); + if (rejectOnAbort) this.off("abort", onFailure); + }; + const deactivateBufferedEvent = (entry) => { + entry.active = false; + if (entry.check) { + __classPrivateFieldGet(this, _EventStream_pendingBufferedEventChecks, "f").delete(entry.check); + entry.check = void 0; + } + }; + const failBufferedEvents = (discardRetained = false) => { + if (discardRetained) { + while (bufferedEventSizes.length) deactivateBufferedEvent(bufferedEventSizes.dequeue()); + pushQueue.clear(); + bufferedLedger.clear(); + } + const error = new OpenAIError(`Event stream iterator buffer limit exceeded (${MAX_BUFFERED_ITERATOR_EVENTS} events or ${MAX_BUFFERED_ITERATOR_BYTES} bytes); consume events as they arrive.`); + try { + __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_handleError).call(this, error); + } finally { + this.controller.abort(); + } + return error; + }; + const revalidateBufferedEvent = (value, entry) => { + if (!entry.active || __classPrivateFieldGet(this, _EventStream_ended, "f")) return; + const graph = inspectBufferedEventGraph(value, MAX_BUFFERED_ITERATOR_BYTES); + if (!graph || !bufferedLedger.refresh(entry.retention, graph)) failBufferedEvents(true); + }; + const push = (value) => { + if (ended) return; + const reader = readQueue.dequeue(); + if (reader) reader.resolve({ + value, + done: false + }); + else { + if (pushQueue.length >= MAX_BUFFERED_ITERATOR_EVENTS) { + failBufferedEvents(); + return; + } + const graph = inspectBufferedEventGraph(value, MAX_BUFFERED_ITERATOR_BYTES); + const retention = graph && bufferedLedger.retain(graph); + if (!retention) { + failBufferedEvents(); + return; + } + if (typeof value === "object" && value !== null && sdkOwnedBufferedEventArguments.has(value)) { + const argumentsTuple = value; + for (let index = 0; index < argumentsTuple.length; index += 1) { + const argument = argumentsTuple[index]; + if (typeof argument === "string") argumentsTuple[index] = bufferedJSONParse(bufferedJSONStringify(argument)); + } + } + const entry = { + retention, + active: true, + check: void 0 + }; + pushQueue.enqueue(value); + bufferedEventSizes.enqueue(entry); + const check = () => { + entry.check = void 0; + revalidateBufferedEvent(value, entry); + }; + entry.check = check; + __classPrivateFieldGet(this, _EventStream_pendingBufferedEventChecks, "f").add(check); + } + }; + const onFailure = (error) => { + failure = error; + if (!pushQueue.length) rejectReader(); + }; + const adoptTerminalFailure = () => { + if (failure) return; + const terminal = __classPrivateFieldGet(this, _EventStream_terminalFailure, "f"); + if (!terminal) return; + if (terminal.kind === "error" ? rejectOnError : rejectOnAbort) failure = terminal.error; + }; + const onEnd = () => { + ended = true; + adoptTerminalFailure(); + cleanup(); + if (!pushQueue.length) { + rejectReader(); + finishReaders(); + } + }; + if (!ended) { + detach = attach(push); + this.on("end", onEnd); + if (rejectOnError) this.on("error", onFailure); + if (rejectOnAbort) this.on("abort", onFailure); + } + return { + next: () => { + if (pushQueue.length) { + const value = pushQueue.dequeue(); + const entry = bufferedEventSizes.dequeue(); + deactivateBufferedEvent(entry); + const graph = inspectBufferedEventGraph(value, MAX_BUFFERED_ITERATOR_BYTES); + if (!graph || !bufferedLedger.refresh(entry.retention, graph)) { + const error = failBufferedEvents(true); + failureDelivered = true; + return Promise.reject(error); + } + bufferedLedger.release(entry.retention); + return Promise.resolve({ + value, + done: false + }); + } + if (ended || this.ended) adoptTerminalFailure(); + if (failure && !failureDelivered) { + failureDelivered = true; + return Promise.reject(failure); + } + if (ended) return Promise.resolve(doneResult()); + return new Promise((resolve, reject) => { + readQueue.enqueue({ + resolve, + reject + }); + }); + }, + return: () => { + ended = true; + failureDelivered = true; + while (bufferedEventSizes.length) deactivateBufferedEvent(bufferedEventSizes.dequeue()); + pushQueue.clear(); + bufferedLedger.clear(); + cleanup(); + finishReaders(); + if (onReturn) { + this.done().catch(() => void 0); + onReturn(); + } + return Promise.resolve(doneResult()); + }, + [Symbol.asyncIterator]() { + return this; + } + }; + } + /** Resolves when the stream ends successfully or rejects when it fails or is aborted. */ + async done() { + __classPrivateFieldSet(this, _EventStream_catchingPromiseCreated, true, "f"); + await __classPrivateFieldGet(this, _EventStream_endPromise, "f"); + } + /** Returns whether an event currently has one or more registered listeners. */ + _hasListeners(event) { + return Boolean(__classPrivateFieldGet(this, _EventStream_listeners, "f")[event]?.some((listener) => !listener.removed)); + } + /** Dispatches a stream event and performs the associated lifecycle transitions. */ + _emit(event, ...args) { + if (__classPrivateFieldGet(this, _EventStream_ended, "f")) return; + if (event === "end") { + __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_removeAbortListeners).call(this); + __classPrivateFieldSet(this, _EventStream_ended, true, "f"); + __classPrivateFieldGet(this, _EventStream_resolveEndPromise, "f").call(this); + } + const listeners = __classPrivateFieldGet(this, _EventStream_listeners, "f")[event]; + let dispatchError; + let dispatchThrew = false; + try { + if (listeners) { + __classPrivateFieldGet(this, _EventStream_listeners, "f")[event] = listeners.filter((listener) => { + if (listener.once) listener.detached = true; + return !listener.once && !listener.removed; + }); + __classPrivateFieldSet(this, _EventStream_listenerDispatchDepth, __classPrivateFieldGet(this, _EventStream_listenerDispatchDepth, "f") + 1, "f"); + try { + for (const registration of listeners) if (!registration.removed) { + const { listener } = registration; + listener(...args); + } + } finally { + __classPrivateFieldSet(this, _EventStream_listenerDispatchDepth, __classPrivateFieldGet(this, _EventStream_listenerDispatchDepth, "f") - 1, "f"); + if (__classPrivateFieldGet(this, _EventStream_listenerDispatchDepth, "f") === 0) { + __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_cleanupEmittedListeners).call(this); + for (const check of __classPrivateFieldGet(this, _EventStream_pendingBufferedEventChecks, "f")) { + __classPrivateFieldGet(this, _EventStream_pendingBufferedEventChecks, "f").delete(check); + if (!__classPrivateFieldGet(this, _EventStream_ended, "f")) check(); + } + } + } + } + } catch (error) { + dispatchError = error; + dispatchThrew = true; + } + try { + __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_settleTerminalEvent).call(this, event, args, Boolean(listeners?.length)); + } catch (error) { + if (!dispatchThrew) { + dispatchError = error; + dispatchThrew = true; + } + } + if (dispatchThrew) throw dispatchError; + } + _emitFinal() {} +}; +_EventStream_connectedPromise = /* @__PURE__ */ new WeakMap(), _EventStream_resolveConnectedPromise = /* @__PURE__ */ new WeakMap(), _EventStream_rejectConnectedPromise = /* @__PURE__ */ new WeakMap(), _EventStream_endPromise = /* @__PURE__ */ new WeakMap(), _EventStream_resolveEndPromise = /* @__PURE__ */ new WeakMap(), _EventStream_rejectEndPromise = /* @__PURE__ */ new WeakMap(), _EventStream_listeners = /* @__PURE__ */ new WeakMap(), _EventStream_abortListeners = /* @__PURE__ */ new WeakMap(), _EventStream_emittedListenerRegistrations = /* @__PURE__ */ new WeakMap(), _EventStream_pendingListenerCleanup = /* @__PURE__ */ new WeakMap(), _EventStream_pendingBufferedEventChecks = /* @__PURE__ */ new WeakMap(), _EventStream_listenerDispatchDepth = /* @__PURE__ */ new WeakMap(), _EventStream_ended = /* @__PURE__ */ new WeakMap(), _EventStream_errored = /* @__PURE__ */ new WeakMap(), _EventStream_aborted = /* @__PURE__ */ new WeakMap(), _EventStream_catchingPromiseCreated = /* @__PURE__ */ new WeakMap(), _EventStream_terminalFailure = /* @__PURE__ */ new WeakMap(), _EventStream_instances = /* @__PURE__ */ new WeakSet(), _EventStream_abortFromSignal = function _EventStream_abortFromSignal(signal) { + try { + this.controller.abort(signal.reason); + } catch { + this.controller.abort(); + } +}, _EventStream_removeAbortListeners = function _EventStream_removeAbortListeners() { + for (const { signal, listener } of __classPrivateFieldGet(this, _EventStream_abortListeners, "f").splice(0)) signal.removeEventListener("abort", listener); +}, _EventStream_onceForEmitted = function _EventStream_onceForEmitted(event, listener) { + const previousListeners = __classPrivateFieldGet(this, _EventStream_listeners, "f")[event]; + const previousLength = previousListeners?.length ?? 0; + this.once(event, listener); + const listeners = __classPrivateFieldGet(this, _EventStream_listeners, "f")[event]; + const [registration] = listeners?.slice(-1) ?? []; + if ((previousListeners === void 0 || listeners === previousListeners) && listeners?.length === previousLength + 1 && registration?.listener === listener && registration.once) __classPrivateFieldGet(this, _EventStream_emittedListenerRegistrations, "f").set(listener, { + event, + registration + }); +}, _EventStream_removeEmittedListener = function _EventStream_removeEmittedListener(event, registration) { + if (registration.removed) return; + registration.removed = true; + __classPrivateFieldGet(this, _EventStream_emittedListenerRegistrations, "f").delete(registration.listener); + __classPrivateFieldGet(this, _EventStream_pendingListenerCleanup, "f").add(event); + if (__classPrivateFieldGet(this, _EventStream_listenerDispatchDepth, "f") === 0) __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_cleanupEmittedListeners).call(this); +}, _EventStream_cleanupEmittedListeners = function _EventStream_cleanupEmittedListeners() { + for (const event of __classPrivateFieldGet(this, _EventStream_pendingListenerCleanup, "f")) { + const eventType = event; + const listeners = __classPrivateFieldGet(this, _EventStream_listeners, "f")[eventType]; + if (listeners) __classPrivateFieldGet(this, _EventStream_listeners, "f")[eventType] = listeners.filter((listener) => !listener.removed); + } + __classPrivateFieldGet(this, _EventStream_pendingListenerCleanup, "f").clear(); +}, _EventStream_handleError = function _EventStream_handleError(error) { + __classPrivateFieldSet(this, _EventStream_errored, true, "f"); + if (error instanceof Error && error.name === "AbortError") error = this._userAbortError(); + if (error instanceof APIUserAbortError) { + __classPrivateFieldSet(this, _EventStream_aborted, true, "f"); + return this._emit("abort", error); + } + if (error instanceof OpenAIError) return this._emit("error", error); + if (error instanceof Error) { + const openAIError = new OpenAIError(error.message); + openAIError.cause = error; + return this._emit("error", openAIError); + } + return this._emit("error", new OpenAIError(String(error))); +}, _EventStream_settleTerminalEvent = function _EventStream_settleTerminalEvent(event, args, hasListeners) { + if (event === "abort") { + const error = args[0]; + __classPrivateFieldSet(this, _EventStream_terminalFailure, __classPrivateFieldGet(this, _EventStream_terminalFailure, "f") ?? { + kind: "abort", + error + }, "f"); + if (!__classPrivateFieldGet(this, _EventStream_catchingPromiseCreated, "f") && !hasListeners) Promise.reject(error); + __classPrivateFieldGet(this, _EventStream_rejectConnectedPromise, "f").call(this, error); + __classPrivateFieldGet(this, _EventStream_rejectEndPromise, "f").call(this, error); + this._emit("end"); + return; + } + if (event === "error") { + const error = args[0]; + __classPrivateFieldSet(this, _EventStream_terminalFailure, __classPrivateFieldGet(this, _EventStream_terminalFailure, "f") ?? { + kind: "error", + error + }, "f"); + if (!__classPrivateFieldGet(this, _EventStream_catchingPromiseCreated, "f") && !hasListeners) Promise.reject(error); + __classPrivateFieldGet(this, _EventStream_rejectConnectedPromise, "f").call(this, error); + __classPrivateFieldGet(this, _EventStream_rejectEndPromise, "f").call(this, error); + this._emit("end"); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/RunnableFunction.mjs +/** Returns whether a runnable function provides a parser for its raw argument string. */ +function isRunnableFunctionWithParse(fn) { + return typeof fn.parse === "function"; +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/AbstractChatCompletionRunner.mjs +var _AbstractChatCompletionRunner_instances; +var _a$2; +var _AbstractChatCompletionRunner_completionArrivedBeforeAbort; +var _AbstractChatCompletionRunner_afterCompletionInvoked; +var _AbstractChatCompletionRunner_getFinalContent; +var _AbstractChatCompletionRunner_getFinalMessage; +var _AbstractChatCompletionRunner_getFinalFunctionToolCall; +var _AbstractChatCompletionRunner_getFinalFunctionToolCallResult; +var _AbstractChatCompletionRunner_calculateTotalUsage; +var _AbstractChatCompletionRunner_throwIfAborted; +var _AbstractChatCompletionRunner_validateParams; +var _AbstractChatCompletionRunner_stringifyFunctionCallResult; +const DEFAULT_MAX_CHAT_COMPLETIONS = 10; +function normalizeToolCallIds(chatCompletion) { + for (const choice of chatCompletion.choices) for (const toolCall of choice.message.tool_calls ?? []) if (!toolCall.id) toolCall.id = `call_${uuid4()}`; +} +/** +* Parsed completions contain response-only and helper-only fields. Keep those +* on runner.messages for callers, but only replay valid request fields. +*/ +function toRequestMessage(message) { + if (!isAssistantMessage(message)) return message; + const requestMessage = { role: "assistant" }; + if (message.audio != null) requestMessage.audio = { id: message.audio.id }; + if (message.content !== void 0) requestMessage.content = message.content; + if (message.function_call != null) requestMessage.function_call = message.function_call; + if (message.name !== void 0) requestMessage.name = message.name; + if (message.refusal != null) requestMessage.refusal = message.refusal; + if (message.tool_calls !== void 0) requestMessage.tool_calls = message.tool_calls.map((toolCall) => { + if (toolCall.type === "custom") return { + id: toolCall.id, + type: toolCall.type, + custom: { + input: toolCall.custom.input, + name: toolCall.custom.name + } + }; + return { + id: toolCall.id, + type: toolCall.type, + function: { + arguments: toolCall.function.arguments, + name: toolCall.function.name + } + }; + }); + return requestMessage; +} +/** Shared conversation, event, cancellation, and final-result behavior for chat completion runners. */ +var AbstractChatCompletionRunner = class extends EventStream { + constructor() { + super(...arguments); + _AbstractChatCompletionRunner_instances.add(this); + this._chatCompletions = []; + _AbstractChatCompletionRunner_completionArrivedBeforeAbort.set(this, false); + _AbstractChatCompletionRunner_afterCompletionInvoked.set(this, false); + /** Mutable conversation history, including initial input, assistant replies, and tool results. */ + this.messages = []; + } + _addChatCompletion(chatCompletion) { + __classPrivateFieldSet(this, _AbstractChatCompletionRunner_completionArrivedBeforeAbort, !this.controller.signal.aborted, "f"); + normalizeToolCallIds(chatCompletion); + this._chatCompletions.push(chatCompletion); + this._emit("chatCompletion", chatCompletion); + const message = chatCompletion.choices[0]?.message; + if (message) this._addMessage(message); + return chatCompletion; + } + _addMessage(message, emit = true, normalizeContent = true) { + if (normalizeContent && !("content" in message)) message.content = null; + this.messages.push(message); + if (emit) { + this._emit("message", message); + if (isToolMessage(message) && message.content) this._emit("functionToolCallResult", message.content); + else if (isAssistantMessage(message) && message.tool_calls) { + for (const tool_call of message.tool_calls) if (tool_call.type === "function") this._emit("functionToolCall", tool_call.function); + } + } + } + /** + * @returns a promise that resolves with the final ChatCompletion, or rejects + * if an error occurred or the stream ended prematurely without producing a ChatCompletion. + */ + async finalChatCompletion() { + await this.done(); + const completion = this._chatCompletions[this._chatCompletions.length - 1]; + if (!completion) throw new OpenAIError("stream ended without producing a ChatCompletion"); + return completion; + } + /** + * @returns a promise that resolves with the content of the final ChatCompletionMessage, or rejects + * if an error occurred or the stream ended prematurely without producing a ChatCompletionMessage. + */ + async finalContent() { + await this.done(); + return __classPrivateFieldGet(this, _AbstractChatCompletionRunner_instances, "m", _AbstractChatCompletionRunner_getFinalContent).call(this); + } + /** + * @returns a promise that resolves with the final assistant ChatCompletionMessage response, + * or rejects if an error occurred or the stream ended prematurely without producing a ChatCompletionMessage. + */ + async finalMessage() { + await this.done(); + return __classPrivateFieldGet(this, _AbstractChatCompletionRunner_instances, "m", _AbstractChatCompletionRunner_getFinalMessage).call(this); + } + /** + * Waits for completion and returns the last function-tool call, or `undefined` + * when no assistant message contains a function-tool call. + */ + async finalFunctionToolCall() { + await this.done(); + return __classPrivateFieldGet(this, _AbstractChatCompletionRunner_instances, "m", _AbstractChatCompletionRunner_getFinalFunctionToolCall).call(this); + } + /** Waits for completion and returns the last matching function-tool result, if any. */ + async finalFunctionToolCallResult() { + await this.done(); + return __classPrivateFieldGet(this, _AbstractChatCompletionRunner_instances, "m", _AbstractChatCompletionRunner_getFinalFunctionToolCallResult).call(this); + } + /** Waits for completion and sums token usage across every chat completion in the run. */ + async totalUsage() { + await this.done(); + return __classPrivateFieldGet(this, _AbstractChatCompletionRunner_instances, "m", _AbstractChatCompletionRunner_calculateTotalUsage).call(this); + } + /** Returns a copy of the chat completions received so far, in request order. */ + allChatCompletions() { + return [...this._chatCompletions]; + } + _emitFinal() { + if (__classPrivateFieldGet(this, _AbstractChatCompletionRunner_afterCompletionInvoked, "f")) __classPrivateFieldGet(this, _AbstractChatCompletionRunner_instances, "m", _AbstractChatCompletionRunner_throwIfAborted).call(this); + const completion = this._chatCompletions[this._chatCompletions.length - 1]; + if (completion) this._emit("finalChatCompletion", completion); + const finalMessage = __classPrivateFieldGet(this, _AbstractChatCompletionRunner_instances, "m", _AbstractChatCompletionRunner_getFinalMessage).call(this); + if (finalMessage) this._emit("finalMessage", finalMessage); + const finalContent = __classPrivateFieldGet(this, _AbstractChatCompletionRunner_instances, "m", _AbstractChatCompletionRunner_getFinalContent).call(this); + if (finalContent) this._emit("finalContent", finalContent); + const finalFunctionCall = __classPrivateFieldGet(this, _AbstractChatCompletionRunner_instances, "m", _AbstractChatCompletionRunner_getFinalFunctionToolCall).call(this); + if (finalFunctionCall) this._emit("finalFunctionToolCall", finalFunctionCall); + const finalFunctionCallResult = __classPrivateFieldGet(this, _AbstractChatCompletionRunner_instances, "m", _AbstractChatCompletionRunner_getFinalFunctionToolCallResult).call(this); + if (finalFunctionCallResult != null) this._emit("finalFunctionToolCallResult", finalFunctionCallResult); + if (this._chatCompletions.some((c) => c.usage)) this._emit("totalUsage", __classPrivateFieldGet(this, _AbstractChatCompletionRunner_instances, "m", _AbstractChatCompletionRunner_calculateTotalUsage).call(this)); + } + async _createChatCompletion(client, params, options) { + this._listenForAbort(options?.signal); + __classPrivateFieldGet(_a$2, _a$2, "m", _AbstractChatCompletionRunner_validateParams).call(_a$2, params); + const chatCompletion = await client.chat.completions.create({ + ...params, + stream: false + }, { + ...options, + signal: this.controller.signal + }); + this._connected(); + return this._addChatCompletion(parseChatCompletion(chatCompletion, params)); + } + async _runChatCompletion(client, params, options) { + for (const message of params.messages) this._addMessage(message, false, false); + return await this._createChatCompletion(client, params, options); + } + async _runTools(client, params, runner, options) { + const role = "tool"; + const { tool_choice = "auto", stream, toolContext: inputToolContext, ...restParams } = params; + const toolContext = inputToolContext; + const singleFunctionToCall = typeof tool_choice !== "string" && tool_choice.type === "function" && tool_choice?.function?.name; + const { maxChatCompletions = DEFAULT_MAX_CHAT_COMPLETIONS, afterCompletion } = options || {}; + const runAfterCompletion = async (completion) => { + if (afterCompletion == null) return; + __classPrivateFieldSet(this, _AbstractChatCompletionRunner_afterCompletionInvoked, true, "f"); + await afterCompletion(completion, runner); + __classPrivateFieldGet(this, _AbstractChatCompletionRunner_instances, "m", _AbstractChatCompletionRunner_throwIfAborted).call(this); + }; + const inputTools = params.tools.map((tool) => { + if (isAutoParsableTool$1(tool)) { + if (!tool.$callback) throw new OpenAIError("Tool given to `.runTools()` that does not have an associated function"); + return { + type: "function", + function: { + function: tool.$callback, + name: tool.function.name, + description: tool.function.description || "", + parameters: tool.function.parameters, + parse: tool.$parseRaw, + strict: true + } + }; + } + return tool; + }); + const functionsByName = Object.create(null); + for (const f of inputTools) if (f.type === "function") functionsByName[f.function.name || f.function.function.name] = f.function; + const tools = "tools" in params ? inputTools.map((t) => t.type === "function" ? { + type: "function", + function: { + name: t.function.name || t.function.function.name, + parameters: t.function.parameters, + description: t.function.description, + strict: t.function.strict + } + } : t) : void 0; + for (const message of params.messages) this._addMessage(message, false, false); + let allowBufferedToolCall = false; + const runToolCall = async (toolCall) => { + const bufferedToolCall = allowBufferedToolCall; + allowBufferedToolCall = false; + if (toolCall.type !== "function") return { + message: void 0, + functionCalled: false + }; + const tool_call_id = toolCall.id; + const { name, arguments: args } = toolCall.function; + const fn = functionsByName[name]; + if (!fn) { + const content = `Invalid tool_call: ${JSON.stringify(name)}. Available options are: ${Object.keys(functionsByName).map((name) => JSON.stringify(name)).join(", ")}. Please try again`; + return { + message: { + role, + tool_call_id, + content + }, + functionCalled: false + }; + } + if (singleFunctionToCall && singleFunctionToCall !== name) { + const content = `Invalid tool_call: ${JSON.stringify(name)}. ${JSON.stringify(singleFunctionToCall)} requested. Please try again`; + return { + message: { + role, + tool_call_id, + content + }, + functionCalled: false + }; + } + let rawContent; + if (isRunnableFunctionWithParse(fn)) { + let parsed; + try { + parsed = await fn.parse(args); + } catch (error) { + if (this.controller.signal.aborted) throw this._userAbortError(); + const content = error instanceof Error ? error.message : String(error); + return { + message: { + role, + tool_call_id, + content + }, + functionCalled: false + }; + } + if (this.controller.signal.aborted) throw this._userAbortError(); + try { + rawContent = await fn.function(parsed, runner, toolContext); + } catch (error) { + if (this.controller.signal.aborted && Object.is(error, this.controller.signal.reason)) throw this._userAbortError(); + throw error; + } + } else { + if (this.controller.signal.aborted && !bufferedToolCall) throw this._userAbortError(); + try { + rawContent = await fn.function(args, runner, toolContext); + } catch (error) { + if (this.controller.signal.aborted && Object.is(error, this.controller.signal.reason)) throw this._userAbortError(); + throw error; + } + } + const content = __classPrivateFieldGet(_a$2, _a$2, "m", _AbstractChatCompletionRunner_stringifyFunctionCallResult).call(_a$2, rawContent); + return { + message: { + role, + tool_call_id, + content + }, + functionCalled: true + }; + }; + for (let i = 0; i < maxChatCompletions; ++i) { + const chatCompletion = await this._createChatCompletion(client, { + ...restParams, + tool_choice, + tools, + messages: this.messages.map(toRequestMessage) + }, options); + allowBufferedToolCall = this.controller.signal.aborted && __classPrivateFieldGet(this, _AbstractChatCompletionRunner_completionArrivedBeforeAbort, "f"); + const message = chatCompletion.choices[0]?.message; + if (!message) throw new OpenAIError(`missing message in ChatCompletion response`); + if (!message.tool_calls?.length) { + await runAfterCompletion(chatCompletion); + return; + } + if (singleFunctionToCall || params.parallel_tool_calls === false) for (const toolCall of message.tool_calls) { + const result = await runToolCall(toolCall); + if (result.message) this._addMessage(result.message); + if (this.controller.signal.aborted) throw this._userAbortError(); + if (singleFunctionToCall && result.functionCalled) { + await runAfterCompletion(chatCompletion); + return; + } + } + else { + const results = await Promise.allSettled(message.tool_calls.map(runToolCall)); + if (!this.controller.signal.aborted) { + for (const result of results) if (result.status === "rejected") throw result.reason; + } + for (const result of results) if (result.status === "fulfilled" && result.value.message) this._addMessage(result.value.message); + if (this.controller.signal.aborted) throw this._userAbortError(); + } + await runAfterCompletion(chatCompletion); + } + } +}; +_a$2 = AbstractChatCompletionRunner, _AbstractChatCompletionRunner_completionArrivedBeforeAbort = /* @__PURE__ */ new WeakMap(), _AbstractChatCompletionRunner_afterCompletionInvoked = /* @__PURE__ */ new WeakMap(), _AbstractChatCompletionRunner_instances = /* @__PURE__ */ new WeakSet(), _AbstractChatCompletionRunner_getFinalContent = function _AbstractChatCompletionRunner_getFinalContent() { + return __classPrivateFieldGet(this, _AbstractChatCompletionRunner_instances, "m", _AbstractChatCompletionRunner_getFinalMessage).call(this).content ?? null; +}, _AbstractChatCompletionRunner_getFinalMessage = function _AbstractChatCompletionRunner_getFinalMessage() { + let i = this.messages.length; + while (i-- > 0) { + const message = this.messages[i]; + if (isAssistantMessage(message)) return { + ...message, + content: message.content ?? null, + refusal: message.refusal ?? null + }; + } + throw new OpenAIError("stream ended without producing a ChatCompletionMessage with role=assistant"); +}, _AbstractChatCompletionRunner_getFinalFunctionToolCall = function _AbstractChatCompletionRunner_getFinalFunctionToolCall() { + for (let i = this.messages.length - 1; i >= 0; i--) { + const message = this.messages[i]; + if (isAssistantMessage(message) && message?.tool_calls?.length) for (let j = message.tool_calls.length - 1; j >= 0; j--) { + const toolCall = message.tool_calls[j]; + if (toolCall?.type === "function") return toolCall.function; + } + } +}, _AbstractChatCompletionRunner_getFinalFunctionToolCallResult = function _AbstractChatCompletionRunner_getFinalFunctionToolCallResult() { + for (let i = this.messages.length - 1; i >= 0; i--) { + const message = this.messages[i]; + if (isToolMessage(message) && message.content != null && typeof message.content === "string" && this.messages.some((x) => x.role === "assistant" && x.tool_calls?.some((y) => y.type === "function" && y.id === message.tool_call_id))) return message.content; + } +}, _AbstractChatCompletionRunner_calculateTotalUsage = function _AbstractChatCompletionRunner_calculateTotalUsage() { + const total = { + completion_tokens: 0, + prompt_tokens: 0, + total_tokens: 0 + }; + for (const { usage } of this._chatCompletions) if (usage) { + total.completion_tokens += usage.completion_tokens; + total.prompt_tokens += usage.prompt_tokens; + total.total_tokens += usage.total_tokens; + for (const key of ["completion_tokens_details", "prompt_tokens_details"]) { + const details = usage[key]; + if (isObj(details)) { + const totalDetails = total[key] ?? (total[key] = {}); + for (const name in details) { + if (!hasOwn(details, name)) continue; + const count = details[name]; + if (typeof count === "number") Object.defineProperty(totalDetails, name, { + value: (hasOwn(totalDetails, name) ? totalDetails[name] ?? 0 : 0) + count, + enumerable: true, + configurable: true, + writable: true + }); + } + } + } + } + return total; +}, _AbstractChatCompletionRunner_throwIfAborted = function _AbstractChatCompletionRunner_throwIfAborted() { + if (this.controller.signal.aborted) throw this._userAbortError(); +}, _AbstractChatCompletionRunner_validateParams = function _AbstractChatCompletionRunner_validateParams(params) { + if (params.n != null && params.n > 1) throw new OpenAIError("ChatCompletion convenience helpers only support n=1 at this time. To use n>1, please use chat.completions.create() directly."); +}, _AbstractChatCompletionRunner_stringifyFunctionCallResult = function _AbstractChatCompletionRunner_stringifyFunctionCallResult(rawContent) { + if (typeof rawContent === "string") return rawContent; + if (rawContent === void 0) return "undefined"; + return JSON.stringify(rawContent); +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/ChatCompletionRunner.mjs +/** Executes function tools and follows up with non-streaming chat completion requests. */ +var ChatCompletionRunner = class ChatCompletionRunner extends AbstractChatCompletionRunner { + /** Starts a non-streaming tool loop and returns its event-driven conversation runner. */ + static runTools(client, params, options) { + const runner = new ChatCompletionRunner(); + const opts = { + ...options, + __metadata: { + ...options?.__metadata, + helperMethod: "runTools" + } + }; + runner._run(() => runner._runTools(client, params, runner, opts)); + return runner; + } + /** + * Appends a conversation message and emits text content for assistant replies. + * @param normalizeContent Defaults to true; initial history passes false to preserve caller-owned messages. + */ + _addMessage(message, emit = true, normalizeContent = true) { + super._addMessage(message, emit, normalizeContent); + if (emit && isAssistantMessage(message) && message.content) this._emit("content", message.content); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/_vendor/partial-json-parser/parser.mjs +const Allow = { + STR: 1, + NUM: 2, + ARR: 4, + OBJ: 8, + NULL: 16, + BOOL: 32, + NAN: 64, + INFINITY: 128, + MINUS_INFINITY: 256, + INF: 384, + SPECIAL: 496, + ATOM: 499, + COLLECTION: 12, + ALL: 511 +}; +var PartialJSON = class extends Error {}; +var MalformedJSON = class extends Error {}; +/** +* Parse incomplete JSON +* @param {string} jsonString Partial JSON to be parsed +* @param {number} allowPartial Specify what types are allowed to be partial, see {@link Allow} for details +* @returns The parsed JSON +* @throws {PartialJSON} If the JSON is incomplete (related to the `allow` parameter) +* @throws {MalformedJSON} If the JSON is malformed +*/ +function parseJSON(jsonString, allowPartial = Allow.ALL) { + if (typeof jsonString !== "string") throw new TypeError(`expecting str, got ${typeof jsonString}`); + if (!jsonString.trim()) throw new Error(`${jsonString} is empty`); + return _parseJSON(jsonString.trim(), allowPartial); +} +const _parseJSON = (jsonString, allow) => { + const length = jsonString.length; + let index = 0; + const markPartialJSON = (msg) => { + throw new PartialJSON(`${msg} at position ${index}`); + }; + const throwMalformedError = (msg) => { + throw new MalformedJSON(`${msg} at position ${index}`); + }; + const parseAny = () => { + skipBlank(); + if (index >= length) markPartialJSON("Unexpected end of input"); + if (jsonString[index] === "\"") return parseStr(); + if (jsonString[index] === "{") return parseObj(); + if (jsonString[index] === "[") return parseArr(); + if (jsonString.substring(index, index + 4) === "null" || Allow.NULL & allow && length - index < 4 && "null".startsWith(jsonString.substring(index))) { + index += 4; + return null; + } + if (jsonString.substring(index, index + 4) === "true" || Allow.BOOL & allow && length - index < 4 && "true".startsWith(jsonString.substring(index))) { + index += 4; + return true; + } + if (jsonString.substring(index, index + 5) === "false" || Allow.BOOL & allow && length - index < 5 && "false".startsWith(jsonString.substring(index))) { + index += 5; + return false; + } + if (jsonString.substring(index, index + 8) === "Infinity" || Allow.INFINITY & allow && length - index < 8 && "Infinity".startsWith(jsonString.substring(index))) { + index += 8; + return Infinity; + } + if (jsonString.substring(index, index + 9) === "-Infinity" || Allow.MINUS_INFINITY & allow && length - index > 1 && length - index < 9 && "-Infinity".startsWith(jsonString.substring(index))) { + index += 9; + return -Infinity; + } + if (jsonString.substring(index, index + 3) === "NaN" || Allow.NAN & allow && length - index < 3 && "NaN".startsWith(jsonString.substring(index))) { + index += 3; + return NaN; + } + return parseNum(); + }; + const parseStr = () => { + const start = index; + let escape = false; + index++; + while (index < length && (jsonString[index] !== "\"" || escape && jsonString[index - 1] === "\\")) { + escape = jsonString[index] === "\\" ? !escape : false; + index++; + } + if (jsonString.charAt(index) === "\"") try { + return JSON.parse(jsonString.substring(start, ++index - Number(escape))); + } catch (e) { + throwMalformedError(String(e)); + } + else if (Allow.STR & allow) try { + return JSON.parse(jsonString.substring(start, index - Number(escape)) + "\""); + } catch { + return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf("\\")) + "\""); + } + markPartialJSON("Unterminated string literal"); + }; + const parseObj = () => { + index++; + skipBlank(); + const obj = {}; + try { + while (jsonString[index] !== "}") { + skipBlank(); + if (index >= length && Allow.OBJ & allow) return obj; + const key = parseStr(); + skipBlank(); + index++; + try { + const value = parseAny(); + Object.defineProperty(obj, key, { + value, + writable: true, + enumerable: true, + configurable: true + }); + } catch (e) { + if (Allow.OBJ & allow) return obj; + throw e; + } + skipBlank(); + if (jsonString[index] === ",") index++; + } + } catch { + if (Allow.OBJ & allow) return obj; + markPartialJSON("Expected '}' at end of object"); + } + index++; + return obj; + }; + const parseArr = () => { + index++; + const arr = []; + try { + while (jsonString[index] !== "]") { + arr.push(parseAny()); + skipBlank(); + if (jsonString[index] === ",") index++; + } + } catch { + if (Allow.ARR & allow) return arr; + markPartialJSON("Expected ']' at end of array"); + } + index++; + return arr; + }; + const parseNum = () => { + if (index === 0) { + if (jsonString === "-" && Allow.NUM & allow) markPartialJSON("Not sure what '-' is"); + try { + return JSON.parse(jsonString); + } catch (e) { + if (Allow.NUM & allow) try { + if (jsonString[jsonString.length - 1] === ".") return JSON.parse(jsonString.substring(0, jsonString.lastIndexOf("."))); + return JSON.parse(jsonString.substring(0, jsonString.lastIndexOf("e"))); + } catch {} + throwMalformedError(String(e)); + } + } + const start = index; + if (jsonString[index] === "-") index++; + while (jsonString[index] && !",]}".includes(jsonString[index])) index++; + if (index === length && !(Allow.NUM & allow)) markPartialJSON("Unterminated number literal"); + const number = jsonString.substring(start, index); + try { + return JSON.parse(number); + } catch { + if (number === "-" && Allow.NUM & allow) markPartialJSON("Not sure what '-' is"); + try { + return JSON.parse(number.substring(0, number.lastIndexOf("e"))); + } catch (e) { + throwMalformedError(String(e)); + } + } + }; + const skipBlank = () => { + while (index < length && " \n\r ".includes(jsonString[index])) index++; + }; + return parseAny(); +}; +const partialParse = (input) => parseJSON(input, Allow.ALL ^ Allow.NUM); +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/ChatCompletionStream.mjs +var _ChatCompletionStream_instances; +var _ChatCompletionStream_params; +var _ChatCompletionStream_rejectsUnfinishedTurns; +var _ChatCompletionStream_audioDoneChoiceIndexes; +var _ChatCompletionStream_choiceEventStates; +var _ChatCompletionStream_currentChatCompletionSnapshot; +var _ChatCompletionStream_hasAutoParseableTool; +var _ChatCompletionStream_partialJSONParseBudget; +var _ChatCompletionStream_beginRequest; +var _ChatCompletionStream_getChoiceEventState; +var _ChatCompletionStream_addChunk; +var _ChatCompletionStream_emitToolCallDoneEvent; +var _ChatCompletionStream_emitContentDoneEvents; +var _ChatCompletionStream_validateStructuredSnapshots; +var _ChatCompletionStream_endRequest; +var _ChatCompletionStream_accumulateChatCompletion; +function parseStructuredStreamingJSON(content) { + try { + return partialParse(content); + } catch (error) { + if (error instanceof MalformedJSON || error instanceof SyntaxError) return parseResponseFormatContent({ + type: "json_schema", + $parseRaw: void 0 + }, content); + throw error; + } +} +const CHAT_COMPLETION_READABLE_STREAM_MESSAGE_PREFIX = "chat.completion.chunk.message:"; +/** Encodes a tool-result message as a backwards-compatible, empty completion chunk. */ +function makeChatCompletionReadableStreamMessageChunk(chunk, message, toolCallIds) { + const payload = { + type: "message", + message, + ...toolCallIds ? { tool_call_ids: toolCallIds } : {} + }; + return { + id: chunk.id, + choices: [], + created: chunk.created, + model: chunk.model, + object: `${CHAT_COMPLETION_READABLE_STREAM_MESSAGE_PREFIX}${JSON.stringify(payload)}` + }; +} +function isChatCompletionReadableStreamMessage(item) { + return "type" in item && item.type === "message" && "message" in item || "object" in item && typeof item.object === "string" && item.object.startsWith(CHAT_COMPLETION_READABLE_STREAM_MESSAGE_PREFIX); +} +function getChatCompletionReadableStreamMessage(item) { + if ("type" in item) return item; + return JSON.parse(item.object.slice(30)); +} +const MAX_STREAM_CHOICES = 128; +const MAX_STREAM_TOOL_CALLS = 128; +const MAX_PARTIAL_JSON_BYTES = 16777216; +const MAX_PARTIAL_JSON_FRAGMENTS = 65536; +const MAX_PARTIAL_JSON_DEPTH = 128; +const MAX_PARTIAL_JSON_PARSE_WORK = 67108864; +const EAGER_PARTIAL_JSON_BYTES = 1024; +function createPartialJSONParseState() { + return { + bytes: 0, + depth: 0, + fragments: 0, + work: 0, + escaped: false, + has_non_whitespace: false, + in_string: false, + last_parsed_bytes: 0, + pending_high_surrogate: false + }; +} +function recordPartialJSONFragment(state, budget, fragment, validationWorkBudget) { + if (budget.fragments >= MAX_PARTIAL_JSON_FRAGMENTS) throw new OpenAIError("Chat completion stream exceeded its structured JSON fragment limit"); + let bytes = 0; + let { depth, escaped, has_non_whitespace: hasNonWhitespace, in_string: inString } = state; + let completed = false; + let firstCharacter = true; + for (const character of fragment) { + const previousBytes = bytes; + const codePoint = character.codePointAt(0); + if (firstCharacter && state.pending_high_surrogate && codePoint >= 56320 && codePoint <= 57343) bytes += 1; + else if (codePoint <= 127) bytes += 1; + else if (codePoint <= 2047) bytes += 2; + else if (codePoint <= 65535) bytes += 3; + else bytes += 4; + firstCharacter = false; + if (budget.bytes + bytes > MAX_PARTIAL_JSON_BYTES) throw new OpenAIError("Chat completion stream exceeded its structured JSON byte limit"); + if (validationWorkBudget && validationWorkBudget.work + bytes > MAX_PARTIAL_JSON_PARSE_WORK) { + validationWorkBudget.work += previousBytes; + throw new OpenAIError("Chat completion stream exceeded its structured JSON parse-work limit"); + } + if (character !== " " && character !== "\n" && character !== "\r" && character !== " ") hasNonWhitespace = true; + if (inString) { + if (escaped) escaped = false; + else if (character === "\\") escaped = true; + else if (character === "\"") { + inString = false; + completed || (completed = depth === 0); + } + continue; + } + if (character === "\"") inString = true; + else if (character === "{" || character === "[") { + depth += 1; + if (depth > MAX_PARTIAL_JSON_DEPTH) throw new OpenAIError("Chat completion stream exceeded its structured JSON nesting depth limit"); + } else if ((character === "}" || character === "]") && depth > 0) { + depth -= 1; + completed || (completed = depth === 0); + } + } + state.bytes += bytes; + state.fragments += 1; + state.depth = depth; + state.escaped = escaped; + state.has_non_whitespace = hasNonWhitespace; + state.in_string = inString; + if (fragment.length > 0) { + const finalCodeUnit = fragment.codePointAt(fragment.length - 1) ?? 0; + state.pending_high_surrogate = finalCodeUnit >= 55296 && finalCodeUnit <= 56319; + } + budget.bytes += bytes; + budget.fragments += 1; + if (validationWorkBudget) validationWorkBudget.work += bytes; + if (!hasNonWhitespace || bytes === 0) return false; + const minimumGrowth = Math.max(EAGER_PARTIAL_JSON_BYTES, Math.floor(state.last_parsed_bytes / 2)); + if (state.bytes > EAGER_PARTIAL_JSON_BYTES && !completed && state.bytes - state.last_parsed_bytes < minimumGrowth) return false; + return true; +} +function reservePartialJSONParse(state, budget) { + if (budget.work + state.bytes > MAX_PARTIAL_JSON_PARSE_WORK) return false; + budget.work += state.bytes; + state.work += state.bytes; + state.last_parsed_bytes = state.bytes; + return true; +} +function captureStructuredJSONSnapshot(snapshot, property) { + const descriptor = Object.getOwnPropertyDescriptor(snapshot, property); + if (!descriptor) { + let prototype = Object.getPrototypeOf(snapshot); + for (let depth = 0; prototype !== null; depth += 1) { + if (depth >= MAX_PARTIAL_JSON_DEPTH || Object.getOwnPropertyDescriptor(prototype, property)) throw new OpenAIError("Chat completion stream contains an unsafe structured JSON snapshot"); + prototype = Object.getPrototypeOf(prototype); + } + return; + } + if (!("value" in descriptor) || typeof descriptor.value !== "string" && descriptor.value !== null && descriptor.value !== void 0) throw new OpenAIError("Chat completion stream contains an unsafe structured JSON snapshot"); + return descriptor.value; +} +function captureStructuredMessageSnapshot(choice) { + const descriptor = Object.getOwnPropertyDescriptor(choice, "message"); + if (!descriptor || !("value" in descriptor) || typeof descriptor.value !== "object" || descriptor.value === null) throw new OpenAIError("Chat completion stream contains an unsafe structured JSON snapshot"); + return descriptor.value; +} +function captureSnapshotArray(snapshot, property, maximum, kind) { + const descriptor = Object.getOwnPropertyDescriptor(snapshot, property); + if (!descriptor) { + let prototype = Object.getPrototypeOf(snapshot); + for (let depth = 0; prototype !== null; depth += 1) { + if (depth >= MAX_PARTIAL_JSON_DEPTH || Object.getOwnPropertyDescriptor(prototype, property)) throw new OpenAIError(`Chat completion stream contains an unsafe snapshot ${kind} collection`); + prototype = Object.getPrototypeOf(prototype); + } + return; + } + if (!("value" in descriptor) || !Array.isArray(descriptor.value)) throw new OpenAIError(`Chat completion stream contains an unsafe snapshot ${kind} collection`); + const length = Object.getOwnPropertyDescriptor(descriptor.value, "length"); + if (!length || !("value" in length) || !Number.isSafeInteger(length.value) || length.value > maximum) throw new OpenAIError(`Chat completion stream exceeded its snapshot ${kind} limit`); + return descriptor.value; +} +function captureSnapshotArrayItem(array, index) { + const descriptor = Object.getOwnPropertyDescriptor(array, index); + if (!descriptor) return; + if (!("value" in descriptor)) throw new OpenAIError("Chat completion stream contains an unsafe structured JSON snapshot"); + return descriptor.value; +} +function mapCapturedSnapshotArray(array, maximum, kind, map) { + const descriptor = Object.getOwnPropertyDescriptor(array, "length"); + const length = descriptor && "value" in descriptor ? descriptor.value : void 0; + if (typeof length !== "number" || !Number.isSafeInteger(length) || length < 0 || length > maximum) throw new OpenAIError(`Chat completion stream exceeded its snapshot ${kind} limit`); + const mapped = []; + mapped.length = length; + for (let index = 0; index < length; index += 1) { + const item = Object.getOwnPropertyDescriptor(array, index); + if (!item) continue; + if (!("value" in item)) throw new OpenAIError("Chat completion stream contains an unsafe structured JSON snapshot"); + mapped[index] = map(item.value, index); + } + return mapped; +} +function validateStructuredJSONSnapshot(value, budget, validationWorkBudget) { + const state = createPartialJSONParseState(); + const parseBudget = budget ?? { + bytes: 0, + fragments: 0, + work: 0 + }; + recordPartialJSONFragment(state, parseBudget, value, validationWorkBudget); + if (!reservePartialJSONParse(state, parseBudget)) throw new OpenAIError("Chat completion stream exceeded its structured JSON parse-work limit"); + return value; +} +function ownFunctionToolIdentity(toolCall) { + const type = Object.getOwnPropertyDescriptor(toolCall, "type"); + const fn = Object.getOwnPropertyDescriptor(toolCall, "function"); + if (!type || !("value" in type) || type.value !== "function" || !fn || !("value" in fn)) return; + if (typeof fn.value !== "object" || fn.value === null) return; + const name = Object.getOwnPropertyDescriptor(fn.value, "name"); + if (!name || !("value" in name) || typeof name.value !== "string" || name.value.length === 0) return; + return { + type: "function", + name: name.value + }; +} +function assertBoundToolCallIdentity(toolCall, identity) { + const current = ownFunctionToolIdentity(toolCall); + if (!current || current.name !== identity.name || current.type !== identity.type) throw new OpenAIError("Chat completion stream contains a changed tool call identity"); +} +function assignOwnProperties(target, source) { + if (Object.prototype.propertyIsEnumerable.call(source, "__proto__") && !hasOwn(target, "__proto__")) Object.defineProperty(target, "__proto__", { + value: void 0, + writable: true, + enumerable: true, + configurable: true + }); + return Object.assign(target, source); +} +function cloneParserConfigObject(value, stableFields = []) { + const descriptors = Object.getOwnPropertyDescriptors(value); + for (const field of stableFields) { + const descriptor = descriptors[field]; + if (!descriptor && !(field in value)) continue; + descriptors[field] = { + value: descriptor && "value" in descriptor ? descriptor.value : Reflect.get(value, field, value), + enumerable: descriptor?.enumerable ?? false, + configurable: descriptor?.configurable ?? true, + writable: descriptor && "writable" in descriptor ? descriptor.writable : false + }; + } + return Object.create(Object.getPrototypeOf(value), descriptors); +} +function snapshotChatCompletionParserParams(params) { + const snapshot = cloneParserConfigObject(params); + if (params.tools) { + const stableTools = []; + const lengthDescriptor = Object.getOwnPropertyDescriptor(params.tools, "length"); + const length = lengthDescriptor && "value" in lengthDescriptor ? lengthDescriptor.value : void 0; + const toolCount = typeof length === "number" && Number.isSafeInteger(length) && length >= 0 ? Math.min(length, MAX_STREAM_TOOL_CALLS) : 0; + for (let index = 0; index < toolCount; index += 1) { + const item = Object.getOwnPropertyDescriptor(params.tools, String(index)); + if (!item || !("value" in item)) { + stableTools.length = index + 1; + continue; + } + const tool = item.value; + const stableTool = cloneParserConfigObject(tool, [ + "type", + "$brand", + "$parseRaw", + "$callback", + "function" + ]); + const descriptors = Object.getOwnPropertyDescriptors(stableTool); + if (isChatCompletionFunctionTool(stableTool)) { + const descriptor = descriptors.function; + descriptors.function = { + ...descriptor && "value" in descriptor ? descriptor : { + configurable: true, + enumerable: true, + writable: true + }, + value: cloneParserConfigObject(stableTool.function, ["name", "strict"]) + }; + } + stableTools[index] = Object.create(Object.getPrototypeOf(tool), descriptors); + } + snapshot.tools = stableTools; + } + if (params.response_format) snapshot.response_format = cloneParserConfigObject(params.response_format, [ + "type", + "$brand", + "$parseRaw" + ]); + return snapshot; +} +const MAX_SERIALIZED_PARSER_SCHEMA_NODES = 4096; +const stringifyParserSchemaValue = JSON.stringify; +const MAX_SERIALIZED_PARSER_SCHEMA_BYTES = 1048576; +const MAX_SERIALIZED_PARSER_SCHEMA_DEPTH = 64; +const OMITTED_SERIALIZED_PARSER_VALUE = Symbol("omitted serialized parser value"); +const UNSAFE_SERIALIZED_PARSER_VALUE = Symbol("unsafe serialized parser value"); +function canonicalSerializedParserSchema(value, budget) { + const ancestors = /* @__PURE__ */ new WeakSet(); + const charge = (bytes) => { + if (!Number.isSafeInteger(bytes) || bytes < 0 || budget.bytes + bytes > MAX_SERIALIZED_PARSER_SCHEMA_BYTES) return false; + budget.bytes += bytes; + return true; + }; + const visit = (current, depth) => { + if (depth > MAX_SERIALIZED_PARSER_SCHEMA_DEPTH || budget.nodes >= MAX_SERIALIZED_PARSER_SCHEMA_NODES) return UNSAFE_SERIALIZED_PARSER_VALUE; + budget.nodes += 1; + if (current === void 0 || typeof current === "function" || typeof current === "symbol") return OMITTED_SERIALIZED_PARSER_VALUE; + if (typeof current === "bigint") return UNSAFE_SERIALIZED_PARSER_VALUE; + if (current === null || typeof current === "boolean" || typeof current === "number") { + const serialized = stringifyParserSchemaValue(current); + return typeof serialized === "string" && charge(serialized.length) ? serialized : UNSAFE_SERIALIZED_PARSER_VALUE; + } + if (typeof current === "string") { + if (!charge(current.length * 6 + 2)) return UNSAFE_SERIALIZED_PARSER_VALUE; + return stringifyParserSchemaValue(current); + } + if (typeof current !== "object" || ancestors.has(current)) return UNSAFE_SERIALIZED_PARSER_VALUE; + const array = Array.isArray(current); + const prototype = Object.getPrototypeOf(current); + if (array && prototype !== Array.prototype || !array && prototype !== null && prototype !== Object.prototype) return UNSAFE_SERIALIZED_PARSER_VALUE; + for (let owner = current; owner !== null; owner = Object.getPrototypeOf(owner)) { + const serializer = Object.getOwnPropertyDescriptor(owner, "toJSON"); + if (!serializer) continue; + if (!("value" in serializer) || typeof serializer.value === "function") return UNSAFE_SERIALIZED_PARSER_VALUE; + break; + } + ancestors.add(current); + try { + if (!charge(2)) return UNSAFE_SERIALIZED_PARSER_VALUE; + if (array) { + const lengthDescriptor = Object.getOwnPropertyDescriptor(current, "length"); + const length = lengthDescriptor && "value" in lengthDescriptor ? lengthDescriptor.value : void 0; + if (typeof length !== "number" || !Number.isSafeInteger(length) || length < 0 || length > MAX_SERIALIZED_PARSER_SCHEMA_NODES - budget.nodes) return UNSAFE_SERIALIZED_PARSER_VALUE; + const items = []; + for (let index = 0; index < length; index += 1) { + const key = String(index); + const descriptor = Object.getOwnPropertyDescriptor(current, key); + if (!descriptor) { + if (Object.getOwnPropertyDescriptor(Array.prototype, key) || Object.getOwnPropertyDescriptor(Object.prototype, key)) return UNSAFE_SERIALIZED_PARSER_VALUE; + budget.nodes += 1; + if (!charge(4)) return UNSAFE_SERIALIZED_PARSER_VALUE; + items.push("null"); + continue; + } + if (!("value" in descriptor)) return UNSAFE_SERIALIZED_PARSER_VALUE; + const item = visit(descriptor.value, depth + 1); + if (item === UNSAFE_SERIALIZED_PARSER_VALUE) return item; + items.push(item === OMITTED_SERIALIZED_PARSER_VALUE ? "null" : item); + } + return `[${items.join(",")}]`; + } + const keys = Reflect.ownKeys(current); + if (keys.length > MAX_SERIALIZED_PARSER_SCHEMA_NODES - budget.nodes) return UNSAFE_SERIALIZED_PARSER_VALUE; + const entries = []; + for (const key of keys) { + if (typeof key !== "string") continue; + const descriptor = Object.getOwnPropertyDescriptor(current, key); + if (!descriptor) return UNSAFE_SERIALIZED_PARSER_VALUE; + if (!descriptor.enumerable) continue; + if (!("value" in descriptor)) return UNSAFE_SERIALIZED_PARSER_VALUE; + entries.push([key, descriptor.value]); + } + entries.sort(([left], [right]) => { + if (left === right) return 0; + return left < right ? -1 : 1; + }); + const fields = []; + for (const [key, entry] of entries) { + const normalized = visit(entry, depth + 1); + if (normalized === UNSAFE_SERIALIZED_PARSER_VALUE) return normalized; + if (normalized === OMITTED_SERIALIZED_PARSER_VALUE) continue; + if (!charge(key.length * 6 + 3)) return UNSAFE_SERIALIZED_PARSER_VALUE; + fields.push(`${stringifyParserSchemaValue(key)}:${normalized}`); + } + return `{${fields.join(",")}}`; + } finally { + ancestors.delete(current); + } + }; + try { + const normalized = visit(value, 0); + return typeof normalized === "string" ? normalized : void 0; + } catch { + return; + } +} +function rememberSerializedParserSchema(signatures, source, holder, key) { + const parser = Object.getOwnPropertyDescriptor(source, "$parseRaw"); + const schema = Object.getOwnPropertyDescriptor(holder, key); + if (!parser || !("value" in parser) || typeof parser.value !== "function" || !schema || !("value" in schema)) return; + const normalized = canonicalSerializedParserSchema(schema.value, { + nodes: 0, + bytes: 0 + }); + if (normalized !== void 0) signatures.set(source, normalized); +} +function hasMatchingSerializedParserSchema(signatures, source, holder, key, value) { + const expected = source && signatures.get(source); + const descriptor = Object.getOwnPropertyDescriptor(holder, key); + return expected !== void 0 && descriptor !== void 0 && "value" in descriptor && canonicalSerializedParserSchema(value, { + nodes: 0, + bytes: 0 + }) === expected; +} +function serializedParserDescriptor(descriptor, value) { + return descriptor && "value" in descriptor ? { + ...descriptor, + value + } : { + configurable: true, + enumerable: true, + writable: true, + value + }; +} +function shadowSerializedParserMetadata(descriptors, source, fields) { + for (const field of fields) { + const descriptor = descriptors[field]; + if (!descriptor && !(field in source)) continue; + descriptors[field] = descriptor && "value" in descriptor ? { + ...descriptor, + value: void 0 + } : { + configurable: descriptor?.configurable ?? true, + enumerable: descriptor?.enumerable ?? false, + writable: false, + value: void 0 + }; + } +} +function snapshotSerializedParserTool(serialized) { + const source = serialized.source ?? { + type: serialized.type, + ...serialized.type === "function" ? { function: {} } : {} + }; + const descriptors = Object.getOwnPropertyDescriptors(source); + descriptors.type = serializedParserDescriptor(descriptors.type, serialized.type); + if (serialized.type !== "function" || !serialized.function) { + if (descriptors.function) descriptors.function = serializedParserDescriptor(descriptors.function, void 0); + shadowSerializedParserMetadata(descriptors, source, [ + "$brand", + "$parseRaw", + "$callback" + ]); + return Object.create(Object.getPrototypeOf(source), descriptors); + } + const descriptor = descriptors.function; + const original = descriptor && "value" in descriptor && typeof descriptor.value === "object" && descriptor.value !== null ? descriptor.value : {}; + const functionDescriptors = Object.getOwnPropertyDescriptors(original); + functionDescriptors["name"] = serializedParserDescriptor(functionDescriptors["name"], serialized.function.name); + functionDescriptors["strict"] = serializedParserDescriptor(functionDescriptors["strict"], serialized.function.strict); + descriptors.function = serializedParserDescriptor(descriptor, Object.create(Object.getPrototypeOf(original), functionDescriptors)); + if (!serialized.function.schemaMatches) shadowSerializedParserMetadata(descriptors, source, [ + "$brand", + "$parseRaw", + "$callback" + ]); + return Object.create(Object.getPrototypeOf(source), descriptors); +} +function snapshotSerializedResponseFormat(serialized) { + const source = serialized.source ?? { type: serialized.type }; + const descriptors = Object.getOwnPropertyDescriptors(source); + descriptors.type = serializedParserDescriptor(descriptors.type, serialized.type); + if (serialized.type !== "json_schema" || !serialized.source || !serialized.schemaMatches) shadowSerializedParserMetadata(descriptors, source, ["$brand", "$parseRaw"]); + return Object.create(Object.getPrototypeOf(source), descriptors); +} +function ownSerializedParserObject(holder, key) { + const descriptor = Object.getOwnPropertyDescriptor(holder, key); + if (!descriptor || !("value" in descriptor)) return; + const { value } = descriptor; + return typeof value === "object" && value !== null ? value : void 0; +} +function observeSerializedChatCompletionParserParams(body, initial, update) { + const originalToolOwners = /* @__PURE__ */ new WeakMap(); + const originalSchemaSignatures = /* @__PURE__ */ new WeakMap(); + if (body.tools) for (let index = 0; index < body.tools.length && index < MAX_STREAM_TOOL_CALLS; index += 1) { + const owner = ownSerializedParserObject(body.tools, String(index)); + const source = initial.tools?.[index]; + if (owner && source) { + originalToolOwners.set(owner, source); + const originalFunction = ownSerializedParserObject(source, "function"); + if (originalFunction) rememberSerializedParserSchema(originalSchemaSignatures, source, originalFunction, "parameters"); + } + } + if (initial.response_format) rememberSerializedParserSchema(originalSchemaSignatures, initial.response_format, initial.response_format, "json_schema"); + let root; + let tools; + let responseFormat; + let responseFrame; + let frames = []; + let toolFrames = /* @__PURE__ */ new WeakMap(); + let actualToolOwners = /* @__PURE__ */ new Map(); + let functionFrames = /* @__PURE__ */ new WeakMap(); + return observeJSONRequestBody(body, { + value(holder, key, value) { + if (!root && key === "" && typeof value === "object" && value !== null) { + root = value; + tools = void 0; + responseFormat = void 0; + responseFrame = void 0; + frames = []; + toolFrames = /* @__PURE__ */ new WeakMap(); + actualToolOwners = /* @__PURE__ */ new Map(); + functionFrames = /* @__PURE__ */ new WeakMap(); + return; + } + if (holder === root && key === "response_format") { + if (typeof value === "object" && value !== null) { + responseFormat = value; + responseFrame = { + source: ownSerializedParserObject(holder, key) === body.response_format ? initial.response_format : void 0, + schemaMatches: false + }; + } + return; + } + if (holder === root && key === "tools") { + if (Array.isArray(value)) { + tools = new Proxy(value, { get(target, property) { + const actual = Reflect.get(target, property, target); + if (typeof property === "string") { + const index = Number(property); + if (Number.isSafeInteger(index) && index >= 0 && index < MAX_STREAM_TOOL_CALLS && String(index) === property) actualToolOwners.set(index, typeof actual === "object" && actual !== null ? actual : void 0); + } + return actual; + } }); + return tools; + } + return; + } + if (holder === tools) { + const index = Number(key); + if (!Number.isSafeInteger(index) || index < 0 || index >= MAX_STREAM_TOOL_CALLS || typeof value !== "object" || value === null) return; + const owner = actualToolOwners.get(index); + const frame = { source: owner ? originalToolOwners.get(owner) : void 0 }; + frames[index] = frame; + toolFrames.set(value, frame); + return; + } + const tool = toolFrames.get(holder); + if (tool) { + if (key === "type" && typeof value === "string") tool.type = value; + else if (key === "function" && typeof value === "object" && value !== null) { + const fn = { + source: tool.source, + schemaMatches: false + }; + tool.function = fn; + functionFrames.set(value, fn); + } + return; + } + if (holder === responseFormat && responseFrame) { + if (key === "type" && typeof value === "string") responseFrame.type = value; + else if (key === "json_schema") responseFrame.schemaMatches = hasMatchingSerializedParserSchema(originalSchemaSignatures, responseFrame.source, holder, key, value); + return; + } + const fn = functionFrames.get(holder); + if (fn) { + if (key === "name" && typeof value === "string") fn.name = value; + else if (key === "strict" && typeof value === "boolean") fn.strict = value; + else if (key === "parameters") fn.schemaMatches = hasMatchingSerializedParserSchema(originalSchemaSignatures, fn.source, holder, key, value); + } + }, + complete() { + if (!root) return; + const snapshot = cloneParserConfigObject(initial); + if (tools) { + const serializedTools = []; + for (let index = 0; index < frames.length; index += 1) { + const frame = frames[index]; + if (frame) serializedTools[index] = snapshotSerializedParserTool(frame); + } + snapshot.tools = serializedTools; + } else delete snapshot.tools; + if (responseFrame) snapshot.response_format = snapshotSerializedResponseFormat(responseFrame); + else delete snapshot.response_format; + update(snapshot); + root = void 0; + tools = void 0; + responseFormat = void 0; + responseFrame = void 0; + frames = []; + toolFrames = /* @__PURE__ */ new WeakMap(); + actualToolOwners = /* @__PURE__ */ new Map(); + functionFrames = /* @__PURE__ */ new WeakMap(); + } + }); +} +/** Streams chat completion chunks while accumulating snapshots, parsed output, and events. */ +var ChatCompletionStream = class ChatCompletionStream extends AbstractChatCompletionRunner { + /** Creates an unstarted stream, retaining request parameters for structured-output parsing. */ + constructor(params) { + super(); + _ChatCompletionStream_instances.add(this); + _ChatCompletionStream_params.set(this, void 0); + _ChatCompletionStream_rejectsUnfinishedTurns.set(this, false); + _ChatCompletionStream_audioDoneChoiceIndexes.set(this, void 0); + _ChatCompletionStream_choiceEventStates.set(this, void 0); + _ChatCompletionStream_currentChatCompletionSnapshot.set(this, void 0); + _ChatCompletionStream_hasAutoParseableTool.set(this, void 0); + _ChatCompletionStream_partialJSONParseBudget.set(this, void 0); + __classPrivateFieldSet(this, _ChatCompletionStream_params, params, "f"); + __classPrivateFieldSet(this, _ChatCompletionStream_audioDoneChoiceIndexes, /* @__PURE__ */ new Set(), "f"); + __classPrivateFieldSet(this, _ChatCompletionStream_choiceEventStates, [], "f"); + __classPrivateFieldSet(this, _ChatCompletionStream_hasAutoParseableTool, false, "f"); + const tools = params?.tools; + const lengthDescriptor = tools && Object.getOwnPropertyDescriptor(tools, "length"); + const length = lengthDescriptor && "value" in lengthDescriptor ? lengthDescriptor.value : void 0; + if (tools && typeof length === "number" && Number.isSafeInteger(length) && length >= 0) for (let index = 0; index < Math.min(length, MAX_STREAM_TOOL_CALLS); index += 1) { + const descriptor = Object.getOwnPropertyDescriptor(tools, String(index)); + if (!descriptor || !("value" in descriptor)) continue; + const tool = descriptor.value; + if (isChatCompletionFunctionTool(tool) && (isAutoParsableTool$1(tool) || tool.function.strict === true)) { + __classPrivateFieldSet(this, _ChatCompletionStream_hasAutoParseableTool, true, "f"); + break; + } + } + __classPrivateFieldSet(this, _ChatCompletionStream_partialJSONParseBudget, { + bytes: 0, + fragments: 0, + work: 0 + }, "f"); + } + /** The latest accumulated completion, or `undefined` before a chunk arrives or after finalization. */ + get currentChatCompletionSnapshot() { + return __classPrivateFieldGet(this, _ChatCompletionStream_currentChatCompletionSnapshot, "f"); + } + /** + * Intended for use on the frontend, consuming a stream produced with + * `.toReadableStream()` on the backend. + * + * Original input messages are not included in the serialized stream. Tool-result + * messages explicitly serialized by a streaming tool runner are replayed. + */ + static fromReadableStream(stream) { + const runner = new ChatCompletionStream(null); + runner._run(() => runner._fromReadableStream(stream)); + return runner; + } + /** Starts a streaming chat completion request and returns its event-driven helper. */ + static createChatCompletion(client, params, options) { + const runner = new ChatCompletionStream(params); + runner._run(() => runner._runChatCompletion(client, { + ...params, + stream: true + }, { + ...options, + __metadata: { + ...options?.__metadata, + helperMethod: "stream" + } + })); + return runner; + } + /** Rejects unfinished turns before tool callbacks while preserving ordinary stream and replay behavior. */ + _runTools(client, params, runner, options) { + __classPrivateFieldSet(this, _ChatCompletionStream_rejectsUnfinishedTurns, true, "f"); + return super._runTools(client, params, runner, options); + } + async _createChatCompletion(client, params, options) { + this._listenForAbort(options?.signal); + const requestParams = { + ...params, + stream: true + }; + __classPrivateFieldSet(this, _ChatCompletionStream_params, requestParams, "f"); + __classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_beginRequest).call(this); + const parserParams = snapshotChatCompletionParserParams(requestParams); + __classPrivateFieldSet(this, _ChatCompletionStream_params, parserParams, "f"); + __classPrivateFieldSet(this, _ChatCompletionStream_hasAutoParseableTool, parserParams.tools?.some((tool) => isChatCompletionFunctionTool(tool) && (isAutoParsableTool$1(tool) || tool.function.strict === true)) ?? false, "f"); + const stopObserving = requestParams.tools || requestParams.response_format ? observeSerializedChatCompletionParserParams(requestParams, parserParams, (serialized) => { + __classPrivateFieldSet(this, _ChatCompletionStream_params, serialized, "f"); + __classPrivateFieldSet(this, _ChatCompletionStream_hasAutoParseableTool, serialized.tools?.some((tool) => isChatCompletionFunctionTool(tool) && (isAutoParsableTool$1(tool) || tool.function.strict === true)) ?? false, "f"); + }) : void 0; + const stream = await client.chat.completions.create(requestParams, { + ...options, + signal: this.controller.signal + }).finally(stopObserving); + this._connected(); + for await (const chunk of stream) __classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_addChunk).call(this, chunk); + if (stream.controller.signal?.aborted) throw this._userAbortError(); + return this._addChatCompletion(__classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_endRequest).call(this)); + } + async _fromReadableStream(readableStream, options) { + this._listenForAbort(options?.signal); + __classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_beginRequest).call(this); + this._connected(); + const stream = Stream.fromReadableStream(readableStream, this.controller); + let chatId; + for await (const item of stream) { + if ("error" in item && hasOwn(item, "error") && typeof item.error === "object" && item.error !== null) throw new APIError(void 0, item.error, void 0, void 0); + if (isChatCompletionReadableStreamMessage(item)) { + const message = getChatCompletionReadableStreamMessage(item); + if (__classPrivateFieldGet(this, _ChatCompletionStream_currentChatCompletionSnapshot, "f")) { + const toolCalls = __classPrivateFieldGet(this, _ChatCompletionStream_currentChatCompletionSnapshot, "f").choices[0]?.message.tool_calls; + for (const [index, id] of message.tool_call_ids?.entries() ?? []) { + const toolCall = toolCalls?.[index]; + if (toolCall && id) toolCall.id = id; + } + this._addChatCompletion(__classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_endRequest).call(this)); + chatId = void 0; + } + this._addMessage(message.message); + continue; + } + const chunk = normalizeChatCompletionChunk(item); + if (chatId && chunk.id && chatId !== chunk.id) this._addChatCompletion(__classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_endRequest).call(this)); + __classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_addChunk).call(this, chunk); + if (chunk.id) chatId = chunk.id; + } + if (stream.controller.signal?.aborted) throw this._userAbortError(); + if (__classPrivateFieldGet(this, _ChatCompletionStream_currentChatCompletionSnapshot, "f")) return this._addChatCompletion(__classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_endRequest).call(this)); + const lastChatCompletion = this._chatCompletions[this._chatCompletions.length - 1]; + if (lastChatCompletion) return lastChatCompletion; + throw new OpenAIError(`request ended without sending any chunks`); + } + /** Iterates over raw API chunks; stopping iteration early aborts the underlying request. */ + [(_ChatCompletionStream_params = /* @__PURE__ */ new WeakMap(), _ChatCompletionStream_rejectsUnfinishedTurns = /* @__PURE__ */ new WeakMap(), _ChatCompletionStream_audioDoneChoiceIndexes = /* @__PURE__ */ new WeakMap(), _ChatCompletionStream_choiceEventStates = /* @__PURE__ */ new WeakMap(), _ChatCompletionStream_currentChatCompletionSnapshot = /* @__PURE__ */ new WeakMap(), _ChatCompletionStream_hasAutoParseableTool = /* @__PURE__ */ new WeakMap(), _ChatCompletionStream_partialJSONParseBudget = /* @__PURE__ */ new WeakMap(), _ChatCompletionStream_instances = /* @__PURE__ */ new WeakSet(), _ChatCompletionStream_beginRequest = function _ChatCompletionStream_beginRequest() { + if (this.ended) return; + __classPrivateFieldSet(this, _ChatCompletionStream_audioDoneChoiceIndexes, /* @__PURE__ */ new Set(), "f"); + __classPrivateFieldSet(this, _ChatCompletionStream_currentChatCompletionSnapshot, void 0, "f"); + __classPrivateFieldSet(this, _ChatCompletionStream_partialJSONParseBudget, { + bytes: 0, + fragments: 0, + work: 0 + }, "f"); + }, _ChatCompletionStream_getChoiceEventState = function _ChatCompletionStream_getChoiceEventState(choice) { + let state = __classPrivateFieldGet(this, _ChatCompletionStream_choiceEventStates, "f")[choice.index]; + if (state) return state; + state = { + content_done: false, + content_parse_state: void 0, + refusal_done: false, + logprobs_content_done: false, + logprobs_refusal_done: false, + done_tool_calls: /* @__PURE__ */ new Set(), + current_tool_call_index: null, + tool_call_parse_states: /* @__PURE__ */ new Map(), + tool_call_identities: /* @__PURE__ */ new Map() + }; + __classPrivateFieldGet(this, _ChatCompletionStream_choiceEventStates, "f")[choice.index] = state; + return state; + }, _ChatCompletionStream_addChunk = function _ChatCompletionStream_addChunk(chunk) { + if (this.ended) return; + const capturedChoiceFrames = /* @__PURE__ */ new WeakMap(); + const completion = __classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_accumulateChatCompletion).call(this, chunk, capturedChoiceFrames); + this._emit("chunk", chunk, completion); + for (const choice of chunk.choices) { + const capturedChoice = capturedChoiceFrames.get(choice); + const choiceSnapshot = completion.choices[capturedChoice?.index ?? choice.index]; + const capturedToolCalls = capturedChoice?.tool_calls ?? []; + const { delta } = choice; + const structuredResponse = isParseableResponseFormat(__classPrivateFieldGet(this, _ChatCompletionStream_params, "f")?.response_format); + const boundedSnapshot = structuredResponse || __classPrivateFieldGet(this, _ChatCompletionStream_hasAutoParseableTool, "f"); + const messageSnapshot = boundedSnapshot ? captureStructuredMessageSnapshot(choiceSnapshot) : choiceSnapshot.message; + const refusal = boundedSnapshot ? captureStructuredJSONSnapshot(messageSnapshot, "refusal") : messageSnapshot.refusal; + const messageContent = !refusal && structuredResponse ? captureStructuredJSONSnapshot(messageSnapshot, "content") : messageSnapshot.content; + if (delta?.content != null && messageSnapshot.role === "assistant" && messageContent) { + this._emit("content", delta.content, messageContent); + this._emit("content.delta", { + delta: delta.content, + snapshot: messageContent, + parsed: messageSnapshot.parsed + }); + } + if (delta?.refusal != null && messageSnapshot.role === "assistant" && refusal) this._emit("refusal.delta", { + delta: delta.refusal, + snapshot: refusal + }); + if (choice.logprobs?.content != null && messageSnapshot.role === "assistant") this._emit("logprobs.content.delta", { + content: choice.logprobs?.content, + snapshot: choiceSnapshot.logprobs?.content ?? [] + }); + if (choice.logprobs?.refusal != null && messageSnapshot.role === "assistant") this._emit("logprobs.refusal.delta", { + refusal: choice.logprobs?.refusal, + snapshot: choiceSnapshot.logprobs?.refusal ?? [] + }); + const state = __classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_getChoiceEventState).call(this, choiceSnapshot); + if (choiceSnapshot.finish_reason) { + __classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_emitContentDoneEvents).call(this, choiceSnapshot); + if (state.current_tool_call_index != null) __classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_emitToolCallDoneEvent).call(this, choiceSnapshot, state.current_tool_call_index); + } + for (const toolCall of capturedToolCalls) { + if (state.current_tool_call_index !== toolCall.index) { + __classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_emitContentDoneEvents).call(this, choiceSnapshot); + if (state.current_tool_call_index != null) __classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_emitToolCallDoneEvent).call(this, choiceSnapshot, state.current_tool_call_index); + } + state.current_tool_call_index = toolCall.index; + } + for (const toolCallDelta of capturedToolCalls) { + const toolCallSnapshot = messageSnapshot.tool_calls?.[toolCallDelta.index]; + if (!toolCallSnapshot?.type) continue; + if (toolCallSnapshot.type === "function") { + const boundIdentity = state.tool_call_identities.get(toolCallDelta.index); + let argumentsSnapshot; + if (boundIdentity?.parseable) { + const capturedArguments = captureStructuredJSONSnapshot(toolCallSnapshot.function, "arguments"); + if (typeof capturedArguments !== "string") throw new OpenAIError("Chat completion stream contains an unsafe structured JSON snapshot"); + argumentsSnapshot = capturedArguments; + } else argumentsSnapshot = toolCallSnapshot.function.arguments; + this._emit("tool_calls.function.arguments.delta", { + name: toolCallSnapshot.function.name, + index: toolCallDelta.index, + arguments: argumentsSnapshot, + parsed_arguments: toolCallSnapshot.function.parsed_arguments, + arguments_delta: toolCallDelta.arguments_delta + }); + } else if (toolCallSnapshot.type !== "custom"); + } + } + }, _ChatCompletionStream_emitToolCallDoneEvent = function _ChatCompletionStream_emitToolCallDoneEvent(choiceSnapshot, toolCallIndex) { + const state = __classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_getChoiceEventState).call(this, choiceSnapshot); + if (state.done_tool_calls.has(toolCallIndex)) return; + const toolCallSnapshot = (__classPrivateFieldGet(this, _ChatCompletionStream_hasAutoParseableTool, "f") ? captureStructuredMessageSnapshot(choiceSnapshot) : choiceSnapshot.message).tool_calls?.[toolCallIndex]; + if (!toolCallSnapshot) throw new Error("no tool call snapshot"); + const boundIdentity = state.tool_call_identities.get(toolCallIndex); + if (boundIdentity) assertBoundToolCallIdentity(toolCallSnapshot, boundIdentity); + if (!toolCallSnapshot.type) throw new Error("tool call snapshot missing `type`"); + if (toolCallSnapshot.type === "function") { + const inputTool = __classPrivateFieldGet(this, _ChatCompletionStream_params, "f")?.tools?.find((tool) => isChatCompletionFunctionTool(tool) && tool.function.name === toolCallSnapshot.function.name); + let parsedArguments = null; + const parseable = isAutoParsableTool$1(inputTool) || inputTool?.function.strict === true; + let argumentsSnapshot; + if (parseable) { + if (__classPrivateFieldGet(this, _ChatCompletionStream_currentChatCompletionSnapshot, "f")) __classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_validateStructuredSnapshots).call(this, __classPrivateFieldGet(this, _ChatCompletionStream_currentChatCompletionSnapshot, "f")); + const capturedArguments = captureStructuredJSONSnapshot(toolCallSnapshot.function, "arguments"); + if (typeof capturedArguments !== "string") throw new OpenAIError("Chat completion stream contains an unsafe structured JSON snapshot"); + argumentsSnapshot = capturedArguments; + } else argumentsSnapshot = toolCallSnapshot.function.arguments; + if (isAutoParsableTool$1(inputTool)) parsedArguments = inputTool.$parseRaw(validateStructuredJSONSnapshot(argumentsSnapshot)); + else if (inputTool?.function.strict) parsedArguments = parseResponseFormatContent({ + type: "json_schema", + $parseRaw: void 0 + }, validateStructuredJSONSnapshot(argumentsSnapshot)); + if (choiceSnapshot.finish_reason) state.done_tool_calls.add(toolCallIndex); + this._emit("tool_calls.function.arguments.done", { + name: toolCallSnapshot.function.name, + index: toolCallIndex, + arguments: argumentsSnapshot, + parsed_arguments: parsedArguments + }); + } else if (toolCallSnapshot.type !== "custom"); + }, _ChatCompletionStream_emitContentDoneEvents = function _ChatCompletionStream_emitContentDoneEvents(choiceSnapshot) { + const state = __classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_getChoiceEventState).call(this, choiceSnapshot); + const structuredResponse = isParseableResponseFormat(__classPrivateFieldGet(this, _ChatCompletionStream_params, "f")?.response_format); + const boundedSnapshot = structuredResponse || __classPrivateFieldGet(this, _ChatCompletionStream_hasAutoParseableTool, "f"); + const messageSnapshot = boundedSnapshot ? captureStructuredMessageSnapshot(choiceSnapshot) : choiceSnapshot.message; + const refusal = boundedSnapshot ? captureStructuredJSONSnapshot(messageSnapshot, "refusal") : messageSnapshot.refusal; + const parseableContent = !refusal && structuredResponse; + const content = parseableContent ? captureStructuredJSONSnapshot(messageSnapshot, "content") : messageSnapshot.content; + if (content != null && (content !== "" || !refusal && !messageSnapshot.tool_calls?.length && !messageSnapshot.function_call) && !state.content_done) { + if (parseableContent && __classPrivateFieldGet(this, _ChatCompletionStream_currentChatCompletionSnapshot, "f")) __classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_validateStructuredSnapshots).call(this, __classPrivateFieldGet(this, _ChatCompletionStream_currentChatCompletionSnapshot, "f")); + state.content_done = true; + this._emit("content.done", { + content, + parsed: refusal ? null : parseResponseFormatContent(__classPrivateFieldGet(this, _ChatCompletionStream_params, "f")?.response_format, parseableContent ? validateStructuredJSONSnapshot(content) : content) + }); + } + if (refusal && !state.refusal_done) { + state.refusal_done = true; + this._emit("refusal.done", { refusal }); + } + if (choiceSnapshot.logprobs?.content && !state.logprobs_content_done) { + state.logprobs_content_done = true; + this._emit("logprobs.content.done", { content: choiceSnapshot.logprobs.content }); + } + if (choiceSnapshot.logprobs?.refusal && !state.logprobs_refusal_done) { + state.logprobs_refusal_done = true; + this._emit("logprobs.refusal.done", { refusal: choiceSnapshot.logprobs.refusal }); + } + }, _ChatCompletionStream_validateStructuredSnapshots = function _ChatCompletionStream_validateStructuredSnapshots(snapshot) { + const finalJSONBudget = { + bytes: 0, + fragments: 0, + work: 0 + }; + const parseableContent = isParseableResponseFormat(__classPrivateFieldGet(this, _ChatCompletionStream_params, "f")?.response_format); + const validatedMessages = /* @__PURE__ */ new WeakMap(); + const choices = captureSnapshotArray(snapshot, "choices", MAX_STREAM_CHOICES, "choice"); + if (!choices) throw new OpenAIError("Chat completion stream contains an unsafe snapshot choice collection"); + for (let choiceIndex = 0; choiceIndex < choices.length; choiceIndex += 1) { + const choice = captureSnapshotArrayItem(choices, choiceIndex); + if (!choice) continue; + const message = captureStructuredMessageSnapshot(choice); + const refusal = captureStructuredJSONSnapshot(message, "refusal"); + const content = captureStructuredJSONSnapshot(message, "content"); + const validatedTools = /* @__PURE__ */ new Map(); + const toolCalls = captureSnapshotArray(message, "tool_calls", MAX_STREAM_TOOL_CALLS, "tool-call"); + validatedMessages.set(choice, Object.freeze({ + message, + content, + refusal, + toolCallCollection: toolCalls, + toolCalls: validatedTools + })); + const state = __classPrivateFieldGet(this, _ChatCompletionStream_choiceEventStates, "f")[choice.index]; + if (parseableContent && !refusal && typeof content === "string") validateStructuredJSONSnapshot(content, finalJSONBudget, __classPrivateFieldGet(this, _ChatCompletionStream_partialJSONParseBudget, "f")); + for (const [index, identity] of state?.tool_call_identities ?? []) { + const toolCall = toolCalls && captureSnapshotArrayItem(toolCalls, index); + if (!toolCall) throw new OpenAIError("Chat completion stream contains a changed tool call identity"); + assertBoundToolCallIdentity(toolCall, identity); + } + if (!__classPrivateFieldGet(this, _ChatCompletionStream_hasAutoParseableTool, "f")) continue; + for (let toolCallIndex = 0; toolCallIndex < (toolCalls?.length ?? 0); toolCallIndex += 1) { + const toolCall = captureSnapshotArrayItem(toolCalls, toolCallIndex); + if (!toolCall) continue; + const identity = ownFunctionToolIdentity(toolCall); + if (!identity) { + const type = Object.getOwnPropertyDescriptor(toolCall, "type"); + if (type && !("value" in type)) throw new OpenAIError("Chat completion stream contains an unsafe structured JSON snapshot"); + if (type?.value !== "function") continue; + const fn = Object.getOwnPropertyDescriptor(toolCall, "function"); + if (fn && !("value" in fn)) throw new OpenAIError("Chat completion stream contains an unsafe structured JSON snapshot"); + if (fn && typeof fn.value === "object" && fn.value !== null) { + const name = Object.getOwnPropertyDescriptor(fn.value, "name"); + if (name && !("value" in name)) throw new OpenAIError("Chat completion stream contains an unsafe structured JSON snapshot"); + } + continue; + } + if (!shouldParseToolCall(__classPrivateFieldGet(this, _ChatCompletionStream_params, "f"), { + type: identity.type, + function: { name: identity.name } + })) continue; + const descriptor = Object.getOwnPropertyDescriptor(toolCall, "function"); + if (!descriptor || !("value" in descriptor)) throw new OpenAIError("Chat completion stream contains an unsafe structured JSON snapshot"); + const fn = descriptor.value; + const argumentsSnapshot = captureStructuredJSONSnapshot(fn, "arguments"); + if (typeof argumentsSnapshot !== "string") throw new OpenAIError("Chat completion stream contains an unsafe structured JSON snapshot"); + validateStructuredJSONSnapshot(argumentsSnapshot, finalJSONBudget, __classPrivateFieldGet(this, _ChatCompletionStream_partialJSONParseBudget, "f")); + validatedTools.set(toolCallIndex, Object.freeze({ + tool: toolCall, + function: fn, + type: identity.type, + name: identity.name, + arguments: argumentsSnapshot + })); + } + } + return validatedMessages; + }, _ChatCompletionStream_endRequest = function _ChatCompletionStream_endRequest() { + if (this.ended) throw new OpenAIError(`stream has ended, this shouldn't happen`); + const snapshot = __classPrivateFieldGet(this, _ChatCompletionStream_currentChatCompletionSnapshot, "f"); + if (!snapshot) throw new OpenAIError(`request ended without sending any chunks`); + const validatedMessages = __classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_validateStructuredSnapshots).call(this, snapshot); + const audioDoneChoiceIndexes = __classPrivateFieldGet(this, _ChatCompletionStream_audioDoneChoiceIndexes, "f"); + __classPrivateFieldSet(this, _ChatCompletionStream_audioDoneChoiceIndexes, /* @__PURE__ */ new Set(), "f"); + __classPrivateFieldSet(this, _ChatCompletionStream_currentChatCompletionSnapshot, void 0, "f"); + __classPrivateFieldSet(this, _ChatCompletionStream_choiceEventStates, [], "f"); + return finalizeChatCompletion(snapshot, __classPrivateFieldGet(this, _ChatCompletionStream_params, "f"), audioDoneChoiceIndexes, validatedMessages); + }, _ChatCompletionStream_accumulateChatCompletion = function _ChatCompletionStream_accumulateChatCompletion(chunk, capturedChoiceFrames) { + var _a, _b, _c, _d, _e; + let snapshot = __classPrivateFieldGet(this, _ChatCompletionStream_currentChatCompletionSnapshot, "f"); + const { choices, obfuscation: _obfuscation, ...rest } = chunk; + if (!snapshot) { + const newSnapshot = { + ...rest, + choices: [] + }; + __classPrivateFieldSet(this, _ChatCompletionStream_currentChatCompletionSnapshot, newSnapshot, "f"); + snapshot = newSnapshot; + } else if (chunk.id) assignOwnProperties(snapshot, rest); + const requestedChoiceCount = __classPrivateFieldGet(this, _ChatCompletionStream_params, "f")?.n; + const maxChoices = typeof requestedChoiceCount === "number" && Number.isSafeInteger(requestedChoiceCount) && requestedChoiceCount > 0 ? Math.min(requestedChoiceCount, MAX_STREAM_CHOICES) : MAX_STREAM_CHOICES; + for (const chunkChoice of chunk.choices) { + const { delta, finish_reason, index, logprobs = null, ...other } = chunkChoice; + const capturedToolCalls = []; + capturedChoiceFrames.set(chunkChoice, Object.freeze({ + index, + tool_calls: capturedToolCalls + })); + if (!Number.isSafeInteger(index) || index < 0 || index >= maxChoices) throw new OpenAIError(`Chat completion stream contains an invalid choice index: ${index}`); + let choice = snapshot.choices[index]; + if (!choice) { + const newChoice = { + finish_reason: finish_reason ?? null, + index, + message: {}, + logprobs: null, + ...other + }; + snapshot.choices[index] = newChoice; + choice = newChoice; + } + if (isParseableResponseFormat(__classPrivateFieldGet(this, _ChatCompletionStream_params, "f")?.response_format) || __classPrivateFieldGet(this, _ChatCompletionStream_hasAutoParseableTool, "f")) captureStructuredJSONSnapshot(captureStructuredMessageSnapshot(choice), "refusal"); + if (logprobs) { + if (choice.logprobs) { + const { content, refusal, ...rest } = logprobs; + assignOwnProperties(choice.logprobs, rest); + if (content) { + (_a = choice.logprobs).content ?? (_a.content = []); + choice.logprobs.content.push(...content); + } + if (refusal) { + (_b = choice.logprobs).refusal ?? (_b.refusal = []); + choice.logprobs.refusal.push(...refusal); + } + } else { + choice.logprobs = { ...logprobs }; + if (logprobs.content) choice.logprobs.content = [...logprobs.content]; + if (logprobs.refusal) choice.logprobs.refusal = [...logprobs.refusal]; + } + } + if (finish_reason) { + choice.finish_reason = finish_reason; + if (__classPrivateFieldGet(this, _ChatCompletionStream_params, "f") && (__classPrivateFieldGet(this, _ChatCompletionStream_rejectsUnfinishedTurns, "f") || hasAutoParseableInput$1(__classPrivateFieldGet(this, _ChatCompletionStream_params, "f")))) { + if (finish_reason === "length") throw new LengthFinishReasonError(); + if (finish_reason === "content_filter") throw new ContentFilterFinishReasonError(); + } + } + assignOwnProperties(choice, other); + if (!delta) { + Object.freeze(capturedToolCalls); + continue; + } + __classPrivateFieldGet(this, _ChatCompletionStream_audioDoneChoiceIndexes, "f").delete(index); + const { audio, content, refusal, function_call, role, ...capturedDeltaFields } = delta; + const { tool_calls: capturedToolCallDelta, ...rest } = capturedDeltaFields; + const tool_calls = hasOwn(capturedDeltaFields, "tool_calls") ? capturedToolCallDelta : delta.tool_calls; + assignOwnProperties(choice.message, rest); + if (audio?.expires_at != null && audio.id == null && audio.data == null && audio.transcript == null && content == null && refusal == null && function_call == null && role == null && tool_calls == null && Object.keys(rest).length === 0) __classPrivateFieldGet(this, _ChatCompletionStream_audioDoneChoiceIndexes, "f").add(index); + if (refusal) choice.message.refusal = (choice.message.refusal || "") + refusal; + if (role) choice.message.role = role; + if (audio) { + const audioSnapshot = (_c = choice.message).audio ?? (_c.audio = {}); + if (audio.id != null) audioSnapshot.id = audio.id; + if (audio.data != null) audioSnapshot.data = (audioSnapshot.data ?? "") + audio.data; + if (audio.transcript != null) audioSnapshot.transcript = (audioSnapshot.transcript ?? "") + audio.transcript; + if (audio.expires_at != null) audioSnapshot.expires_at = audio.expires_at; + } + if (function_call) { + if (choice.message.function_call) { + if (function_call.name) choice.message.function_call.name = function_call.name; + if (function_call.arguments) { + (_d = choice.message.function_call).arguments ?? (_d.arguments = ""); + choice.message.function_call.arguments += function_call.arguments; + } + } else choice.message.function_call = function_call; + } + if (content != null) { + if (!choice.message.refusal && isParseableResponseFormat(__classPrivateFieldGet(this, _ChatCompletionStream_params, "f")?.response_format)) { + const eventState = __classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_getChoiceEventState).call(this, choice); + const parseState = eventState.content_parse_state ?? (eventState.content_parse_state = createPartialJSONParseState()); + const shouldParse = recordPartialJSONFragment(parseState, __classPrivateFieldGet(this, _ChatCompletionStream_partialJSONParseBudget, "f"), content); + choice.message.content = (captureStructuredJSONSnapshot(choice.message, "content") || "") + content; + if (!parseState.has_non_whitespace) choice.message.parsed = null; + else if (shouldParse && reservePartialJSONParse(parseState, __classPrivateFieldGet(this, _ChatCompletionStream_partialJSONParseBudget, "f"))) { + __classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_validateStructuredSnapshots).call(this, snapshot); + choice.message.parsed = parseStructuredStreamingJSON(validateStructuredJSONSnapshot(choice.message.content)); + } else if (content.length > 0) choice.message.parsed = null; + } else choice.message.content = (choice.message.content || "") + content; + } + if (tool_calls) { + const toolCallSnapshots = (_e = choice.message).tool_calls ?? (_e.tool_calls = []); + for (const toolCallDelta of tool_calls) { + const { index, id, type, function: fn, custom, ...rest } = toolCallDelta; + if (!Number.isSafeInteger(index) || index < 0 || index >= MAX_STREAM_TOOL_CALLS) throw new OpenAIError(`Chat completion stream contains an invalid tool call index: ${index}`); + let argumentsDelta = ""; + const tool_call = toolCallSnapshots[index] ?? (toolCallSnapshots[index] = {}); + const functionName = fn?.name; + const eventState = __classPrivateFieldGet(this, _ChatCompletionStream_hasAutoParseableTool, "f") ? __classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_getChoiceEventState).call(this, choice) : void 0; + let boundIdentity = eventState?.tool_call_identities.get(index); + if (boundIdentity) { + assertBoundToolCallIdentity(tool_call, boundIdentity); + if (type !== void 0 && type !== boundIdentity.type || functionName !== void 0 && functionName !== boundIdentity.name) throw new OpenAIError("Chat completion stream contains a changed tool call identity"); + } + assignOwnProperties(tool_call, rest); + if (id) tool_call.id = id; + if (type) tool_call.type = type; + if (custom) { + const customSnapshot = tool_call.custom ?? (tool_call.custom = { + name: custom.name ?? "", + input: "" + }); + if (custom.name) customSnapshot.name = custom.name; + if (custom.input) customSnapshot.input += custom.input; + } + if (fn) { + const functionSnapshot = tool_call.function ?? (tool_call.function = { + name: functionName ?? "", + arguments: "" + }); + if (functionName) functionSnapshot.name = functionName; + if (eventState && !boundIdentity) { + const identity = ownFunctionToolIdentity(tool_call); + const configuredTool = identity && __classPrivateFieldGet(this, _ChatCompletionStream_params, "f")?.tools?.find((tool) => isChatCompletionFunctionTool(tool) && tool.function.name === identity.name); + if (identity) { + boundIdentity = { + ...identity, + parseable: configuredTool !== void 0 && shouldParseToolCall(__classPrivateFieldGet(this, _ChatCompletionStream_params, "f"), { + type: identity.type, + function: { name: identity.name } + }) + }; + eventState.tool_call_identities.set(index, boundIdentity); + if (!boundIdentity.parseable) { + const provisionalState = eventState.tool_call_parse_states.get(index); + if (provisionalState) { + __classPrivateFieldGet(this, _ChatCompletionStream_partialJSONParseBudget, "f").bytes -= provisionalState.bytes; + __classPrivateFieldGet(this, _ChatCompletionStream_partialJSONParseBudget, "f").fragments -= provisionalState.fragments; + __classPrivateFieldGet(this, _ChatCompletionStream_partialJSONParseBudget, "f").work -= provisionalState.work; + eventState.tool_call_parse_states.delete(index); + } + } + } + } + const argumentFragment = fn.arguments; + if (argumentFragment != null) { + argumentsDelta = argumentFragment; + if (eventState && boundIdentity?.parseable !== false) { + let parseState = eventState.tool_call_parse_states.get(index); + if (!parseState) { + parseState = createPartialJSONParseState(); + eventState.tool_call_parse_states.set(index, parseState); + } + const shouldParse = recordPartialJSONFragment(parseState, __classPrivateFieldGet(this, _ChatCompletionStream_partialJSONParseBudget, "f"), argumentFragment); + const previousArguments = captureStructuredJSONSnapshot(functionSnapshot, "arguments"); + if (typeof previousArguments !== "string") throw new OpenAIError("Chat completion stream contains an unsafe structured JSON snapshot"); + functionSnapshot.arguments = previousArguments + argumentFragment; + if (shouldParse && boundIdentity?.parseable === true && reservePartialJSONParse(parseState, __classPrivateFieldGet(this, _ChatCompletionStream_partialJSONParseBudget, "f"))) { + __classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_validateStructuredSnapshots).call(this, snapshot); + functionSnapshot.parsed_arguments = parseStructuredStreamingJSON(validateStructuredJSONSnapshot(functionSnapshot.arguments)); + } else if (argumentFragment.length > 0 && hasOwn(functionSnapshot, "parsed_arguments")) functionSnapshot.parsed_arguments = void 0; + } else functionSnapshot.arguments += argumentFragment; + } + } + capturedToolCalls.push(Object.freeze({ + index, + arguments_delta: argumentsDelta + })); + } + } + Object.freeze(capturedToolCalls); + } + return snapshot; + }, Symbol.asyncIterator)]() { + return this._createIterator((push) => { + const onChunk = (chunk) => push(chunk); + this.on("chunk", onChunk); + return () => this.off("chunk", onChunk); + }, { onReturn: () => this.abort() }); + } + /** Serializes raw completion chunks into a readable stream for transfer to another runtime. */ + toReadableStream() { + return new Stream(this[Symbol.asyncIterator].bind(this), this.controller).toReadableStream(); + } +}; +function finalizeChatCompletion(snapshot, params, audioDoneChoiceIndexes, validatedMessages) { + const { id, choices, created, model, system_fingerprint, ...rest } = snapshot; + return maybeParseChatCompletion({ + ...rest, + id, + choices: mapCapturedSnapshotArray(choices, MAX_STREAM_CHOICES, "choice", (choice) => { + const validated = validatedMessages.get(choice); + if (!validated) throw new OpenAIError("Chat completion stream contains an unsafe structured JSON snapshot"); + const { message: sourceMessage, finish_reason, index, logprobs, ...choiceRest } = new Proxy(choice, { get(target, property, receiver) { + return property === "message" ? validated.message : Reflect.get(target, property, receiver); + } }); + const message = new Proxy(sourceMessage, { get(target, property, receiver) { + if (property === "content") return validated.content; + if (property === "refusal") return validated.refusal; + if (property === "tool_calls") return validated.toolCallCollection; + return Reflect.get(target, property, receiver); + } }); + const { content = null, function_call, tool_calls, audio, ...messageRest } = message; + const finishReason = finish_reason ?? (audioDoneChoiceIndexes.has(index) && isCompleteAudio(audio) ? "stop" : null); + if (!finishReason) throw new OpenAIError(`missing finish_reason for choice ${index}`); + const audioResponse = audio ? { audio } : {}; + const role = message.role; + if (!role) throw new OpenAIError(`missing role for choice ${index}`); + if (function_call) { + const { arguments: args, name } = function_call; + if (args == null) throw new OpenAIError(`missing function_call.arguments for choice ${index}`); + if (!name) throw new OpenAIError(`missing function_call.name for choice ${index}`); + return { + ...choiceRest, + message: { + ...audioResponse, + content, + function_call: { + arguments: args, + name + }, + role, + refusal: message.refusal ?? null + }, + finish_reason: finishReason, + index, + logprobs + }; + } + if (tool_calls) return { + ...choiceRest, + index, + finish_reason: finishReason, + logprobs, + message: { + ...messageRest, + ...audioResponse, + role, + content, + refusal: message.refusal ?? null, + tool_calls: mapCapturedSnapshotArray(tool_calls, MAX_STREAM_TOOL_CALLS, "tool-call", (tool_call, i) => { + const captured = validated.toolCalls.get(i); + if (!captured) { + const identity = ownFunctionToolIdentity(tool_call); + if (identity && shouldParseToolCall(params, { + type: identity.type, + function: { name: identity.name } + })) throw new OpenAIError("Chat completion stream contains an unsafe structured JSON snapshot"); + } + if (captured && captured.tool !== tool_call) throw new OpenAIError("Chat completion stream contains a changed tool call identity"); + const stableFunction = captured && new Proxy(captured.function, { get(target, property, receiver) { + if (property === "arguments") return captured.arguments; + if (property === "name") return captured.name; + return Reflect.get(target, property, receiver); + } }); + const stableTool = captured && stableFunction ? new Proxy(tool_call, { get(target, property, receiver) { + if (property === "type") return captured.type; + if (property === "function") return stableFunction; + return Reflect.get(target, property, receiver); + } }) : tool_call; + if (stableTool.type == null) throw new OpenAIError(`missing choices[${index}].tool_calls[${i}].type`); + if (stableTool.type === "custom") { + const { custom, type, id, ...toolRest } = stableTool; + const { input = "", name, ...customRest } = custom || {}; + if (name == null) throw new OpenAIError(`missing choices[${index}].tool_calls[${i}].custom.name`); + return { + ...toolRest, + id: id || `call_${uuid4()}`, + type, + custom: { + ...customRest, + name, + input + } + }; + } + const { function: fn, type, id, ...toolRest } = stableTool; + const { arguments: args, name, ...fnRest } = fn || {}; + if (name == null) throw new OpenAIError(`missing choices[${index}].tool_calls[${i}].function.name`); + if (args == null) throw new OpenAIError(`missing choices[${index}].tool_calls[${i}].function.arguments`); + return { + ...toolRest, + id: id || `call_${uuid4()}`, + type, + function: { + ...fnRest, + name, + arguments: args + } + }; + }) + } + }; + return { + ...choiceRest, + message: { + ...messageRest, + ...audioResponse, + content, + role, + refusal: message.refusal ?? null + }, + finish_reason: finishReason, + index, + logprobs + }; + }), + created, + model, + object: "chat.completion", + ...system_fingerprint ? { system_fingerprint } : {} + }, params); +} +function isCompleteAudio(audio) { + return audio?.id != null && audio.data != null && audio.transcript != null && audio.expires_at != null; +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/ChatCompletionStreamingRunner.mjs +/** Executes function tools while streaming every intermediate chat completion. */ +var ChatCompletionStreamingRunner = class ChatCompletionStreamingRunner extends ChatCompletionStream { + /** Restores a serialized tool run, including intermediate completions and tool-result messages. */ + static fromReadableStream(stream) { + const runner = new ChatCompletionStreamingRunner(null); + runner._run(() => runner._fromReadableStream(stream)); + return runner; + } + /** Serializes completion chunks and tool-result messages for replay in another runtime. */ + toReadableStream() { + let lastChunk; + let toolCallIds; + const iterator = this._createIterator((push) => { + const onChunk = (chunk) => { + lastChunk = chunk; + push(chunk); + }; + const onMessage = (message) => { + if (isAssistantMessage(message)) { + toolCallIds = message.tool_calls?.map((toolCall) => toolCall.id); + return; + } + if (isToolMessage(message)) { + if (!lastChunk) throw new OpenAIError("cannot serialize a tool message before receiving any chunks"); + push(makeChatCompletionReadableStreamMessageChunk(lastChunk, message, toolCallIds)); + toolCallIds = void 0; + } + }; + this.on("chunk", onChunk); + this.on("message", onMessage); + return () => { + this.off("chunk", onChunk); + this.off("message", onMessage); + }; + }, { onReturn: () => this.abort() }); + return new Stream(() => iterator, this.controller).toReadableStream(); + } + /** Starts a streaming tool loop and returns its event-driven conversation runner. */ + static runTools(client, params, options) { + const runner = new ChatCompletionStreamingRunner(params); + const opts = { + ...options, + __metadata: { + ...options?.__metadata, + helperMethod: "runTools" + } + }; + runner._run(() => runner._runTools(client, params, runner, opts)); + return runner; + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/chat/completions/completions.mjs +function resolveResourceRequestOptions$104(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$56 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$56(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$56.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$56.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +/** +* Given a list of messages comprising a conversation, the model will return a response. +*/ +var Completions$1 = class extends APIResource { + constructor() { + super(...arguments); + this.messages = new Messages$1(this._client); + } + create(body, options) { + return this._client.post("/chat/completions", resolveResourceRequestOptions$104(options, (options) => ({ + body, + ...options, + stream: body.stream ?? false, + __security: { bearerAuth: true } + })))._thenUnwrap((result) => body.stream ? normalizeChatCompletionStream(result) : result); + } + /** + * Get a stored chat completion. Only Chat Completions that have been created with + * the `store` parameter set to `true` will be returned. + * + * @example + * ```ts + * const chatCompletion = + * await client.chat.completions.retrieve('completion_id'); + * ``` + */ + retrieve(completionID, options) { + return this._client.get(path`/chat/completions/${completionID}`, resolveResourceRequestOptions$104(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Modify a stored chat completion. Only Chat Completions that have been created + * with the `store` parameter set to `true` can be modified. Currently, the only + * supported modification is to update the `metadata` field. + * + * @example + * ```ts + * const chatCompletion = await client.chat.completions.update( + * 'completion_id', + * { metadata: { foo: 'string' } }, + * ); + * ``` + */ + update(completionID, body, options) { + return this._client.post(path`/chat/completions/${completionID}`, resolveResourceRequestOptions$104(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$56(query, [ + "after", + "limit", + "metadata", + "model", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/chat/completions", CursorPage, resolveResourceRequestOptions$104(options, (options) => ({ + query, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Delete a stored chat completion. Only Chat Completions that have been created + * with the `store` parameter set to `true` can be deleted. + * + * @example + * ```ts + * const chatCompletionDeleted = + * await client.chat.completions.delete('completion_id'); + * ``` + */ + delete(completionID, options) { + return this._client.delete(path`/chat/completions/${completionID}`, resolveResourceRequestOptions$104(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + parse(body, options) { + validateInputTools(body.tools); + return this._client.chat.completions.create(body, { + ...options, + __metadata: { + ...options?.__metadata, + helperMethod: "chat.completions.parse" + } + })._thenUnwrap((completion) => parseChatCompletion(completion, body)); + } + runTools(body, options) { + if (body.stream) return ChatCompletionStreamingRunner.runTools(this._client, body, options); + return ChatCompletionRunner.runTools(this._client, body, options); + } + /** + * Creates a chat completion stream + */ + stream(body, options) { + return ChatCompletionStream.createChatCompletion(this._client, body, options); + } +}; +Completions$1.Messages = Messages$1; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/chat/chat.mjs +var Chat = class extends APIResource { + constructor() { + super(...arguments); + this.completions = new Completions$1(this._client); + } +}; +Chat.Completions = Completions$1; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/admin-api-keys.mjs +function resolveResourceRequestOptions$103(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$55 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$55(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$55.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$55.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var AdminAPIKeys = class extends APIResource { + /** + * Create an organization admin API key + * + * @example + * ```ts + * const adminAPIKey = + * await client.admin.organization.adminAPIKeys.create({ + * name: 'New Admin Key', + * }); + * ``` + */ + create(body, options) { + return this._client.post("/organization/admin_api_keys", resolveResourceRequestOptions$103(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Retrieve a single organization API key + * + * @example + * ```ts + * const adminAPIKey = + * await client.admin.organization.adminAPIKeys.retrieve( + * 'key_id', + * ); + * ``` + */ + retrieve(keyID, options) { + return this._client.get(path`/organization/admin_api_keys/${keyID}`, resolveResourceRequestOptions$103(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$55(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/organization/admin_api_keys", CursorPage, resolveResourceRequestOptions$103(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Delete an organization admin API key + * + * @example + * ```ts + * const adminAPIKey = + * await client.admin.organization.adminAPIKeys.delete( + * 'key_id', + * ); + * ``` + */ + delete(keyID, options) { + return this._client.delete(path`/organization/admin_api_keys/${keyID}`, resolveResourceRequestOptions$103(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/audit-logs.mjs +function resolveResourceRequestOptions$102(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$54 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$54(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$54.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$54.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +/** +* List user actions and configuration changes within this organization. +*/ +var AuditLogs = class extends APIResource { + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$54(query, [ + "actor_emails", + "actor_ids", + "after", + "before", + "effective_at", + "event_types", + "limit", + "project_ids", + "resource_ids", + "tenant_only" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/organization/audit_logs", ConversationCursorPage, resolveResourceRequestOptions$102(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/certificates.mjs +function resolveResourceRequestOptions$101(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$53 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$53(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$53.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$53.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Certificates$1 = class extends APIResource { + /** + * Upload a certificate to the organization. This does **not** automatically + * activate the certificate. + * + * Organizations can upload up to 50 certificates. + * + * @example + * ```ts + * const certificate = + * await client.admin.organization.certificates.create({ + * certificate: 'certificate', + * }); + * ``` + */ + create(body, options) { + return this._client.post("/organization/certificates", resolveResourceRequestOptions$101(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + retrieve(certificateID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$53(query, ["include"], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.get(path`/organization/certificates/${certificateID}`, resolveResourceRequestOptions$101(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Modify a certificate. Note that only the name can be modified. + * + * @example + * ```ts + * const certificate = + * await client.admin.organization.certificates.update( + * 'certificate_id', + * ); + * ``` + */ + update(certificateID, body, options) { + return this._client.post(path`/organization/certificates/${certificateID}`, resolveResourceRequestOptions$101(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$53(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/organization/certificates", ConversationCursorPage, resolveResourceRequestOptions$101(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Delete a certificate from the organization. + * + * The certificate must be inactive for the organization and all projects. + * + * @example + * ```ts + * const certificate = + * await client.admin.organization.certificates.delete( + * 'certificate_id', + * ); + * ``` + */ + delete(certificateID, options) { + return this._client.delete(path`/organization/certificates/${certificateID}`, resolveResourceRequestOptions$101(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Activate certificates at the organization level. + * + * You can atomically and idempotently activate up to 10 certificates at a time. + * + * @example + * ```ts + * // Automatically fetches more pages as needed. + * for await (const certificateActivateResponse of client.admin.organization.certificates.activate( + * { certificate_ids: ['cert_abc'] }, + * )) { + * // ... + * } + * ``` + */ + activate(body, options) { + return this._client.getAPIList("/organization/certificates/activate", Page, resolveResourceRequestOptions$101(options, (options) => ({ + body, + method: "post", + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Deactivate certificates at the organization level. + * + * You can atomically and idempotently deactivate up to 10 certificates at a time. + * + * @example + * ```ts + * // Automatically fetches more pages as needed. + * for await (const certificateDeactivateResponse of client.admin.organization.certificates.deactivate( + * { certificate_ids: ['cert_abc'] }, + * )) { + * // ... + * } + * ``` + */ + deactivate(body, options) { + return this._client.getAPIList("/organization/certificates/deactivate", Page, resolveResourceRequestOptions$101(options, (options) => ({ + body, + method: "post", + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/data-retention.mjs +function resolveResourceRequestOptions$100(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var DataRetention$1 = class extends APIResource { + /** + * Retrieves organization data retention controls. + * + * @example + * ```ts + * const organizationDataRetention = + * await client.admin.organization.dataRetention.retrieve(); + * ``` + */ + retrieve(options) { + return this._client.get("/organization/data_retention", resolveResourceRequestOptions$100(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Updates organization data retention controls. + * + * @example + * ```ts + * const organizationDataRetention = + * await client.admin.organization.dataRetention.update({ + * retention_type: 'zero_data_retention', + * }); + * ``` + */ + update(body, options) { + return this._client.post("/organization/data_retention", resolveResourceRequestOptions$100(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/external-storage.mjs +function resolveResourceRequestOptions$99(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$52 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$52(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$52.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$52.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var ExternalStorage = class extends APIResource { + /** + * Register one customer-managed external storage configuration. + * + * @example + * ```ts + * const externalStorageConfiguration = + * await client.admin.organization.externalStorage.create({ + * project_id: 'proj_123', + * provider: { + * bucket: 'bucket', + * role_arn: 'role_arn', + * type: 'aws', + * }, + * }); + * ``` + */ + create(body, options) { + return this._client.post("/organization/external_storage", resolveResourceRequestOptions$99(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Get one customer-managed external storage configuration. + * + * @example + * ```ts + * const externalStorageConfiguration = + * await client.admin.organization.externalStorage.retrieve( + * 'extstorage_123', + * ); + * ``` + */ + retrieve(externalStorageID, options) { + return this._client.get(path`/organization/external_storage/${externalStorageID}`, resolveResourceRequestOptions$99(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$52(query, [ + "after", + "limit", + "order", + "project_id" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/organization/external_storage", CursorPage, resolveResourceRequestOptions$99(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Disconnect a customer-managed external storage configuration. Removing the + * project's last configuration restores organization-default retention if + * customer-managed retention was active. Repeating a deletion also completes any + * interrupted retention update. Cloud storage is unchanged. + * + * @example + * ```ts + * const externalStorageDeleted = + * await client.admin.organization.externalStorage.delete( + * 'extstorage_123', + * ); + * ``` + */ + delete(externalStorageID, options) { + return this._client.delete(path`/organization/external_storage/${externalStorageID}`, resolveResourceRequestOptions$99(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Validate one customer-managed external storage configuration. + * + * @example + * ```ts + * const externalStorageConfiguration = + * await client.admin.organization.externalStorage.validate( + * 'extstorage_123', + * ); + * ``` + */ + validate(externalStorageID, options) { + return this._client.post(path`/organization/external_storage/${externalStorageID}/validate`, resolveResourceRequestOptions$99(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/invites.mjs +function resolveResourceRequestOptions$98(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$51 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$51(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$51.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$51.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Invites = class extends APIResource { + /** + * Create an invite for a user to the organization. The invite must be accepted by + * the user before they have access to the organization. + * + * @example + * ```ts + * const invite = + * await client.admin.organization.invites.create({ + * email: 'email', + * role: 'reader', + * }); + * ``` + */ + create(body, options) { + return this._client.post("/organization/invites", resolveResourceRequestOptions$98(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Retrieves an invite. + * + * @example + * ```ts + * const invite = + * await client.admin.organization.invites.retrieve( + * 'invite_id', + * ); + * ``` + */ + retrieve(inviteID, options) { + return this._client.get(path`/organization/invites/${inviteID}`, resolveResourceRequestOptions$98(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$51(query, ["after", "limit"], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/organization/invites", ConversationCursorPage, resolveResourceRequestOptions$98(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Delete an invite. If the invite has already been accepted, it cannot be deleted. + * + * @example + * ```ts + * const invite = + * await client.admin.organization.invites.delete( + * 'invite_id', + * ); + * ``` + */ + delete(inviteID, options) { + return this._client.delete(path`/organization/invites/${inviteID}`, resolveResourceRequestOptions$98(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/roles.mjs +function resolveResourceRequestOptions$97(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$50 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$50(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$50.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$50.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Roles$5 = class extends APIResource { + /** + * Creates a custom role for the organization. + * + * @example + * ```ts + * const role = await client.admin.organization.roles.create({ + * permissions: ['string'], + * role_name: 'role_name', + * }); + * ``` + */ + create(body, options) { + return this._client.post("/organization/roles", resolveResourceRequestOptions$97(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Retrieves an organization role. + * + * @example + * ```ts + * const role = await client.admin.organization.roles.retrieve( + * 'role_id', + * ); + * ``` + */ + retrieve(roleID, options) { + return this._client.get(path`/organization/roles/${roleID}`, resolveResourceRequestOptions$97(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Updates an existing organization role. + * + * @example + * ```ts + * const role = await client.admin.organization.roles.update( + * 'role_id', + * ); + * ``` + */ + update(roleID, body, options) { + return this._client.post(path`/organization/roles/${roleID}`, resolveResourceRequestOptions$97(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$50(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/organization/roles", NextCursorPage, resolveResourceRequestOptions$97(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Deletes a custom role from the organization. + * + * @example + * ```ts + * const role = await client.admin.organization.roles.delete( + * 'role_id', + * ); + * ``` + */ + delete(roleID, options) { + return this._client.delete(path`/organization/roles/${roleID}`, resolveResourceRequestOptions$97(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/spend-alerts.mjs +function resolveResourceRequestOptions$96(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$49 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$49(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$49.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$49.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var SpendAlerts$1 = class extends APIResource { + /** + * Creates an organization spend alert. + * + * @example + * ```ts + * const organizationSpendAlert = + * await client.admin.organization.spendAlerts.create({ + * currency: 'USD', + * interval: 'month', + * notification_channel: { + * recipients: ['string'], + * type: 'email', + * }, + * threshold_amount: 0, + * }); + * ``` + */ + create(body, options) { + return this._client.post("/organization/spend_alerts", resolveResourceRequestOptions$96(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Retrieves an organization spend alert. + * + * @example + * ```ts + * const organizationSpendAlert = + * await client.admin.organization.spendAlerts.retrieve( + * 'alert_id', + * ); + * ``` + */ + retrieve(alertID, options) { + return this._client.get(path`/organization/spend_alerts/${alertID}`, resolveResourceRequestOptions$96(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Updates an organization spend alert. + * + * @example + * ```ts + * const organizationSpendAlert = + * await client.admin.organization.spendAlerts.update( + * 'alert_id', + * { + * currency: 'USD', + * interval: 'month', + * notification_channel: { + * recipients: ['string'], + * type: 'email', + * }, + * threshold_amount: 0, + * }, + * ); + * ``` + */ + update(alertID, body, options) { + return this._client.post(path`/organization/spend_alerts/${alertID}`, resolveResourceRequestOptions$96(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$49(query, [ + "after", + "before", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/organization/spend_alerts", ConversationCursorPage, resolveResourceRequestOptions$96(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Deletes an organization spend alert. + * + * @example + * ```ts + * const organizationSpendAlertDeleted = + * await client.admin.organization.spendAlerts.delete( + * 'alert_id', + * ); + * ``` + */ + delete(alertID, options) { + return this._client.delete(path`/organization/spend_alerts/${alertID}`, resolveResourceRequestOptions$96(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/spend-limit.mjs +function resolveResourceRequestOptions$95(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var SpendLimit$1 = class extends APIResource { + /** + * Get the organization's hard spend limit. + * + * @example + * ```ts + * const organizationSpendLimit = + * await client.admin.organization.spendLimit.retrieve(); + * ``` + */ + retrieve(options) { + return this._client.get("/organization/spend_limit", resolveResourceRequestOptions$95(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Create or replace the organization's hard spend limit. + * + * @example + * ```ts + * const organizationSpendLimit = + * await client.admin.organization.spendLimit.update({ + * currency: 'USD', + * interval: 'month', + * threshold_amount: 1, + * }); + * ``` + */ + update(body, options) { + return this._client.post("/organization/spend_limit", resolveResourceRequestOptions$95(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Delete the organization's hard spend limit. + * + * @example + * ```ts + * const organizationSpendLimitDeleted = + * await client.admin.organization.spendLimit.delete(); + * ``` + */ + delete(options) { + return this._client.delete("/organization/spend_limit", resolveResourceRequestOptions$95(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/usage.mjs +function resolveResourceRequestOptions$94(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var Usage = class extends APIResource { + /** + * Get audio speeches usage details for the organization. + * + * @example + * ```ts + * const response = + * await client.admin.organization.usage.audioSpeeches({ + * start_time: 0, + * }); + * ``` + */ + audioSpeeches(query, options) { + return this._client.get("/organization/usage/audio_speeches", resolveResourceRequestOptions$94(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Get audio transcriptions usage details for the organization. + * + * @example + * ```ts + * const response = + * await client.admin.organization.usage.audioTranscriptions( + * { start_time: 0 }, + * ); + * ``` + */ + audioTranscriptions(query, options) { + return this._client.get("/organization/usage/audio_transcriptions", resolveResourceRequestOptions$94(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Get code interpreter sessions usage details for the organization. + * + * @example + * ```ts + * const response = + * await client.admin.organization.usage.codeInterpreterSessions( + * { start_time: 0 }, + * ); + * ``` + */ + codeInterpreterSessions(query, options) { + return this._client.get("/organization/usage/code_interpreter_sessions", resolveResourceRequestOptions$94(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Get completions usage details for the organization. + * + * @example + * ```ts + * const response = + * await client.admin.organization.usage.completions({ + * start_time: 0, + * }); + * ``` + */ + completions(query, options) { + return this._client.get("/organization/usage/completions", resolveResourceRequestOptions$94(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Get costs details for the organization. + * + * @example + * ```ts + * const response = + * await client.admin.organization.usage.costs({ + * start_time: 0, + * }); + * ``` + */ + costs(query, options) { + return this._client.get("/organization/costs", resolveResourceRequestOptions$94(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Get Decisions API usage details for the organization. + * + * @example + * ```ts + * const response = + * await client.admin.organization.usage.decisions({ + * start_time: 0, + * }); + * ``` + */ + decisions(query, options) { + return this._client.get("/organization/usage/decisions", resolveResourceRequestOptions$94(options, (options) => ({ + query: Object.fromEntries(Object.entries(query).filter(([, value]) => value !== null)), + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Get embeddings usage details for the organization. + * + * @example + * ```ts + * const response = + * await client.admin.organization.usage.embeddings({ + * start_time: 0, + * }); + * ``` + */ + embeddings(query, options) { + return this._client.get("/organization/usage/embeddings", resolveResourceRequestOptions$94(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Get file search calls usage details for the organization. + * + * @example + * ```ts + * const response = + * await client.admin.organization.usage.fileSearchCalls({ + * start_time: 0, + * }); + * ``` + */ + fileSearchCalls(query, options) { + return this._client.get("/organization/usage/file_search_calls", resolveResourceRequestOptions$94(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Get images usage details for the organization. + * + * @example + * ```ts + * const response = + * await client.admin.organization.usage.images({ + * start_time: 0, + * }); + * ``` + */ + images(query, options) { + return this._client.get("/organization/usage/images", resolveResourceRequestOptions$94(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Get moderations usage details for the organization. + * + * @example + * ```ts + * const response = + * await client.admin.organization.usage.moderations({ + * start_time: 0, + * }); + * ``` + */ + moderations(query, options) { + return this._client.get("/organization/usage/moderations", resolveResourceRequestOptions$94(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Get vector stores usage details for the organization. + * + * @example + * ```ts + * const response = + * await client.admin.organization.usage.vectorStores({ + * start_time: 0, + * }); + * ``` + */ + vectorStores(query, options) { + return this._client.get("/organization/usage/vector_stores", resolveResourceRequestOptions$94(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Get web search calls usage details for the organization. + * + * @example + * ```ts + * const response = + * await client.admin.organization.usage.webSearchCalls({ + * start_time: 0, + * }); + * ``` + */ + webSearchCalls(query, options) { + return this._client.get("/organization/usage/web_search_calls", resolveResourceRequestOptions$94(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/groups/roles.mjs +function resolveResourceRequestOptions$93(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$48 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$48(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$48.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$48.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Roles$4 = class extends APIResource { + /** + * Assigns an organization role to a group within the organization. + * + * @example + * ```ts + * const role = + * await client.admin.organization.groups.roles.create( + * 'group_id', + * { role_id: 'role_id' }, + * ); + * ``` + */ + create(groupID, body, options) { + return this._client.post(path`/organization/groups/${groupID}/roles`, resolveResourceRequestOptions$93(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Retrieves an organization role assigned to a group. + * + * @example + * ```ts + * const role = + * await client.admin.organization.groups.roles.retrieve( + * 'role_id', + * { group_id: 'group_id' }, + * ); + * ``` + */ + retrieve(roleID, params, options) { + const { group_id } = params; + return this._client.get(path`/organization/groups/${group_id}/roles/${roleID}`, resolveResourceRequestOptions$93(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + list(groupID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$48(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/organization/groups/${groupID}/roles`, NextCursorPage, resolveResourceRequestOptions$93(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Unassigns an organization role from a group within the organization. + * + * @example + * ```ts + * const role = + * await client.admin.organization.groups.roles.delete( + * 'role_id', + * { group_id: 'group_id' }, + * ); + * ``` + */ + delete(roleID, params, options) { + const { group_id } = params; + return this._client.delete(path`/organization/groups/${group_id}/roles/${roleID}`, resolveResourceRequestOptions$93(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/groups/users.mjs +function resolveResourceRequestOptions$92(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$47 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$47(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$47.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$47.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Users$2 = class extends APIResource { + /** + * Adds a user to a group. + * + * @example + * ```ts + * const user = + * await client.admin.organization.groups.users.create( + * 'group_id', + * { user_id: 'user_id' }, + * ); + * ``` + */ + create(groupID, body, options) { + return this._client.post(path`/organization/groups/${groupID}/users`, resolveResourceRequestOptions$92(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Retrieves a user in a group. + * + * @example + * ```ts + * const user = + * await client.admin.organization.groups.users.retrieve( + * 'user_id', + * { group_id: 'group_id' }, + * ); + * ``` + */ + retrieve(userID, params, options) { + const { group_id } = params; + return this._client.get(path`/organization/groups/${group_id}/users/${userID}`, resolveResourceRequestOptions$92(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + list(groupID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$47(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/organization/groups/${groupID}/users`, NextCursorPage, resolveResourceRequestOptions$92(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Removes a user from a group. + * + * @example + * ```ts + * const user = + * await client.admin.organization.groups.users.delete( + * 'user_id', + * { group_id: 'group_id' }, + * ); + * ``` + */ + delete(userID, params, options) { + const { group_id } = params; + return this._client.delete(path`/organization/groups/${group_id}/users/${userID}`, resolveResourceRequestOptions$92(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/groups/groups.mjs +function resolveResourceRequestOptions$91(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$46 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$46(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$46.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$46.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Groups$1 = class extends APIResource { + constructor() { + super(...arguments); + this.users = new Users$2(this._client); + this.roles = new Roles$4(this._client); + } + /** + * Creates a new group in the organization. + * + * @example + * ```ts + * const group = await client.admin.organization.groups.create( + * { name: 'x' }, + * ); + * ``` + */ + create(body, options) { + return this._client.post("/organization/groups", resolveResourceRequestOptions$91(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Retrieves a group. + * + * @example + * ```ts + * const group = + * await client.admin.organization.groups.retrieve( + * 'group_id', + * ); + * ``` + */ + retrieve(groupID, options) { + return this._client.get(path`/organization/groups/${groupID}`, resolveResourceRequestOptions$91(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Updates a group's information. + * + * @example + * ```ts + * const group = await client.admin.organization.groups.update( + * 'group_id', + * { name: 'x' }, + * ); + * ``` + */ + update(groupID, body, options) { + return this._client.post(path`/organization/groups/${groupID}`, resolveResourceRequestOptions$91(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$46(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/organization/groups", NextCursorPage, resolveResourceRequestOptions$91(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Deletes a group from the organization. + * + * @example + * ```ts + * const group = await client.admin.organization.groups.delete( + * 'group_id', + * ); + * ``` + */ + delete(groupID, options) { + return this._client.delete(path`/organization/groups/${groupID}`, resolveResourceRequestOptions$91(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +Groups$1.Users = Users$2; +Groups$1.Roles = Roles$4; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/projects/api-keys.mjs +function resolveResourceRequestOptions$90(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$45 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$45(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$45.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$45.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var APIKeys$1 = class extends APIResource { + /** + * Retrieves an API key in the project. + * + * @example + * ```ts + * const projectAPIKey = + * await client.admin.organization.projects.apiKeys.retrieve( + * 'api_key_id', + * { project_id: 'project_id' }, + * ); + * ``` + */ + retrieve(apiKeyID, params, options) { + const { project_id } = params; + return this._client.get(path`/organization/projects/${project_id}/api_keys/${apiKeyID}`, resolveResourceRequestOptions$90(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Updates the expiration of an existing API key in the project, including a + * service-account-owned key. Requires permission to write project API keys. + * + * Provide `expires_in_seconds` to set the expiration relative to this request. The + * value must satisfy the organization's and project's expiry policies. Expired + * keys cannot be updated. Retrying resets the expiration relative to the new + * request. The response contains only the redacted key, not its secret. + * + * @example + * ```ts + * const projectAPIKey = + * await client.admin.organization.projects.apiKeys.update( + * 'api_key_id', + * { project_id: 'project_id', expires_in_seconds: 1 }, + * ); + * ``` + */ + update(apiKeyID, params, options) { + const { project_id, ...body } = params; + return this._client.post(path`/organization/projects/${project_id}/api_keys/${apiKeyID}`, resolveResourceRequestOptions$90(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + list(projectID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$45(query, [ + "after", + "limit", + "owner_project_access" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/organization/projects/${projectID}/api_keys`, ConversationCursorPage, resolveResourceRequestOptions$90(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Deletes an API key from the project. + * + * Returns confirmation of the key deletion, or an error if the key belonged to a + * service account. + * + * @example + * ```ts + * const apiKey = + * await client.admin.organization.projects.apiKeys.delete( + * 'api_key_id', + * { project_id: 'project_id' }, + * ); + * ``` + */ + delete(apiKeyID, params, options) { + const { project_id } = params; + return this._client.delete(path`/organization/projects/${project_id}/api_keys/${apiKeyID}`, resolveResourceRequestOptions$90(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/projects/certificates.mjs +function resolveResourceRequestOptions$89(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$44 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$44(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$44.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$44.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Certificates = class extends APIResource { + list(projectID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$44(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/organization/projects/${projectID}/certificates`, ConversationCursorPage, resolveResourceRequestOptions$89(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Activate certificates at the project level. + * + * You can atomically and idempotently activate up to 10 certificates at a time. + * + * @example + * ```ts + * // Automatically fetches more pages as needed. + * for await (const certificateActivateResponse of client.admin.organization.projects.certificates.activate( + * 'project_id', + * { certificate_ids: ['cert_abc'] }, + * )) { + * // ... + * } + * ``` + */ + activate(projectID, body, options) { + return this._client.getAPIList(path`/organization/projects/${projectID}/certificates/activate`, Page, resolveResourceRequestOptions$89(options, (options) => ({ + body, + method: "post", + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Deactivate certificates at the project level. You can atomically and + * idempotently deactivate up to 10 certificates at a time. + * + * @example + * ```ts + * // Automatically fetches more pages as needed. + * for await (const certificateDeactivateResponse of client.admin.organization.projects.certificates.deactivate( + * 'project_id', + * { certificate_ids: ['cert_abc'] }, + * )) { + * // ... + * } + * ``` + */ + deactivate(projectID, body, options) { + return this._client.getAPIList(path`/organization/projects/${projectID}/certificates/deactivate`, Page, resolveResourceRequestOptions$89(options, (options) => ({ + body, + method: "post", + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/projects/data-retention.mjs +function resolveResourceRequestOptions$88(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var DataRetention = class extends APIResource { + /** + * Retrieves project data retention controls. + * + * @example + * ```ts + * const projectDataRetention = + * await client.admin.organization.projects.dataRetention.retrieve( + * 'project_id', + * ); + * ``` + */ + retrieve(projectID, options) { + return this._client.get(path`/organization/projects/${projectID}/data_retention`, resolveResourceRequestOptions$88(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Updates project data retention controls. + * + * @example + * ```ts + * const projectDataRetention = + * await client.admin.organization.projects.dataRetention.update( + * 'project_id', + * { retention_type: 'organization_default' }, + * ); + * ``` + */ + update(projectID, body, options) { + return this._client.post(path`/organization/projects/${projectID}/data_retention`, resolveResourceRequestOptions$88(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/projects/hosted-tool-permissions.mjs +function resolveResourceRequestOptions$87(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var HostedToolPermissions = class extends APIResource { + /** + * Returns hosted tool permissions for a project. + * + * @example + * ```ts + * const projectHostedToolPermissions = + * await client.admin.organization.projects.hostedToolPermissions.retrieve( + * 'project_id', + * ); + * ``` + */ + retrieve(projectID, options) { + return this._client.get(path`/organization/projects/${projectID}/hosted_tool_permissions`, resolveResourceRequestOptions$87(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Updates hosted tool permissions for a project. + * + * @example + * ```ts + * const projectHostedToolPermissions = + * await client.admin.organization.projects.hostedToolPermissions.update( + * 'project_id', + * ); + * ``` + */ + update(projectID, body, options) { + return this._client.post(path`/organization/projects/${projectID}/hosted_tool_permissions`, resolveResourceRequestOptions$87(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/projects/model-permissions.mjs +function resolveResourceRequestOptions$86(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var ModelPermissions = class extends APIResource { + /** + * Returns model permissions for a project. + * + * @example + * ```ts + * const projectModelPermissions = + * await client.admin.organization.projects.modelPermissions.retrieve( + * 'project_id', + * ); + * ``` + */ + retrieve(projectID, options) { + return this._client.get(path`/organization/projects/${projectID}/model_permissions`, resolveResourceRequestOptions$86(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Updates model permissions for a project. + * + * @example + * ```ts + * const projectModelPermissions = + * await client.admin.organization.projects.modelPermissions.update( + * 'project_id', + * { mode: 'allow_list', model_ids: ['string'] }, + * ); + * ``` + */ + update(projectID, body, options) { + return this._client.post(path`/organization/projects/${projectID}/model_permissions`, resolveResourceRequestOptions$86(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Deletes model permissions for a project. + * + * @example + * ```ts + * const projectModelPermissionsDeleted = + * await client.admin.organization.projects.modelPermissions.delete( + * 'project_id', + * ); + * ``` + */ + delete(projectID, options) { + return this._client.delete(path`/organization/projects/${projectID}/model_permissions`, resolveResourceRequestOptions$86(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/projects/rate-limits.mjs +function resolveResourceRequestOptions$85(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$43 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$43(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$43.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$43.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var RateLimits = class extends APIResource { + listRateLimits(projectID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$43(query, [ + "after", + "before", + "limit" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/organization/projects/${projectID}/rate_limits`, ConversationCursorPage, resolveResourceRequestOptions$85(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Updates a project rate limit. + * + * @example + * ```ts + * const projectRateLimit = + * await client.admin.organization.projects.rateLimits.updateRateLimit( + * 'rate_limit_id', + * { project_id: 'project_id' }, + * ); + * ``` + */ + updateRateLimit(rateLimitID, params, options) { + const { project_id, ...body } = params; + return this._client.post(path`/organization/projects/${project_id}/rate_limits/${rateLimitID}`, resolveResourceRequestOptions$85(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/projects/roles.mjs +function resolveResourceRequestOptions$84(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$42 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$42(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$42.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$42.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Roles$3 = class extends APIResource { + /** + * Creates a custom role for a project. + * + * @example + * ```ts + * const role = + * await client.admin.organization.projects.roles.create( + * 'project_id', + * { permissions: ['string'], role_name: 'role_name' }, + * ); + * ``` + */ + create(projectID, body, options) { + return this._client.post(path`/projects/${projectID}/roles`, resolveResourceRequestOptions$84(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Retrieves a project role. + * + * @example + * ```ts + * const role = + * await client.admin.organization.projects.roles.retrieve( + * 'role_id', + * { project_id: 'project_id' }, + * ); + * ``` + */ + retrieve(roleID, params, options) { + const { project_id } = params; + return this._client.get(path`/projects/${project_id}/roles/${roleID}`, resolveResourceRequestOptions$84(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Updates an existing project role. + * + * @example + * ```ts + * const role = + * await client.admin.organization.projects.roles.update( + * 'role_id', + * { project_id: 'project_id' }, + * ); + * ``` + */ + update(roleID, params, options) { + const { project_id, ...body } = params; + return this._client.post(path`/projects/${project_id}/roles/${roleID}`, resolveResourceRequestOptions$84(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + list(projectID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$42(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/projects/${projectID}/roles`, NextCursorPage, resolveResourceRequestOptions$84(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Deletes a custom role from a project. + * + * @example + * ```ts + * const role = + * await client.admin.organization.projects.roles.delete( + * 'role_id', + * { project_id: 'project_id' }, + * ); + * ``` + */ + delete(roleID, params, options) { + const { project_id } = params; + return this._client.delete(path`/projects/${project_id}/roles/${roleID}`, resolveResourceRequestOptions$84(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/projects/spend-alerts.mjs +function resolveResourceRequestOptions$83(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$41 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$41(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$41.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$41.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var SpendAlerts = class extends APIResource { + /** + * Creates a project spend alert. + * + * @example + * ```ts + * const projectSpendAlert = + * await client.admin.organization.projects.spendAlerts.create( + * 'project_id', + * { + * currency: 'USD', + * interval: 'month', + * notification_channel: { + * recipients: ['string'], + * type: 'email', + * }, + * threshold_amount: 0, + * }, + * ); + * ``` + */ + create(projectID, body, options) { + return this._client.post(path`/organization/projects/${projectID}/spend_alerts`, resolveResourceRequestOptions$83(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Retrieves a project spend alert. + * + * @example + * ```ts + * const projectSpendAlert = + * await client.admin.organization.projects.spendAlerts.retrieve( + * 'alert_id', + * { project_id: 'project_id' }, + * ); + * ``` + */ + retrieve(alertID, params, options) { + const { project_id } = params; + return this._client.get(path`/organization/projects/${project_id}/spend_alerts/${alertID}`, resolveResourceRequestOptions$83(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Updates a project spend alert. + * + * @example + * ```ts + * const projectSpendAlert = + * await client.admin.organization.projects.spendAlerts.update( + * 'alert_id', + * { + * project_id: 'project_id', + * currency: 'USD', + * interval: 'month', + * notification_channel: { + * recipients: ['string'], + * type: 'email', + * }, + * threshold_amount: 0, + * }, + * ); + * ``` + */ + update(alertID, params, options) { + const { project_id, ...body } = params; + return this._client.post(path`/organization/projects/${project_id}/spend_alerts/${alertID}`, resolveResourceRequestOptions$83(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + list(projectID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$41(query, [ + "after", + "before", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/organization/projects/${projectID}/spend_alerts`, ConversationCursorPage, resolveResourceRequestOptions$83(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Deletes a project spend alert. + * + * @example + * ```ts + * const projectSpendAlertDeleted = + * await client.admin.organization.projects.spendAlerts.delete( + * 'alert_id', + * { project_id: 'project_id' }, + * ); + * ``` + */ + delete(alertID, params, options) { + const { project_id } = params; + return this._client.delete(path`/organization/projects/${project_id}/spend_alerts/${alertID}`, resolveResourceRequestOptions$83(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/projects/spend-limit.mjs +function resolveResourceRequestOptions$82(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var SpendLimit = class extends APIResource { + /** + * Get a project's hard spend limit. + * + * @example + * ```ts + * const projectSpendLimit = + * await client.admin.organization.projects.spendLimit.retrieve( + * 'proj_123', + * ); + * ``` + */ + retrieve(projectID, options) { + return this._client.get(path`/organization/projects/${projectID}/spend_limit`, resolveResourceRequestOptions$82(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Create or replace a project's hard spend limit. + * + * @example + * ```ts + * const projectSpendLimit = + * await client.admin.organization.projects.spendLimit.update( + * 'proj_123', + * { + * currency: 'USD', + * interval: 'month', + * threshold_amount: 1, + * }, + * ); + * ``` + */ + update(projectID, body, options) { + return this._client.post(path`/organization/projects/${projectID}/spend_limit`, resolveResourceRequestOptions$82(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Delete a project's hard spend limit. + * + * @example + * ```ts + * const projectSpendLimitDeleted = + * await client.admin.organization.projects.spendLimit.delete( + * 'proj_123', + * ); + * ``` + */ + delete(projectID, options) { + return this._client.delete(path`/organization/projects/${projectID}/spend_limit`, resolveResourceRequestOptions$82(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/projects/groups/roles.mjs +function resolveResourceRequestOptions$81(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var Roles$2 = class extends APIResource { + /** + * Assigns a project role to a group within a project. + * + * @example + * ```ts + * const role = + * await client.admin.organization.projects.groups.roles.create( + * 'group_id', + * { project_id: 'project_id', role_id: 'role_id' }, + * ); + * ``` + */ + create(groupID, params, options) { + const { project_id, ...body } = params; + return this._client.post(path`/projects/${project_id}/groups/${groupID}/roles`, resolveResourceRequestOptions$81(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Retrieves a project role assigned to a group. + * + * @example + * ```ts + * const role = + * await client.admin.organization.projects.groups.roles.retrieve( + * 'role_id', + * { project_id: 'project_id', group_id: 'group_id' }, + * ); + * ``` + */ + retrieve(roleID, params, options) { + const { project_id, group_id } = params; + return this._client.get(path`/projects/${project_id}/groups/${group_id}/roles/${roleID}`, resolveResourceRequestOptions$81(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Lists the project roles assigned to a group within a project. + * + * @example + * ```ts + * // Automatically fetches more pages as needed. + * for await (const roleListResponse of client.admin.organization.projects.groups.roles.list( + * 'group_id', + * { project_id: 'project_id' }, + * )) { + * // ... + * } + * ``` + */ + list(groupID, params, options) { + const { project_id, ...query } = params; + return this._client.getAPIList(path`/projects/${project_id}/groups/${groupID}/roles`, NextCursorPage, resolveResourceRequestOptions$81(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Unassigns a project role from a group within a project. + * + * @example + * ```ts + * const role = + * await client.admin.organization.projects.groups.roles.delete( + * 'role_id', + * { project_id: 'project_id', group_id: 'group_id' }, + * ); + * ``` + */ + delete(roleID, params, options) { + const { project_id, group_id } = params; + return this._client.delete(path`/projects/${project_id}/groups/${group_id}/roles/${roleID}`, resolveResourceRequestOptions$81(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/projects/groups/groups.mjs +function resolveResourceRequestOptions$80(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$40 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$40(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$40.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$40.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Groups = class extends APIResource { + constructor() { + super(...arguments); + this.roles = new Roles$2(this._client); + } + /** + * Grants a group access to a project. + * + * @example + * ```ts + * const projectGroup = + * await client.admin.organization.projects.groups.create( + * 'project_id', + * { group_id: 'group_id', role: 'role' }, + * ); + * ``` + */ + create(projectID, body, options) { + return this._client.post(path`/organization/projects/${projectID}/groups`, resolveResourceRequestOptions$80(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Retrieves a project's group. + * + * @example + * ```ts + * const projectGroup = + * await client.admin.organization.projects.groups.retrieve( + * 'group_id', + * { project_id: 'project_id' }, + * ); + * ``` + */ + retrieve(groupID, params, options) { + const { project_id, ...query } = params; + return this._client.get(path`/organization/projects/${project_id}/groups/${groupID}`, resolveResourceRequestOptions$80(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + list(projectID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$40(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/organization/projects/${projectID}/groups`, NextCursorPage, resolveResourceRequestOptions$80(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Revokes a group's access to a project. + * + * @example + * ```ts + * const group = + * await client.admin.organization.projects.groups.delete( + * 'group_id', + * { project_id: 'project_id' }, + * ); + * ``` + */ + delete(groupID, params, options) { + const { project_id } = params; + return this._client.delete(path`/organization/projects/${project_id}/groups/${groupID}`, resolveResourceRequestOptions$80(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +Groups.Roles = Roles$2; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/projects/service-accounts/api-keys.mjs +function resolveResourceRequestOptions$79(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var APIKeys = class extends APIResource { + /** + * Creates an API key for a service account in the project. + * + * @example + * ```ts + * const apiKey = + * await client.admin.organization.projects.serviceAccounts.apiKeys.create( + * 'service_account_id', + * { project_id: 'project_id' }, + * ); + * ``` + */ + create(serviceAccountID, params, options) { + const { project_id, ...body } = params; + return this._client.post(path`/organization/projects/${project_id}/service_accounts/${serviceAccountID}/api_keys`, resolveResourceRequestOptions$79(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/projects/service-accounts/service-accounts.mjs +function resolveResourceRequestOptions$78(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$39 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$39(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$39.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$39.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var ServiceAccounts = class extends APIResource { + constructor() { + super(...arguments); + this.apiKeys = new APIKeys(this._client); + } + /** + * Creates a new service account in the project. By default, this also returns an + * unredacted API key for the service account. + * + * @example + * ```ts + * const serviceAccount = + * await client.admin.organization.projects.serviceAccounts.create( + * 'project_id', + * { name: 'name' }, + * ); + * ``` + */ + create(projectID, body, options) { + return this._client.post(path`/organization/projects/${projectID}/service_accounts`, resolveResourceRequestOptions$78(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Retrieves a service account in the project. + * + * @example + * ```ts + * const projectServiceAccount = + * await client.admin.organization.projects.serviceAccounts.retrieve( + * 'service_account_id', + * { project_id: 'project_id' }, + * ); + * ``` + */ + retrieve(serviceAccountID, params, options) { + const { project_id } = params; + return this._client.get(path`/organization/projects/${project_id}/service_accounts/${serviceAccountID}`, resolveResourceRequestOptions$78(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Updates a service account in the project. + * + * @example + * ```ts + * const projectServiceAccount = + * await client.admin.organization.projects.serviceAccounts.update( + * 'service_account_id', + * { project_id: 'project_id' }, + * ); + * ``` + */ + update(serviceAccountID, params, options) { + const { project_id, ...body } = params; + return this._client.post(path`/organization/projects/${project_id}/service_accounts/${serviceAccountID}`, resolveResourceRequestOptions$78(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + list(projectID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$39(query, ["after", "limit"], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/organization/projects/${projectID}/service_accounts`, ConversationCursorPage, resolveResourceRequestOptions$78(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Deletes a service account from the project. + * + * Returns confirmation of service account deletion, or an error if the project is + * archived (archived projects have no service accounts). + * + * @example + * ```ts + * const serviceAccount = + * await client.admin.organization.projects.serviceAccounts.delete( + * 'service_account_id', + * { project_id: 'project_id' }, + * ); + * ``` + */ + delete(serviceAccountID, params, options) { + const { project_id } = params; + return this._client.delete(path`/organization/projects/${project_id}/service_accounts/${serviceAccountID}`, resolveResourceRequestOptions$78(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +ServiceAccounts.APIKeys = APIKeys; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/projects/users/roles.mjs +function resolveResourceRequestOptions$77(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var Roles$1 = class extends APIResource { + /** + * Assigns a project role to a user within a project. + * + * @example + * ```ts + * const role = + * await client.admin.organization.projects.users.roles.create( + * 'user_id', + * { project_id: 'project_id', role_id: 'role_id' }, + * ); + * ``` + */ + create(userID, params, options) { + const { project_id, ...body } = params; + return this._client.post(path`/projects/${project_id}/users/${userID}/roles`, resolveResourceRequestOptions$77(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Retrieves a project role assigned to a user. + * + * @example + * ```ts + * const role = + * await client.admin.organization.projects.users.roles.retrieve( + * 'role_id', + * { project_id: 'project_id', user_id: 'user_id' }, + * ); + * ``` + */ + retrieve(roleID, params, options) { + const { project_id, user_id } = params; + return this._client.get(path`/projects/${project_id}/users/${user_id}/roles/${roleID}`, resolveResourceRequestOptions$77(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Lists the project roles assigned to a user within a project. + * + * @example + * ```ts + * // Automatically fetches more pages as needed. + * for await (const roleListResponse of client.admin.organization.projects.users.roles.list( + * 'user_id', + * { project_id: 'project_id' }, + * )) { + * // ... + * } + * ``` + */ + list(userID, params, options) { + const { project_id, ...query } = params; + return this._client.getAPIList(path`/projects/${project_id}/users/${userID}/roles`, NextCursorPage, resolveResourceRequestOptions$77(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Unassigns a project role from a user within a project. + * + * @example + * ```ts + * const role = + * await client.admin.organization.projects.users.roles.delete( + * 'role_id', + * { project_id: 'project_id', user_id: 'user_id' }, + * ); + * ``` + */ + delete(roleID, params, options) { + const { project_id, user_id } = params; + return this._client.delete(path`/projects/${project_id}/users/${user_id}/roles/${roleID}`, resolveResourceRequestOptions$77(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/projects/users/users.mjs +function resolveResourceRequestOptions$76(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$38 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$38(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$38.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$38.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Users$1 = class extends APIResource { + constructor() { + super(...arguments); + this.roles = new Roles$1(this._client); + } + /** + * Adds a user to the project. Users must already be members of the organization to + * be added to a project. + * + * @example + * ```ts + * const projectUser = + * await client.admin.organization.projects.users.create( + * 'project_id', + * { role: 'role' }, + * ); + * ``` + */ + create(projectID, body, options) { + return this._client.post(path`/organization/projects/${projectID}/users`, resolveResourceRequestOptions$76(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Retrieves a user in the project. + * + * @example + * ```ts + * const projectUser = + * await client.admin.organization.projects.users.retrieve( + * 'user_id', + * { project_id: 'project_id' }, + * ); + * ``` + */ + retrieve(userID, params, options) { + const { project_id } = params; + return this._client.get(path`/organization/projects/${project_id}/users/${userID}`, resolveResourceRequestOptions$76(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Modifies a user's role in the project. + * + * @example + * ```ts + * const projectUser = + * await client.admin.organization.projects.users.update( + * 'user_id', + * { project_id: 'project_id' }, + * ); + * ``` + */ + update(userID, params, options) { + const { project_id, ...body } = params; + return this._client.post(path`/organization/projects/${project_id}/users/${userID}`, resolveResourceRequestOptions$76(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + list(projectID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$38(query, ["after", "limit"], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/organization/projects/${projectID}/users`, ConversationCursorPage, resolveResourceRequestOptions$76(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Deletes a user from the project. + * + * Returns confirmation of project user deletion, or an error if the project is + * archived (archived projects have no users). + * + * @example + * ```ts + * const user = + * await client.admin.organization.projects.users.delete( + * 'user_id', + * { project_id: 'project_id' }, + * ); + * ``` + */ + delete(userID, params, options) { + const { project_id } = params; + return this._client.delete(path`/organization/projects/${project_id}/users/${userID}`, resolveResourceRequestOptions$76(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +Users$1.Roles = Roles$1; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/projects/projects.mjs +function resolveResourceRequestOptions$75(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$37 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$37(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$37.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$37.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Projects = class extends APIResource { + constructor() { + super(...arguments); + this.users = new Users$1(this._client); + this.serviceAccounts = new ServiceAccounts(this._client); + this.apiKeys = new APIKeys$1(this._client); + this.rateLimits = new RateLimits(this._client); + this.modelPermissions = new ModelPermissions(this._client); + this.hostedToolPermissions = new HostedToolPermissions(this._client); + this.groups = new Groups(this._client); + this.roles = new Roles$3(this._client); + this.dataRetention = new DataRetention(this._client); + this.spendLimit = new SpendLimit(this._client); + this.spendAlerts = new SpendAlerts(this._client); + this.certificates = new Certificates(this._client); + } + /** + * Create a new project in the organization. Projects can be created and archived, + * but cannot be deleted. + * + * @example + * ```ts + * const project = + * await client.admin.organization.projects.create({ + * name: 'name', + * }); + * ``` + */ + create(body, options) { + return this._client.post("/organization/projects", resolveResourceRequestOptions$75(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Retrieves a project. + * + * @example + * ```ts + * const project = + * await client.admin.organization.projects.retrieve( + * 'project_id', + * ); + * ``` + */ + retrieve(projectID, options) { + return this._client.get(path`/organization/projects/${projectID}`, resolveResourceRequestOptions$75(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Modifies a project in the organization. + * + * @example + * ```ts + * const project = + * await client.admin.organization.projects.update( + * 'project_id', + * ); + * ``` + */ + update(projectID, body, options) { + return this._client.post(path`/organization/projects/${projectID}`, resolveResourceRequestOptions$75(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$37(query, [ + "after", + "include_archived", + "limit" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/organization/projects", ConversationCursorPage, resolveResourceRequestOptions$75(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Archives a project in the organization. Archived projects cannot be used or + * updated. + * + * @example + * ```ts + * const project = + * await client.admin.organization.projects.archive( + * 'project_id', + * ); + * ``` + */ + archive(projectID, options) { + return this._client.post(path`/organization/projects/${projectID}/archive`, resolveResourceRequestOptions$75(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +Projects.Users = Users$1; +Projects.ServiceAccounts = ServiceAccounts; +Projects.APIKeys = APIKeys$1; +Projects.RateLimits = RateLimits; +Projects.ModelPermissions = ModelPermissions; +Projects.HostedToolPermissions = HostedToolPermissions; +Projects.Groups = Groups; +Projects.Roles = Roles$3; +Projects.DataRetention = DataRetention; +Projects.SpendLimit = SpendLimit; +Projects.SpendAlerts = SpendAlerts; +Projects.Certificates = Certificates; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/users/roles.mjs +function resolveResourceRequestOptions$74(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$36 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$36(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$36.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$36.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Roles = class extends APIResource { + /** + * Assigns an organization role to a user within the organization. + * + * @example + * ```ts + * const role = + * await client.admin.organization.users.roles.create( + * 'user_id', + * { role_id: 'role_id' }, + * ); + * ``` + */ + create(userID, body, options) { + return this._client.post(path`/organization/users/${userID}/roles`, resolveResourceRequestOptions$74(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Retrieves an organization role assigned to a user. + * + * @example + * ```ts + * const role = + * await client.admin.organization.users.roles.retrieve( + * 'role_id', + * { user_id: 'user_id' }, + * ); + * ``` + */ + retrieve(roleID, params, options) { + const { user_id } = params; + return this._client.get(path`/organization/users/${user_id}/roles/${roleID}`, resolveResourceRequestOptions$74(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + list(userID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$36(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/organization/users/${userID}/roles`, NextCursorPage, resolveResourceRequestOptions$74(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Unassigns an organization role from a user within the organization. + * + * @example + * ```ts + * const role = + * await client.admin.organization.users.roles.delete( + * 'role_id', + * { user_id: 'user_id' }, + * ); + * ``` + */ + delete(roleID, params, options) { + const { user_id } = params; + return this._client.delete(path`/organization/users/${user_id}/roles/${roleID}`, resolveResourceRequestOptions$74(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/users/users.mjs +function resolveResourceRequestOptions$73(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$35 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$35(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$35.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$35.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Users = class extends APIResource { + constructor() { + super(...arguments); + this.roles = new Roles(this._client); + } + /** + * Retrieves a user by their identifier. + * + * @example + * ```ts + * const organizationUser = + * await client.admin.organization.users.retrieve('user_id'); + * ``` + */ + retrieve(userID, options) { + return this._client.get(path`/organization/users/${userID}`, resolveResourceRequestOptions$73(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Modifies a user's role in the organization. + * + * @example + * ```ts + * const organizationUser = + * await client.admin.organization.users.update('user_id'); + * ``` + */ + update(userID, body, options) { + return this._client.post(path`/organization/users/${userID}`, resolveResourceRequestOptions$73(options, (options) => ({ + body, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$35(query, [ + "after", + "emails", + "limit" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/organization/users", ConversationCursorPage, resolveResourceRequestOptions$73(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * Deletes a user from the organization. + * + * @example + * ```ts + * const user = await client.admin.organization.users.delete( + * 'user_id', + * ); + * ``` + */ + delete(userID, options) { + return this._client.delete(path`/organization/users/${userID}`, resolveResourceRequestOptions$73(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +Users.Roles = Roles; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/organization/organization.mjs +var Organization = class extends APIResource { + constructor() { + super(...arguments); + this.auditLogs = new AuditLogs(this._client); + this.adminAPIKeys = new AdminAPIKeys(this._client); + this.usage = new Usage(this._client); + this.invites = new Invites(this._client); + this.users = new Users(this._client); + this.groups = new Groups$1(this._client); + this.roles = new Roles$5(this._client); + this.dataRetention = new DataRetention$1(this._client); + this.externalStorage = new ExternalStorage(this._client); + this.spendLimit = new SpendLimit$1(this._client); + this.spendAlerts = new SpendAlerts$1(this._client); + this.certificates = new Certificates$1(this._client); + this.projects = new Projects(this._client); + } +}; +Organization.AuditLogs = AuditLogs; +Organization.AdminAPIKeys = AdminAPIKeys; +Organization.Usage = Usage; +Organization.Invites = Invites; +Organization.Users = Users; +Organization.Groups = Groups$1; +Organization.Roles = Roles$5; +Organization.DataRetention = DataRetention$1; +Organization.ExternalStorage = ExternalStorage; +Organization.SpendLimit = SpendLimit$1; +Organization.SpendAlerts = SpendAlerts$1; +Organization.Certificates = Certificates$1; +Organization.Projects = Projects; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/admin/admin.mjs +var Admin = class extends APIResource { + constructor() { + super(...arguments); + this.organization = new Organization(this._client); + } +}; +Admin.Organization = Organization; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/audio/speech.mjs +function resolveResourceRequestOptions$72(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +/** +* Turn audio into text or text into audio. +*/ +var Speech = class extends APIResource { + /** + * Generates audio from the input text. + * + * Returns the audio file content, or a stream of audio events. + * + * @example + * ```ts + * const speech = await client.audio.speech.create({ + * input: 'input', + * model: 'tts-1', + * voice: 'ash', + * }); + * + * const content = await speech.blob(); + * console.log(content); + * ``` + */ + create(body, options) { + return this._client.post("/audio/speech", resolveResourceRequestOptions$72(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ Accept: "application/octet-stream" }, options?.headers]), + __security: { bearerAuth: true }, + __binaryResponse: true + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/audio/transcriptions.mjs +function resolveResourceRequestOptions$71(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +/** +* Turn audio into text or text into audio. +*/ +var Transcriptions = class extends APIResource { + create(body, options) { + return this._client.post("/audio/transcriptions", resolveResourceRequestOptions$71(options, (options) => multipartFormRequestOptions({ + body, + ...options, + stream: body.stream ?? false, + __metadata: { model: body.model }, + __security: { bearerAuth: true } + }, this._client))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/audio/translations.mjs +function resolveResourceRequestOptions$70(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +/** +* Turn audio into text or text into audio. +*/ +var Translations$1 = class extends APIResource { + create(body, options) { + return this._client.post("/audio/translations", resolveResourceRequestOptions$70(options, (options) => multipartFormRequestOptions({ + body, + ...options, + __metadata: { model: body.model }, + __security: { bearerAuth: true } + }, this._client))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/audio/voices.mjs +function resolveResourceRequestOptions$69(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +/** +* Turn audio into text or text into audio. +*/ +var Voices = class extends APIResource { + /** + * Create a custom voice you can use for audio output (for example, in + * Text-to-Speech and the Realtime API). This requires an audio sample and a + * previously uploaded consent recording. + * + * Send `name`, `audio_sample`, and the `consent` recording ID as multipart form + * data. The optional `type` defaults to `audio_sample`. + * + * Returns the saved voice's metadata. See the + * [custom voices guide](https://developers.openai.com/api/docs/guides/text-to-speech#custom-voices) + * for requirements and best practices. Custom voices are limited to eligible + * customers. + * + * @example + * ```ts + * const voice = await client.audio.voices.create({ + * audio_sample: fs.createReadStream('path/to/file'), + * consent: 'consent', + * name: 'x', + * }); + * ``` + */ + create(body, options) { + return this._client.post("/audio/voices", resolveResourceRequestOptions$69(options, (options) => multipartFormRequestOptions({ + body, + ...options, + __security: { bearerAuth: true } + }, this._client))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/audio/audio.mjs +var Audio = class extends APIResource { + constructor() { + super(...arguments); + this.transcriptions = new Transcriptions(this._client); + this.translations = new Translations$1(this._client); + this.speech = new Speech(this._client); + this.voices = new Voices(this._client); + } +}; +Audio.Transcriptions = Transcriptions; +Audio.Translations = Translations$1; +Audio.Speech = Speech; +Audio.Voices = Voices; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/batches.mjs +function resolveResourceRequestOptions$68(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$34 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$34(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$34.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$34.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +/** +* Create large batches of API requests to run asynchronously. +*/ +var Batches = class extends APIResource { + /** + * Creates and executes a batch from an uploaded file of requests + */ + create(body, options) { + return this._client.post("/batches", resolveResourceRequestOptions$68(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Retrieves a batch. + */ + retrieve(batchID, options) { + return this._client.get(path`/batches/${batchID}`, resolveResourceRequestOptions$68(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$34(query, ["after", "limit"], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/batches", CursorPage, resolveResourceRequestOptions$68(options, (options) => ({ + query, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Cancels an in-progress batch. The batch will be in status `cancelling` for up to + * 10 minutes, before changing to `cancelled`, where it will have partial results + * (if any) available in the output file. + */ + cancel(batchID, options) { + return this._client.post(path`/batches/${batchID}/cancel`, resolveResourceRequestOptions$68(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/assistants.mjs +function resolveResourceRequestOptions$67(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$33 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$33(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$33.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$33.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +/** +* Build Assistants that can call models and use tools. +*/ +var Assistants = class extends APIResource { + /** + * Create an assistant with a model and instructions. + * + * @deprecated + */ + create(body, options) { + return this._client.post("/assistants", resolveResourceRequestOptions$67(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Retrieves an assistant. + * + * @deprecated + */ + retrieve(assistantID, options) { + return this._client.get(path`/assistants/${assistantID}`, resolveResourceRequestOptions$67(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Modifies an assistant. + * + * @deprecated + */ + update(assistantID, body, options) { + return this._client.post(path`/assistants/${assistantID}`, resolveResourceRequestOptions$67(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$33(query, [ + "after", + "before", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/assistants", CursorPage, resolveResourceRequestOptions$67(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Delete an assistant. + * + * @deprecated + */ + delete(assistantID, options) { + return this._client.delete(path`/assistants/${assistantID}`, resolveResourceRequestOptions$67(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/realtime/sessions.mjs +var Sessions$3 = class extends APIResource { + /** + * Create an ephemeral API token for use in client-side applications with the + * Realtime API. Can be configured with the same session parameters as the + * `session.update` client event. + * + * It responds with a session object, plus a `client_secret` key which contains a + * usable ephemeral API token that can be used to authenticate browser clients for + * the Realtime API. + * + * @example + * ```ts + * const session = + * await client.beta.realtime.sessions.create(); + * ``` + */ + create(body, options) { + return this._client.post("/realtime/sessions", { + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/realtime/transcription-sessions.mjs +var TranscriptionSessions = class extends APIResource { + /** + * Create an ephemeral API token for use in client-side applications with the + * Realtime API specifically for realtime transcriptions. Can be configured with + * the same session parameters as the `transcription_session.update` client event. + * + * It responds with a session object, plus a `client_secret` key which contains a + * usable ephemeral API token that can be used to authenticate browser clients for + * the Realtime API. + * + * @example + * ```ts + * const transcriptionSession = + * await client.beta.realtime.transcriptionSessions.create(); + * ``` + */ + create(body, options) { + return this._client.post("/realtime/transcription_sessions", { + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/realtime/realtime.mjs +/** +* @deprecated Realtime has now launched and is generally available. The old beta API is now deprecated. +*/ +var Realtime$1 = class extends APIResource { + constructor() { + super(...arguments); + this.sessions = new Sessions$3(this._client); + this.transcriptionSessions = new TranscriptionSessions(this._client); + } +}; +Realtime$1.Sessions = Sessions$3; +Realtime$1.TranscriptionSessions = TranscriptionSessions; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/beta/agents/files.mjs +/** Beta: uploaded file IDs remain available after partial preparation or staging failure. */ +var AgentFileUploadError = class extends OpenAIError { + constructor(uploadedFiles, cause) { + super("Agent file preparation or staging failed; uploaded files remain caller-owned."); + this.name = "AgentFileUploadError"; + this.uploadedFiles = uploadedFiles; + Object.defineProperty(this, "cause", { + value: cause, + configurable: true + }); + } +}; +/** @internal */ +function validateAgentFilePath(path) { + const parts = path.split("/"); + const root = parts[2] ?? ""; + if (!path.startsWith("/workspace/") || path.includes("\\") || path.includes("\0") || parts.slice(1).some((part) => part === "" || part === "." || part === "..") || root === ".codex" || root === ".managed-agents" || root.startsWith(".managed-agents-") || path === "/workspace/outputs") throw new OpenAIError("Agent files require a non-reserved absolute file path inside /workspace"); +} +function preflight(files, options) { + const entries = Object.entries(files); + const headers = buildHeaders([options.headers]); + if (entries.length > 1 && (headers.values.has("idempotency-key") || !headers.nulls.has("idempotency-key") && options?.idempotencyKey !== void 0)) throw new OpenAIError("Do not reuse an Idempotency-Key across multiple file uploads"); + const paths = new Set(entries.map(([path]) => path)); + for (const [path] of entries) { + validateAgentFilePath(path); + for (let slash = path.lastIndexOf("/"); slash > 0; slash = path.lastIndexOf("/", slash - 1)) if (paths.has(path.slice(0, slash))) throw new OpenAIError("Agent file destinations conflict"); + } + return entries; +} +/** @internal */ +async function prepareAgentFiles(client, files, options) { + const requestOptions = { ...options }; + const headers = buildHeaders([client["_options"].defaultHeaders, requestOptions.headers]); + requestOptions.headers = headers; + const entries = preflight(files, requestOptions); + if (entries.length > 1) headers.nulls.add("idempotency-key"); + const prepared = { + files: [], + uploadedFiles: [] + }; + try { + for (const [path, file] of entries) { + const uploaded = await client.files.create({ + file, + purpose: "user_data" + }, requestOptions); + prepared.uploadedFiles.push(uploaded); + prepared.files.push({ + type: "file_id", + file_id: uploaded.id, + path + }); + } + return prepared; + } catch (error) { + throw new AgentFileUploadError(prepared.uploadedFiles, error); + } +} +/** @internal */ +async function uploadAgentFile(client, resource, environmentID, params, options) { + const prepared = await prepareAgentFiles(client, { [params.path]: params.file }, options); + const [reference] = prepared.files; + const [uploadedFile] = prepared.uploadedFiles; + if (!reference || !uploadedFile) throw new OpenAIError("Missing prepared agent file"); + try { + return { + uploadedFile, + environmentFile: await resource.create(environmentID, reference, options) + }; + } catch (error) { + throw new AgentFileUploadError(prepared.uploadedFiles, error); + } +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/agents/environments/files.mjs +function resolveResourceRequestOptions$66(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var Files$3 = class extends APIResource { + /** Beta: prepare initial hosted file references; uploaded Files API objects remain caller-owned. */ + prepare(files, options) { + return prepareAgentFiles(this._client, files, options); + } + /** Beta: upload one local file and stage its reference in a live environment. */ + upload(environmentID, params, options) { + return uploadAgentFile(this._client, this, environmentID, params, options); + } + /** + * Copies inline bytes or a Files API file into a connected execution environment, + * replacing an existing regular file at the same path. Upload between turns and + * wait for success before starting the next turn. See + * [environment files](https://developers.openai.com/api/docs/guides/agents-api/environments/files). + * + * @example + * ```ts + * const environmentFile = + * await client.beta.agents.environments.files.create( + * 'environment_id', + * { + * type: 'inline', + * path: '/workspace/example.txt', + * data: 'SGVsbG8K', + * }, + * ); + * ``` + */ + create(environmentID, body, options) { + return this._client.post(path`/agents/environments/${environmentID}/files`, resolveResourceRequestOptions$66(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Lists live files on a connected execution environment with optional directory + * filtering and opaque cursor pagination. See + * [environment files](https://developers.openai.com/api/docs/guides/agents-api/environments/files). + * + * @example + * ```ts + * // Automatically fetches more pages as needed. + * for await (const environmentFile of client.beta.agents.environments.files.list( + * 'environment_id', + * )) { + * // ... + * } + * ``` + */ + list(environmentID, query = {}, options) { + return this._client.getAPIList(path`/agents/environments/${environmentID}/files`, TokenPage, resolveResourceRequestOptions$66(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/agents/environments/templates.mjs +function resolveResourceRequestOptions$65(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$32 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$32(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$32.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$32.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Templates = class extends APIResource { + /** + * Creates reusable environment configuration without returning confidential setup + * commands or environment values. See + * [reusing a hosted setup](https://developers.openai.com/api/docs/guides/agents-api/tools#reuse-a-hosted-plugin-setup). + * + * @example + * ```ts + * const environmentTemplate = + * await client.beta.agents.environments.templates.create(); + * ``` + */ + create(body = {}, options) { + return this._client.post("/agents/environments/templates", resolveResourceRequestOptions$65(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Retrieves reusable environment configuration without returning confidential + * values. See + * [reusing a hosted setup](https://developers.openai.com/api/docs/guides/agents-api/tools#reuse-a-hosted-plugin-setup). + * + * @example + * ```ts + * const environmentTemplate = + * await client.beta.agents.environments.templates.retrieve( + * 'environment_template_id', + * ); + * ``` + */ + retrieve(environmentTemplateID, options) { + return this._client.get(path`/agents/environments/templates/${environmentTemplateID}`, resolveResourceRequestOptions$65(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Updates reusable environment configuration without returning confidential + * values. See + * [reusing a hosted setup](https://developers.openai.com/api/docs/guides/agents-api/tools#reuse-a-hosted-plugin-setup). + * + * @example + * ```ts + * const environmentTemplate = + * await client.beta.agents.environments.templates.update( + * 'environment_template_id', + * ); + * ``` + */ + update(environmentTemplateID, body = {}, options) { + return this._client.post(path`/agents/environments/templates/${environmentTemplateID}`, resolveResourceRequestOptions$65(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$32(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/agents/environments/templates", CursorPage, resolveResourceRequestOptions$65(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Deletes reusable environment configuration and all confidential template inputs. + * See + * [reusing a hosted setup](https://developers.openai.com/api/docs/guides/agents-api/tools#reuse-a-hosted-plugin-setup). + * + * @example + * ```ts + * const environmentTemplateDeleted = + * await client.beta.agents.environments.templates.delete( + * 'environment_template_id', + * ); + * ``` + */ + delete(environmentTemplateID, options) { + return this._client.delete(path`/agents/environments/templates/${environmentTemplateID}`, resolveResourceRequestOptions$65(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/agents/environments/environments.mjs +function resolveResourceRequestOptions$64(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$31 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$31(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$31.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$31.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Environments = class extends APIResource { + constructor() { + super(...arguments); + this.files = new Files$3(this._client); + this.templates = new Templates(this._client); + } + /** + * Creates an OpenAI-hosted environment before creating a session. Requires access + * to the prewarming beta. + * + * @example + * ```ts + * const environmentInfo = + * await client.beta.agents.environments.create({ + * environment: { type: 'openai_hosted' }, + * }); + * ``` + */ + create(params, options) { + const { "Idempotency-Key": idempotencyKey, ...body } = params; + return this._client.post("/agents/environments", resolveResourceRequestOptions$64(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ + "OpenAI-Beta": "agents=v1", + ...idempotencyKey != null ? { "Idempotency-Key": idempotencyKey } : void 0 + }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Retrieves an execution environment's connection status and safe installed + * metadata. See + * [environment lifecycle](https://developers.openai.com/api/docs/guides/agents-api/environments/lifecycle). + * + * @example + * ```ts + * const environmentInfo = + * await client.beta.agents.environments.retrieve( + * 'environment_id', + * ); + * ``` + */ + retrieve(environmentID, options) { + return this._client.get(path`/agents/environments/${environmentID}`, resolveResourceRequestOptions$64(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$31(query, [ + "after", + "limit", + "order", + "type" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/agents/environments", EnvironmentInfosPage, resolveResourceRequestOptions$64(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +var EnvironmentInfosPage = class extends CursorPage { + constructor(client, response, body, options) { + super(client, response, body, options); + this.object = body.object; + this.first_id = body.first_id; + this.last_id = body.last_id; + } +}; +Environments.Files = Files$3; +Environments.Templates = Templates; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/agents/turn-state.mjs +var _TurnState_turnID; +var _TurnState_turnEnded; +var _TurnState_eventIDs; +var _TurnState_calls; +/** Tracks one helper invocation's coordinator turn and duplicate deliveries. +* @internal +*/ +var TurnState = class { + constructor() { + _TurnState_turnID.set(this, void 0); + _TurnState_turnEnded.set(this, false); + _TurnState_eventIDs.set(this, /* @__PURE__ */ new Set()); + _TurnState_calls.set(this, /* @__PURE__ */ new Set()); + } + /** Records a delivery unless its event ID is in the bounded recent window. */ + accept(event) { + if (__classPrivateFieldGet(this, _TurnState_eventIDs, "f").has(event.event_id)) return false; + if (__classPrivateFieldGet(this, _TurnState_eventIDs, "f").size === 1024) { + const oldest = __classPrivateFieldGet(this, _TurnState_eventIDs, "f").values().next(); + if (!oldest.done) __classPrivateFieldGet(this, _TurnState_eventIDs, "f").delete(oldest.value); + } + __classPrivateFieldGet(this, _TurnState_eventIDs, "f").add(event.event_id); + if (event.type === "agent.session.turn.created" && event.turn.subagent_id === null && __classPrivateFieldGet(this, _TurnState_turnID, "f") === void 0) __classPrivateFieldSet(this, _TurnState_turnID, event.turn_id, "f"); + if ((event.type === "agent.session.turn.completed" || event.type === "agent.session.turn.failed" || event.type === "agent.session.turn.cancelled") && __classPrivateFieldGet(this, _TurnState_turnID, "f") !== void 0 && event.turn_id === __classPrivateFieldGet(this, _TurnState_turnID, "f")) __classPrivateFieldSet(this, _TurnState_turnEnded, true, "f"); + return true; + } + /** Checks session termination after updating the selected turn state. */ + terminal(event) { + return event.type === "agent.session.failed" || event.type === "agent.session.idle" && __classPrivateFieldGet(this, _TurnState_turnEnded, "f"); + } + /** Returns each tool call once for the full invocation, including subagent turns. */ + call(event) { + if (event.type !== "agent.session.turn.item.added" || event.item.type !== "function_call") return; + const call = event.item; + const key = JSON.stringify([call.turn_id, call.call_id]); + if (__classPrivateFieldGet(this, _TurnState_calls, "f").has(key)) return; + __classPrivateFieldGet(this, _TurnState_calls, "f").add(key); + return call; + } +}; +_TurnState_turnID = /* @__PURE__ */ new WeakMap(), _TurnState_turnEnded = /* @__PURE__ */ new WeakMap(), _TurnState_eventIDs = /* @__PURE__ */ new WeakMap(), _TurnState_calls = /* @__PURE__ */ new WeakMap(); +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/beta/agents/tool-output.mjs +/** +* Recognizes supported content blocks without confusing JSON business data with content. +* @internal +*/ +function isInputContent(value) { + if (!isObj(value)) return false; + const content = value; + let field; + if (content["type"] === "input_text") field = "text"; + else if (content["type"] === "input_image") field = "image_url"; + else return false; + return hasOwn(content, "type") && hasOwn(content, field) && typeof content[field] === "string"; +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/beta/agents/tool-stages.mjs +/** @internal */ +const toolStages = Symbol.for("openai.beta.agents.toolStages"); +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/beta/agents/tool-dispatcher.mjs +var _AgentToolDispatcher_instances; +var _AgentToolDispatcher_handlers; +var _AgentToolDispatcher_options; +var _AgentToolDispatcher_sessions; +var _AgentToolDispatcher_controller; +var _AgentToolDispatcher_onToolError; +var _AgentToolDispatcher_result; +var _AgentToolDispatcher_checkAbort; +var _AgentToolDispatcher_abortError; +var _AgentToolDispatcher_wait; +var _AgentToolDispatcher_submit; +function normalizedOutput(value) { + if (value === null) return null; + if (typeof value === "string" || Array.isArray(value) && value.every(isInputContent)) return value; + throw new OpenAIError("Tool output must be text, content, a JSON object, or null"); +} +function toolResult(call, value) { + const output = isObj(value) ? JSON.stringify(value) : value; + const serialized = JSON.stringify(output); + if (serialized === void 0) throw new OpenAIError("Tool output must be JSON serializable"); + return { + type: "agent.session.input.tool_result", + turn_id: call.turn_id, + call_id: call.call_id, + success: true, + output: normalizedOutput(typeof output === "string" ? output : JSON.parse(serialized)) + }; +} +/** Shared local function dispatch for creation and follow-up streams. @internal */ +var AgentToolDispatcher = class { + constructor(sessions, handlers, controller, options, onToolError) { + _AgentToolDispatcher_instances.add(this); + _AgentToolDispatcher_handlers.set(this, void 0); + _AgentToolDispatcher_options.set(this, void 0); + _AgentToolDispatcher_sessions.set(this, void 0); + _AgentToolDispatcher_controller.set(this, void 0); + _AgentToolDispatcher_onToolError.set(this, void 0); + __classPrivateFieldSet(this, _AgentToolDispatcher_sessions, sessions, "f"); + __classPrivateFieldSet(this, _AgentToolDispatcher_controller, controller, "f"); + __classPrivateFieldSet(this, _AgentToolDispatcher_onToolError, onToolError, "f"); + __classPrivateFieldSet(this, _AgentToolDispatcher_handlers, new Map(Object.entries(handlers)), "f"); + const headers = buildHeaders([options?.headers]); + headers.values.delete("idempotency-key"); + headers.nulls.delete("idempotency-key"); + const { idempotencyKey: _key, ...rest } = options ?? {}; + __classPrivateFieldSet(this, _AgentToolDispatcher_options, { + ...rest, + headers, + signal: controller.signal + }, "f"); + } + canHandle(name) { + return typeof __classPrivateFieldGet(this, _AgentToolDispatcher_handlers, "f").get(name) === "function"; + } + /** Capture routing and arguments before the caller can mutate the yielded event. */ + prepare(call, sessionID) { + const handler = call && __classPrivateFieldGet(this, _AgentToolDispatcher_handlers, "f").get(call.name); + if (!call || typeof handler !== "function") return; + if (!sessionID) throw new OpenAIError("Tool call received before the session creation event"); + const snapshot = structuredClone(call); + return async () => { + __classPrivateFieldGet(this, _AgentToolDispatcher_instances, "m", _AgentToolDispatcher_checkAbort).call(this); + const result = await __classPrivateFieldGet(this, _AgentToolDispatcher_instances, "m", _AgentToolDispatcher_result).call(this, snapshot, handler, sessionID); + __classPrivateFieldGet(this, _AgentToolDispatcher_instances, "m", _AgentToolDispatcher_checkAbort).call(this); + await __classPrivateFieldGet(this, _AgentToolDispatcher_instances, "m", _AgentToolDispatcher_submit).call(this, sessionID, result); + }; + } +}; +_AgentToolDispatcher_handlers = /* @__PURE__ */ new WeakMap(), _AgentToolDispatcher_options = /* @__PURE__ */ new WeakMap(), _AgentToolDispatcher_sessions = /* @__PURE__ */ new WeakMap(), _AgentToolDispatcher_controller = /* @__PURE__ */ new WeakMap(), _AgentToolDispatcher_onToolError = /* @__PURE__ */ new WeakMap(), _AgentToolDispatcher_instances = /* @__PURE__ */ new WeakSet(), _AgentToolDispatcher_result = async function _AgentToolDispatcher_result(call, handler, sessionID) { + let stage = "arguments"; + try { + const args = typeof call.arguments === "string" ? JSON.parse(call.arguments) : call.arguments; + if (!isObj(args)) throw new OpenAIError("Function arguments must be a JSON object"); + stage = "execution"; + const arguments_ = args; + const output = await __classPrivateFieldGet(this, _AgentToolDispatcher_instances, "m", _AgentToolDispatcher_wait).call(this, () => __classPrivateFieldGet(this, _AgentToolDispatcher_onToolError, "f") && handler[toolStages] ? handler(arguments_, (value) => { + stage = value; + }) : handler(arguments_)); + stage = "output"; + return toolResult(call, output); + } catch (error) { + __classPrivateFieldGet(this, _AgentToolDispatcher_instances, "m", _AgentToolDispatcher_checkAbort).call(this); + if (__classPrivateFieldGet(this, _AgentToolDispatcher_onToolError, "f")) { + const failure = Object.freeze({ + error, + stage, + tool_name: call.name, + session_id: sessionID, + turn_id: call.turn_id, + call_id: call.call_id + }); + try { + await __classPrivateFieldGet(this, _AgentToolDispatcher_instances, "m", _AgentToolDispatcher_wait).call(this, () => __classPrivateFieldGet(this, _AgentToolDispatcher_onToolError, "f")?.call(this, failure)); + } catch { + __classPrivateFieldGet(this, _AgentToolDispatcher_instances, "m", _AgentToolDispatcher_checkAbort).call(this); + } + } + return { + type: "agent.session.input.tool_result", + turn_id: call.turn_id, + call_id: call.call_id, + success: false, + error: "Tool handler failed." + }; + } +}, _AgentToolDispatcher_checkAbort = function _AgentToolDispatcher_checkAbort() { + if (__classPrivateFieldGet(this, _AgentToolDispatcher_controller, "f").signal.aborted) throw __classPrivateFieldGet(this, _AgentToolDispatcher_instances, "m", _AgentToolDispatcher_abortError).call(this); +}, _AgentToolDispatcher_abortError = function _AgentToolDispatcher_abortError() { + const error = new APIUserAbortError(); + Object.defineProperty(error, "cause", { + value: __classPrivateFieldGet(this, _AgentToolDispatcher_controller, "f").signal.reason, + writable: true, + configurable: true + }); + return error; +}, _AgentToolDispatcher_wait = async function _AgentToolDispatcher_wait(action) { + let onAbort; + const aborted = new Promise((_resolve, reject) => { + onAbort = () => reject(__classPrivateFieldGet(this, _AgentToolDispatcher_instances, "m", _AgentToolDispatcher_abortError).call(this)); + __classPrivateFieldGet(this, _AgentToolDispatcher_controller, "f").signal.addEventListener("abort", onAbort, { once: true }); + }); + try { + __classPrivateFieldGet(this, _AgentToolDispatcher_instances, "m", _AgentToolDispatcher_checkAbort).call(this); + const invoke = async () => await action(); + return await Promise.race([invoke(), aborted]); + } finally { + if (onAbort) __classPrivateFieldGet(this, _AgentToolDispatcher_controller, "f").signal.removeEventListener("abort", onAbort); + } +}, _AgentToolDispatcher_submit = async function _AgentToolDispatcher_submit(sessionID, result, key = uuid4(), attempt = 0) { + __classPrivateFieldGet(this, _AgentToolDispatcher_instances, "m", _AgentToolDispatcher_checkAbort).call(this); + try { + await __classPrivateFieldGet(this, _AgentToolDispatcher_sessions, "f").events.create(sessionID, { + events: [result], + "Idempotency-Key": key + }, __classPrivateFieldGet(this, _AgentToolDispatcher_options, "f")); + } catch (error) { + const delay = [ + 100, + 300, + 600 + ][attempt]; + if (delay === void 0 || !(error instanceof BadRequestError) || error.code !== "invalid_request_error" || !error.error || !("message" in error.error) || error.error.message !== `Unknown pending tool call: ${result.call_id}`) throw error; + let timer; + try { + await __classPrivateFieldGet(this, _AgentToolDispatcher_instances, "m", _AgentToolDispatcher_wait).call(this, () => new Promise((resolve) => { + timer = setTimeout(resolve, delay); + })); + } finally { + if (timer !== void 0) clearTimeout(timer); + } + await __classPrivateFieldGet(this, _AgentToolDispatcher_instances, "m", _AgentToolDispatcher_submit).call(this, sessionID, result, key, attempt + 1); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/agents/output-text.mjs +/** Joins output_text blocks in content order, without filtering phase, fetching, or mutating the message. */ +function outputText(message) { + return message.content.map((block) => block.type === "output_text" ? block.text : "").join(""); +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/beta/agents/agent-turn-result.mjs +/** Beta: the completed final assistant messages from one hosted root turn. */ +var AgentTurnResult = class { + constructor(turn, messages) { + this.turn = turn; + this.messages = messages; + } + get session_id() { + return this.turn.session_id; + } + get turn_id() { + return this.turn.id; + } + get output_text() { + return this.messages.map(outputText).join(""); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/beta/agents/parsed-agent-turn-result.mjs +/** Beta: a completed hosted turn whose output passed the local parser. */ +var ParsedAgentTurnResult = class extends AgentTurnResult { + constructor(result, parsed) { + super(result.turn, result.messages); + this.raw_result = result; + this.output_parsed = parsed; + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/beta/agents/output-parse-error.mjs +var _AgentOutputParseError_rawResult; +/** Beta: hosted execution completed, but local output parsing failed. */ +var AgentOutputParseError = class extends OpenAIError { + constructor(result) { + super("The completed agent output could not be parsed"); + this.name = "AgentOutputParseError"; + _AgentOutputParseError_rawResult.set(this, void 0); + __classPrivateFieldSet(this, _AgentOutputParseError_rawResult, result, "f"); + } + /** Inspect the completed output explicitly; ordinary error logging omits it. */ + get raw_result() { + return __classPrivateFieldGet(this, _AgentOutputParseError_rawResult, "f"); + } +}; +_AgentOutputParseError_rawResult = /* @__PURE__ */ new WeakMap(); +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/beta/agents/parse-result.mjs +/** @internal */ +function parseAgentResult(result, format) { + try { + if (!format) return result; + let first; + for (const message of result.messages) for (const content of message.content) if (content.type === "output_text") { + const value = format.$parseRaw(content.text); + first ?? (first = { value }); + } + if (!first) throw new AgentOutputParseError(result); + return new ParsedAgentTurnResult(result, first.value); + } catch { + throw new AgentOutputParseError(result); + } +} +function ownJSONValue(object, key) { + const descriptor = object && Object.getOwnPropertyDescriptor(object, key); + return descriptor?.enumerable && "value" in descriptor ? descriptor.value : void 0; +} +/** @internal */ +function agentFormatParser(format) { + if (!format) return; + const descriptor = Object.getOwnPropertyDescriptor(format, "$parseRaw"); + if (!descriptor || !("value" in descriptor) || typeof descriptor.value !== "function") return; + const schema = ownJSONValue(format, "schema"); + if (ownJSONValue(format, "type") !== "json_schema" || !schema) throw new OpenAIError("Typed agent formats require own enumerable type and schema data properties"); + const parse = descriptor.value; + return { + type: "json_schema", + schema, + $parseRaw: (text) => parse.call(format, text) + }; +} +function snapshotJSONProperty(object, key, capture = (value) => value) { + const descriptor = Object.getOwnPropertyDescriptor(object, key); + if (!descriptor?.enumerable) return object; + const value = capture(object[key]); + if ("value" in descriptor && value === descriptor.value) return object; + return Object.create(Object.getPrototypeOf(object), { + ...Object.getOwnPropertyDescriptors(object), + [key]: { + value, + enumerable: true, + configurable: descriptor.configurable, + writable: true + } + }); +} +/** @internal */ +function captureAgentOutput(input, options) { + const body = snapshotJSONProperty(input, "agent", (agent) => agent ? snapshotJSONProperty(agent, "text", (text) => text ? snapshotJSONProperty(text, "format") : text) : agent); + const agent = ownJSONValue(body, "agent"); + const text = ownJSONValue(agent, "text"); + const format = agentFormatParser(ownJSONValue(text, "format")); + if (!format) return { + body, + options + }; + const schema = structuredClone(format.schema); + for (const envelope of [ + body, + agent, + text + ]) if (envelope && "toJSON" in envelope) throw new OpenAIError("Typed agent requests cannot customize body, agent, or text serialization"); + const capturedOptions = { ...options }; + if (ownJSONValue(capturedOptions, "body") !== void 0) throw new OpenAIError("Typed agent requests cannot override the body in request options"); + delete capturedOptions.body; + return { + options: capturedOptions, + body: { + ...body, + agent: { + ...agent, + text: { + ...text, + format: { + type: "json_schema", + schema + } + } + } + }, + format + }; +} +/** @internal */ +async function parseAgentResultPromise(result, format) { + return parseAgentResult(await result, format); +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/beta/agents/agent-turn-result-error.mjs +/** Beta: final collection failed; partial state is evidence, not a successful result. */ +var AgentTurnResultError = class extends OpenAIError { + constructor(reason, session_id, turn, messages, required_actions = [], cause) { + super(`Could not collect the agent turn result: ${reason}`); + this.name = "AgentTurnResultError"; + this.reason = reason; + this.session_id = session_id; + this.turn = turn; + this.messages = messages; + this.required_actions = required_actions; + this.cause = cause; + } + get turn_id() { + return this.turn?.id; + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/beta/agents/agent-turn-result-collector.mjs +var _AgentTurnResultCollector_instances; +var _AgentTurnResultCollector_sessionID; +var _AgentTurnResultCollector_turn; +var _AgentTurnResultCollector_messages; +var _AgentTurnResultCollector_requiredActions; +var _AgentTurnResultCollector_sessionFailed; +var _AgentTurnResultCollector_terminal; +var _AgentTurnResultCollector_idle; +var _AgentTurnResultCollector_acceptTurn; +var _AgentTurnResultCollector_acceptOutput; +var _AgentTurnResultCollector_finalMessages; +/** Accumulates completed items independently of transport and tool execution. +* @internal +*/ +var AgentTurnResultCollector = class { + constructor(sessionID) { + _AgentTurnResultCollector_instances.add(this); + _AgentTurnResultCollector_sessionID.set(this, void 0); + _AgentTurnResultCollector_turn.set(this, void 0); + _AgentTurnResultCollector_messages.set(this, /* @__PURE__ */ new Map()); + _AgentTurnResultCollector_requiredActions.set(this, []); + _AgentTurnResultCollector_sessionFailed.set(this, false); + _AgentTurnResultCollector_terminal.set(this, false); + _AgentTurnResultCollector_idle.set(this, false); + __classPrivateFieldSet(this, _AgentTurnResultCollector_sessionID, sessionID, "f"); + } + accept(event) { + if (this.ready) return; + if ("session" in event) { + __classPrivateFieldSet(this, _AgentTurnResultCollector_sessionID, __classPrivateFieldGet(this, _AgentTurnResultCollector_sessionID, "f") ?? event.session.id, "f"); + __classPrivateFieldSet(this, _AgentTurnResultCollector_requiredActions, structuredClone(event.session.required_actions ?? []), "f"); + __classPrivateFieldSet(this, _AgentTurnResultCollector_sessionFailed, __classPrivateFieldGet(this, _AgentTurnResultCollector_sessionFailed, "f") || event.type === "agent.session.failed", "f"); + __classPrivateFieldSet(this, _AgentTurnResultCollector_idle, __classPrivateFieldGet(this, _AgentTurnResultCollector_idle, "f") || event.type === "agent.session.idle" && __classPrivateFieldGet(this, _AgentTurnResultCollector_terminal, "f"), "f"); + } + if (event.type === "agent.session.turn.created" && event.turn.subagent_id === null && !__classPrivateFieldGet(this, _AgentTurnResultCollector_turn, "f")) { + __classPrivateFieldSet(this, _AgentTurnResultCollector_turn, structuredClone(event.turn), "f"); + __classPrivateFieldSet(this, _AgentTurnResultCollector_sessionID, event.turn.session_id, "f"); + } + let turnID = "turn_id" in event ? event.turn_id : void 0; + if ("item" in event) turnID = event.item.turn_id; + if (!__classPrivateFieldGet(this, _AgentTurnResultCollector_turn, "f") || turnID !== __classPrivateFieldGet(this, _AgentTurnResultCollector_turn, "f").id) return; + __classPrivateFieldGet(this, _AgentTurnResultCollector_instances, "m", _AgentTurnResultCollector_acceptTurn).call(this, event); + } + error(reason, cause) { + return new AgentTurnResultError(reason, __classPrivateFieldGet(this, _AgentTurnResultCollector_sessionID, "f"), __classPrivateFieldGet(this, _AgentTurnResultCollector_turn, "f"), __classPrivateFieldGet(this, _AgentTurnResultCollector_instances, "m", _AgentTurnResultCollector_finalMessages).call(this), __classPrivateFieldGet(this, _AgentTurnResultCollector_requiredActions, "f"), cause); + } + checkAction(canHandle) { + if (__classPrivateFieldGet(this, _AgentTurnResultCollector_sessionFailed, "f") || __classPrivateFieldGet(this, _AgentTurnResultCollector_turn, "f")?.status === "failed") throw this.error("failed"); + if (__classPrivateFieldGet(this, _AgentTurnResultCollector_turn, "f")?.status === "cancelled") throw this.error("cancelled"); + if (__classPrivateFieldGet(this, _AgentTurnResultCollector_requiredActions, "f").some((action) => action.type !== "function_call" || !canHandle(action.name))) throw this.error("requires_action"); + } + get ready() { + return __classPrivateFieldGet(this, _AgentTurnResultCollector_terminal, "f") && __classPrivateFieldGet(this, _AgentTurnResultCollector_idle, "f"); + } + release() { + __classPrivateFieldGet(this, _AgentTurnResultCollector_messages, "f").clear(); + __classPrivateFieldSet(this, _AgentTurnResultCollector_requiredActions, [], "f"); + } + finish() { + this.checkAction(() => this.ready); + if (!__classPrivateFieldGet(this, _AgentTurnResultCollector_terminal, "f") || __classPrivateFieldGet(this, _AgentTurnResultCollector_turn, "f")?.status !== "completed" || !__classPrivateFieldGet(this, _AgentTurnResultCollector_idle, "f")) throw this.error("observation"); + return new AgentTurnResult(__classPrivateFieldGet(this, _AgentTurnResultCollector_turn, "f"), __classPrivateFieldGet(this, _AgentTurnResultCollector_instances, "m", _AgentTurnResultCollector_finalMessages).call(this)); + } +}; +_AgentTurnResultCollector_sessionID = /* @__PURE__ */ new WeakMap(), _AgentTurnResultCollector_turn = /* @__PURE__ */ new WeakMap(), _AgentTurnResultCollector_messages = /* @__PURE__ */ new WeakMap(), _AgentTurnResultCollector_requiredActions = /* @__PURE__ */ new WeakMap(), _AgentTurnResultCollector_sessionFailed = /* @__PURE__ */ new WeakMap(), _AgentTurnResultCollector_terminal = /* @__PURE__ */ new WeakMap(), _AgentTurnResultCollector_idle = /* @__PURE__ */ new WeakMap(), _AgentTurnResultCollector_instances = /* @__PURE__ */ new WeakSet(), _AgentTurnResultCollector_acceptTurn = function _AgentTurnResultCollector_acceptTurn(event) { + if ("turn" in event) { + __classPrivateFieldSet(this, _AgentTurnResultCollector_turn, structuredClone(event.turn), "f"); + __classPrivateFieldSet(this, _AgentTurnResultCollector_terminal, __classPrivateFieldGet(this, _AgentTurnResultCollector_terminal, "f") || event.type === "agent.session.turn.completed" || event.type === "agent.session.turn.failed" || event.type === "agent.session.turn.cancelled", "f"); + } + __classPrivateFieldGet(this, _AgentTurnResultCollector_instances, "m", _AgentTurnResultCollector_acceptOutput).call(this, event); +}, _AgentTurnResultCollector_acceptOutput = function _AgentTurnResultCollector_acceptOutput(event) { + if (event.type !== "agent.session.turn.item.done" || event.item.type !== "message" || event.item.status !== "completed" || event.item.phase === "commentary" || __classPrivateFieldGet(this, _AgentTurnResultCollector_messages, "f").has(event.item.id)) return; + __classPrivateFieldGet(this, _AgentTurnResultCollector_messages, "f").set(event.item.id, { + index: event.output_index, + message: structuredClone(event.item) + }); +}, _AgentTurnResultCollector_finalMessages = function _AgentTurnResultCollector_finalMessages() { + return [...__classPrivateFieldGet(this, _AgentTurnResultCollector_messages, "f").values()].sort((a, b) => a.index - b.index).map(({ message }) => message); +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/beta/agents/result-collection.mjs +var _ResultCollection_instances; +var _ResultCollection_iterator; +var _ResultCollection_ended; +var _ResultCollection_enabled; +var _ResultCollection_uncollectedEvents; +var _ResultCollection_error; +var _ResultCollection_result; +var _ResultCollection_source; +var _ResultCollection_signal; +var _ResultCollection_canHandle; +var _ResultCollection_observe; +var _ResultCollection_collect; +/** Shares collection between a raw creation stream and the follow-up helper. +* @internal +*/ +var ResultCollection = class { + constructor(source, canHandle = () => false, sessionID, signal) { + _ResultCollection_instances.add(this); + _ResultCollection_iterator.set(this, void 0); + _ResultCollection_ended.set(this, false); + _ResultCollection_enabled.set(this, false); + _ResultCollection_uncollectedEvents.set(this, false); + _ResultCollection_error.set(this, void 0); + _ResultCollection_result.set(this, void 0); + _ResultCollection_source.set(this, void 0); + _ResultCollection_signal.set(this, void 0); + _ResultCollection_canHandle.set(this, void 0); + __classPrivateFieldSet(this, _ResultCollection_source, source, "f"); + __classPrivateFieldSet(this, _ResultCollection_signal, signal, "f"); + __classPrivateFieldSet(this, _ResultCollection_canHandle, canHandle, "f"); + this.collector = new AgentTurnResultCollector(sessionID); + } + enable() { + if (!__classPrivateFieldGet(this, _ResultCollection_enabled, "f") && __classPrivateFieldGet(this, _ResultCollection_uncollectedEvents, "f")) throw new OpenAIError("Call withResultCollection() before consuming events, or call finalResult() on a fresh stream."); + __classPrivateFieldSet(this, _ResultCollection_enabled, true, "f"); + } + iterate() { + if (__classPrivateFieldGet(this, _ResultCollection_iterator, "f")) throw new OpenAIError("An agent result stream can only be consumed once"); + return __classPrivateFieldSet(this, _ResultCollection_iterator, __classPrivateFieldGet(this, _ResultCollection_instances, "m", _ResultCollection_observe).call(this), "f"); + } + finalResult() { + return __classPrivateFieldSet(this, _ResultCollection_result, __classPrivateFieldGet(this, _ResultCollection_result, "f") ?? __classPrivateFieldGet(this, _ResultCollection_instances, "m", _ResultCollection_collect).call(this), "f"); + } +}; +_ResultCollection_iterator = /* @__PURE__ */ new WeakMap(), _ResultCollection_ended = /* @__PURE__ */ new WeakMap(), _ResultCollection_enabled = /* @__PURE__ */ new WeakMap(), _ResultCollection_uncollectedEvents = /* @__PURE__ */ new WeakMap(), _ResultCollection_error = /* @__PURE__ */ new WeakMap(), _ResultCollection_result = /* @__PURE__ */ new WeakMap(), _ResultCollection_source = /* @__PURE__ */ new WeakMap(), _ResultCollection_signal = /* @__PURE__ */ new WeakMap(), _ResultCollection_canHandle = /* @__PURE__ */ new WeakMap(), _ResultCollection_instances = /* @__PURE__ */ new WeakSet(), _ResultCollection_observe = async function* _ResultCollection_observe() { + const iterator = __classPrivateFieldGet(this, _ResultCollection_source, "f").call(this); + let done = false; + try { + while (true) { + const next = await iterator.next(); + if (next.done) { + done = true; + return; + } + if (__classPrivateFieldGet(this, _ResultCollection_enabled, "f")) this.collector.accept(next.value); + else __classPrivateFieldSet(this, _ResultCollection_uncollectedEvents, true, "f"); + yield next.value; + } + } catch (error) { + if (__classPrivateFieldGet(this, _ResultCollection_enabled, "f")) __classPrivateFieldSet(this, _ResultCollection_error, error, "f"); + throw error; + } finally { + __classPrivateFieldSet(this, _ResultCollection_ended, true, "f"); + if (!done) await iterator.return?.(); + } +}, _ResultCollection_collect = async function _ResultCollection_collect() { + this.enable(); + try { + const iterator = __classPrivateFieldGet(this, _ResultCollection_iterator, "f") ?? this.iterate(); + while (!__classPrivateFieldGet(this, _ResultCollection_ended, "f") && !this.collector.ready) { + this.collector.checkAction(__classPrivateFieldGet(this, _ResultCollection_canHandle, "f")); + if ((await iterator.next()).done) break; + } + if (__classPrivateFieldGet(this, _ResultCollection_error, "f") !== void 0 && !this.collector.ready) throw __classPrivateFieldGet(this, _ResultCollection_error, "f"); + if (!this.collector.ready && __classPrivateFieldGet(this, _ResultCollection_signal, "f")?.aborted) throw this.collector.error("observation", __classPrivateFieldGet(this, _ResultCollection_signal, "f").reason); + return this.collector.finish(); + } catch (error) { + throw error instanceof AgentTurnResultError ? error : this.collector.error("observation", error); + } finally { + try { + await __classPrivateFieldGet(this, _ResultCollection_iterator, "f")?.return(); + } finally { + this.collector.release(); + } + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/agents/agent-session-stream.mjs +var _AgentSessionStream_instances; +var _AgentSessionStream_consumed; +var _AgentSessionStream_format; +var _AgentSessionStream_parsedResult; +var _AgentSessionStream_collection; +var _AgentSessionStream_stream; +var _AgentSessionStream_response; +var _AgentSessionStream_reading; +var _AgentSessionStream_sessions; +var _AgentSessionStream_sessionID; +var _AgentSessionStream_input; +var _AgentSessionStream_dispatcher; +var _AgentSessionStream_inputKey; +var _AgentSessionStream_options; +var _AgentSessionStream_iterate; +var _AgentSessionStream_checkAbort; +var _AgentSessionStream_abortError; +async function cancelBody(response) { + try { + await response?.body?.cancel(); + } catch {} +} +/** +* A single-use, lazy async iterable of original session events for one turn. +* Requires an idle session and a single input writer: the input endpoint does not +* return a turn ID. Subscribe-before-input avoids losing events; the first +* coordinator turn selects the turn to follow. Initial idle events and subagent +* completion do not end iteration. A selected turn's terminal event followed by +* session.idle, or session.failed, ends iteration. Unexpected EOF throws. +* +* Tool handlers run sequentially during iteration. Handler failures submit a +* generic error without exception text. Each submission has a distinct retry-safe +* idempotency key. Breaking iteration or calling abort closes local requests; +* neither cancels the backend turn. No work starts until iteration begins. +*/ +var AgentSessionStream = class { + /** Creates an unstarted helper. Prefer client.beta.agents.sessions.stream(). */ + constructor(sessions, sessionID, params, options) { + _AgentSessionStream_instances.add(this); + /** Aborts local requests and iteration without cancelling the backend turn. */ + this.controller = new AbortController(); + _AgentSessionStream_consumed.set(this, false); + _AgentSessionStream_format.set(this, void 0); + _AgentSessionStream_parsedResult.set(this, void 0); + _AgentSessionStream_collection.set(this, void 0); + _AgentSessionStream_stream.set(this, void 0); + _AgentSessionStream_response.set(this, void 0); + _AgentSessionStream_reading.set(this, false); + _AgentSessionStream_sessions.set(this, void 0); + _AgentSessionStream_sessionID.set(this, void 0); + _AgentSessionStream_input.set(this, void 0); + _AgentSessionStream_dispatcher.set(this, void 0); + _AgentSessionStream_inputKey.set(this, void 0); + _AgentSessionStream_options.set(this, void 0); + const input = typeof params.input === "string" ? [{ + role: "user", + content: [{ + type: "input_text", + text: params.input + }] + }] : params.input; + if (params.input.length === 0) throw new OpenAIError("input must not be empty"); + __classPrivateFieldSet(this, _AgentSessionStream_format, agentFormatParser(params.outputFormat), "f"); + if (params.outputFormat && !__classPrivateFieldGet(this, _AgentSessionStream_format, "f")) throw new OpenAIError("outputFormat must have its own parser function"); + __classPrivateFieldSet(this, _AgentSessionStream_sessions, sessions, "f"); + __classPrivateFieldSet(this, _AgentSessionStream_sessionID, sessionID, "f"); + __classPrivateFieldSet(this, _AgentSessionStream_input, { + type: "agent.session.input.message", + input + }, "f"); + const headers = buildHeaders([options?.headers]); + __classPrivateFieldSet(this, _AgentSessionStream_inputKey, headers.nulls.has("idempotency-key") ? void 0 : headers.values.get("idempotency-key") ?? params.idempotencyKey ?? options?.idempotencyKey ?? uuid4(), "f"); + headers.values.delete("idempotency-key"); + headers.nulls.delete("idempotency-key"); + const { idempotencyKey: _key, ...rest } = options ?? {}; + __classPrivateFieldSet(this, _AgentSessionStream_options, { + ...rest, + headers + }, "f"); + __classPrivateFieldSet(this, _AgentSessionStream_dispatcher, new AgentToolDispatcher(sessions, params.toolHandlers ?? {}, this.controller, __classPrivateFieldGet(this, _AgentSessionStream_options, "f"), params.onToolError), "f"); + __classPrivateFieldSet(this, _AgentSessionStream_collection, new ResultCollection(() => __classPrivateFieldGet(this, _AgentSessionStream_instances, "m", _AgentSessionStream_iterate).call(this), (name) => __classPrivateFieldGet(this, _AgentSessionStream_dispatcher, "f").canHandle(name), sessionID), "f"); + } + /** Closes local requests without cancelling the turn; an optional reason becomes the abort error's cause. */ + abort(reason) { + this.controller.abort(reason); + __classPrivateFieldGet(this, _AgentSessionStream_stream, "f")?.controller.abort(this.controller.signal.reason); + if (!__classPrivateFieldGet(this, _AgentSessionStream_reading, "f")) cancelBody(__classPrivateFieldGet(this, _AgentSessionStream_response, "f")); + } + /** Starts iteration once; use for await to ensure early exits close the connection. */ + [(_AgentSessionStream_consumed = /* @__PURE__ */ new WeakMap(), _AgentSessionStream_format = /* @__PURE__ */ new WeakMap(), _AgentSessionStream_parsedResult = /* @__PURE__ */ new WeakMap(), _AgentSessionStream_collection = /* @__PURE__ */ new WeakMap(), _AgentSessionStream_stream = /* @__PURE__ */ new WeakMap(), _AgentSessionStream_response = /* @__PURE__ */ new WeakMap(), _AgentSessionStream_reading = /* @__PURE__ */ new WeakMap(), _AgentSessionStream_sessions = /* @__PURE__ */ new WeakMap(), _AgentSessionStream_sessionID = /* @__PURE__ */ new WeakMap(), _AgentSessionStream_input = /* @__PURE__ */ new WeakMap(), _AgentSessionStream_dispatcher = /* @__PURE__ */ new WeakMap(), _AgentSessionStream_inputKey = /* @__PURE__ */ new WeakMap(), _AgentSessionStream_options = /* @__PURE__ */ new WeakMap(), _AgentSessionStream_instances = /* @__PURE__ */ new WeakSet(), Symbol.asyncIterator)]() { + if (__classPrivateFieldGet(this, _AgentSessionStream_consumed, "f")) throw new OpenAIError("An AgentSessionStream can only be consumed once"); + __classPrivateFieldSet(this, _AgentSessionStream_consumed, true, "f"); + return __classPrivateFieldGet(this, _AgentSessionStream_collection, "f").iterate(); + } + /** Beta: opt into retaining completed final messages before iterating progress events. */ + withResultCollection() { + __classPrivateFieldGet(this, _AgentSessionStream_collection, "f").enable(); + return this; + } + /** Beta: drain this turn, dispatch registered tools, and collect its final assistant messages. */ + finalResult() { + return __classPrivateFieldSet(this, _AgentSessionStream_parsedResult, __classPrivateFieldGet(this, _AgentSessionStream_parsedResult, "f") ?? parseAgentResultPromise(__classPrivateFieldGet(this, _AgentSessionStream_collection, "f").finalResult(), __classPrivateFieldGet(this, _AgentSessionStream_format, "f")), "f"); + } +}; +_AgentSessionStream_iterate = async function* _AgentSessionStream_iterate() { + const externalSignal = __classPrivateFieldGet(this, _AgentSessionStream_options, "f").signal; + const abort = () => this.abort(externalSignal?.aborted ? externalSignal.reason : this.controller.signal.reason); + externalSignal?.addEventListener("abort", abort, { once: true }); + this.controller.signal.addEventListener("abort", abort, { once: true }); + const options = { + ...__classPrivateFieldGet(this, _AgentSessionStream_options, "f"), + signal: this.controller.signal + }; + const state = new TurnState(); + try { + if (externalSignal?.aborted) this.abort(externalSignal.reason); + __classPrivateFieldGet(this, _AgentSessionStream_instances, "m", _AgentSessionStream_checkAbort).call(this); + if ((await __classPrivateFieldGet(this, _AgentSessionStream_sessions, "f").retrieve(__classPrivateFieldGet(this, _AgentSessionStream_sessionID, "f"), options)).status !== "idle") throw new OpenAIError("sessions.stream requires an idle session; use sessions.events.stream for active sessions"); + const subscription = await __classPrivateFieldGet(this, _AgentSessionStream_sessions, "f").events.stream(__classPrivateFieldGet(this, _AgentSessionStream_sessionID, "f"), options).withResponse(); + __classPrivateFieldSet(this, _AgentSessionStream_stream, subscription.data, "f"); + __classPrivateFieldSet(this, _AgentSessionStream_response, subscription.response, "f"); + __classPrivateFieldGet(this, _AgentSessionStream_instances, "m", _AgentSessionStream_checkAbort).call(this); + await __classPrivateFieldGet(this, _AgentSessionStream_sessions, "f").events.create(__classPrivateFieldGet(this, _AgentSessionStream_sessionID, "f"), { + events: [__classPrivateFieldGet(this, _AgentSessionStream_input, "f")], + ...__classPrivateFieldGet(this, _AgentSessionStream_inputKey, "f") === void 0 ? {} : { "Idempotency-Key": __classPrivateFieldGet(this, _AgentSessionStream_inputKey, "f") } + }, { + ...options, + headers: buildHeaders([options.headers, { "Idempotency-Key": __classPrivateFieldGet(this, _AgentSessionStream_inputKey, "f") ?? null }]) + }); + __classPrivateFieldGet(this, _AgentSessionStream_instances, "m", _AgentSessionStream_checkAbort).call(this); + __classPrivateFieldSet(this, _AgentSessionStream_reading, true, "f"); + for await (const event of __classPrivateFieldGet(this, _AgentSessionStream_stream, "f")) { + __classPrivateFieldGet(this, _AgentSessionStream_instances, "m", _AgentSessionStream_checkAbort).call(this); + if (!state.accept(event)) continue; + const terminal = state.terminal(event); + const dispatch = __classPrivateFieldGet(this, _AgentSessionStream_dispatcher, "f").prepare(state.call(event), __classPrivateFieldGet(this, _AgentSessionStream_sessionID, "f")); + if (terminal) __classPrivateFieldGet(this, _AgentSessionStream_stream, "f").controller.abort(); + yield event; + if (terminal) return; + __classPrivateFieldGet(this, _AgentSessionStream_instances, "m", _AgentSessionStream_checkAbort).call(this); + await dispatch?.(); + } + __classPrivateFieldGet(this, _AgentSessionStream_instances, "m", _AgentSessionStream_checkAbort).call(this); + throw new OpenAIError("Session event stream ended before the turn reached idle or failed"); + } finally { + externalSignal?.removeEventListener("abort", abort); + this.controller.signal.removeEventListener("abort", abort); + this.abort(); + } +}, _AgentSessionStream_checkAbort = function _AgentSessionStream_checkAbort() { + if (this.controller.signal.aborted) throw __classPrivateFieldGet(this, _AgentSessionStream_instances, "m", _AgentSessionStream_abortError).call(this); +}, _AgentSessionStream_abortError = function _AgentSessionStream_abortError() { + const error = new APIUserAbortError(); + Object.defineProperty(error, "cause", { + value: this.controller.signal.reason, + writable: true, + configurable: true + }); + return error; +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/beta/agents/agent-session-create-stream.mjs +async function* dispatchCreationTools(source, dispatcher, signal) { + const state = new TurnState(); + let sessionID; + for await (const event of { [Symbol.asyncIterator]: source }) { + if (event.type === "agent.session.created") sessionID ?? (sessionID = event.session.id); + const dispatch = state.accept(event) ? dispatcher.prepare(state.call(event), sessionID) : void 0; + yield event; + if (signal.aborted) return; + try { + await dispatch?.(); + } catch (error) { + if (signal.aborted && error instanceof APIUserAbortError) return; + throw error; + } + } +} +/** Add beta result collection without replacing custom stream instances. +* @internal +*/ +function withAgentTurnResult(stream, format, tools) { + let collection; + stream.__betaTransformIterator((source) => { + const { path: _path, method: _method, stream: _stream, ...options } = tools?.options ?? {}; + const dispatcher = tools && new AgentToolDispatcher(tools.sessions, tools.handlers, stream.controller, options); + collection = new ResultCollection(dispatcher ? () => dispatchCreationTools(source, dispatcher, stream.controller.signal) : source, dispatcher ? (name) => dispatcher.canHandle(name) : void 0, void 0, stream.controller.signal); + return () => collection.iterate(); + }); + let parsed; + const result = Object.assign(stream, { + finalResult: () => parsed ?? (parsed = parseAgentResultPromise(collection.finalResult(), format)), + withResultCollection: () => { + collection.enable(); + return result; + } + }); + return result; +} +/** Remove local callbacks without changing ordinary creation requests. @internal */ +function captureCreationTools(body, options) { + const descriptor = Object.getOwnPropertyDescriptor(body, "toolHandlers"); + if (!descriptor) return { + body, + options + }; + const handlers = body.toolHandlers; + if (handlers === void 0 && "value" in descriptor) return { + body, + options + }; + const descriptors = Object.getOwnPropertyDescriptors(body); + delete descriptors.toolHandlers; + const capturedOptions = { ...options }; + if ("toJSON" in body || capturedOptions.body !== void 0) throw new OpenAIError("Creation tool handlers cannot customize request body serialization"); + if (handlers === void 0) return { + body: Object.create(Object.getPrototypeOf(body), descriptors), + options: capturedOptions + }; + const { stream } = body; + if (stream !== true) throw new OpenAIError("toolHandlers requires stream: true"); + capturedOptions.headers = buildHeaders([capturedOptions.headers]); + descriptors.stream = { + value: stream, + enumerable: true, + configurable: true, + writable: true + }; + return { + body: Object.create(Object.getPrototypeOf(body), descriptors), + options: capturedOptions, + handlers: handlers && Object.fromEntries(Object.entries(handlers)) + }; +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/beta/agents/pages.mjs +/** Retain server cursor metadata for legacy Agents items with nullable IDs. +* @internal +* @yields {T} Each item in server order, failing if pagination cannot advance. +*/ +async function* agentItems(load) { + let after; + while (true) { + const page = await load(after); + yield* page.data; + if (!page.has_more) return; + const body = page["body"]; + const last = page.data[page.data.length - 1]; + const cursor = isObj(body) && typeof body["last_id"] === "string" ? body["last_id"] : last?.id; + if (!cursor || cursor === after) throw new OpenAIError("Agent pagination cannot advance to the next page"); + after = cursor; + } +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/beta/agents/result-artifacts.mjs +var _AgentResultArtifacts_resource; +var _AgentResultArtifacts_sessionID; +var _AgentResultArtifacts_turnID; +/** Beta: artifacts from the exact session and turn represented by a result. */ +var AgentResultArtifacts = class { + constructor(resource, result) { + _AgentResultArtifacts_resource.set(this, void 0); + _AgentResultArtifacts_sessionID.set(this, void 0); + _AgentResultArtifacts_turnID.set(this, void 0); + __classPrivateFieldSet(this, _AgentResultArtifacts_resource, resource, "f"); + __classPrivateFieldSet(this, _AgentResultArtifacts_sessionID, result.session_id, "f"); + __classPrivateFieldSet(this, _AgentResultArtifacts_turnID, result.turn_id, "f"); + } + /** Find one immutable artifact by its exact hosted path, across all pages. */ + async retrieve(path, options) { + let selected; + for await (const artifact of agentItems((after) => __classPrivateFieldGet(this, _AgentResultArtifacts_resource, "f").list(__classPrivateFieldGet(this, _AgentResultArtifacts_sessionID, "f"), {}, { + ...options, + query: { + ...options?.query, + after, + environment_id: void 0 + } + }))) if (artifact.session_id === __classPrivateFieldGet(this, _AgentResultArtifacts_sessionID, "f") && artifact.turn_id === __classPrivateFieldGet(this, _AgentResultArtifacts_turnID, "f") && artifact.path === path) { + if (selected) throw new OpenAIError("Multiple artifacts match this result and path"); + selected = artifact; + } + if (!selected) throw new OpenAIError("No artifact matches this result and path"); + return selected; + } + /** Return the native binary response for this result's exact artifact path. */ + async content(path, options) { + const artifact = await this.retrieve(path, options); + return __classPrivateFieldGet(this, _AgentResultArtifacts_resource, "f").content(artifact.id, { session_id: __classPrivateFieldGet(this, _AgentResultArtifacts_sessionID, "f") }, options); + } + /** Stream bytes to a caller-chosen destination; the hosted path never selects a local path. */ + async download(params, options) { + const { path, to } = params; + const artifact = await this.retrieve(path, options); + const response = await __classPrivateFieldGet(this, _AgentResultArtifacts_resource, "f").content(artifact.id, { session_id: __classPrivateFieldGet(this, _AgentResultArtifacts_sessionID, "f") }, options); + if (!response.body) throw new OpenAIError("Artifact response has no content stream"); + try { + await response.body.pipeTo(to, options?.signal ? { signal: options.signal } : {}); + } catch (error) { + try { + await response.body.cancel(); + } catch {} + throw error; + } + return artifact; + } +}; +_AgentResultArtifacts_resource = /* @__PURE__ */ new WeakMap(), _AgentResultArtifacts_sessionID = /* @__PURE__ */ new WeakMap(), _AgentResultArtifacts_turnID = /* @__PURE__ */ new WeakMap(); +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/agents/sessions/artifacts.mjs +function resolveResourceRequestOptions$63(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$30 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$30(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$30.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$30.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Artifacts = class extends APIResource { + /** Beta: bind artifact lookup and downloads to a completed result's exact session and turn. */ + forResult(result) { + return new AgentResultArtifacts(this, result); + } + /** + * Retrieves immutable metadata for one durable session artifact. See + * [session artifacts](https://developers.openai.com/api/docs/guides/agents-api/environments/files#openai-hosted-artifacts). + * + * @example + * ```ts + * const sessionArtifact = + * await client.beta.agents.sessions.artifacts.retrieve( + * 'artifact_id', + * { session_id: 'session_id' }, + * ); + * ``` + */ + retrieve(artifactID, params, options) { + const { session_id } = params; + return this._client.get(path`/agents/sessions/${session_id}/artifacts/${artifactID}`, resolveResourceRequestOptions$63(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + list(sessionID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$30(query, [ + "after", + "environment_id", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/agents/sessions/${sessionID}/artifacts`, CursorPage, resolveResourceRequestOptions$63(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Deletes an immutable session artifact without deleting its live environment file + * or original Files API object. See + * [session artifacts](https://developers.openai.com/api/docs/guides/agents-api/environments/files#openai-hosted-artifacts). + * + * @example + * ```ts + * const sessionArtifactDeleted = + * await client.beta.agents.sessions.artifacts.delete( + * 'artifact_id', + * { session_id: 'session_id' }, + * ); + * ``` + */ + delete(artifactID, params, options) { + const { session_id } = params; + return this._client.delete(path`/agents/sessions/${session_id}/artifacts/${artifactID}`, resolveResourceRequestOptions$63(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Downloads immutable session artifact bytes after the execution environment + * expires. See + * [session artifacts](https://developers.openai.com/api/docs/guides/agents-api/environments/files#openai-hosted-artifacts). + * + * @example + * ```ts + * const response = + * await client.beta.agents.sessions.artifacts.content( + * 'artifact_id', + * { session_id: 'session_id' }, + * ); + * + * const content = await response.blob(); + * console.log(content); + * ``` + */ + content(artifactID, params, options) { + const { session_id } = params; + return this._client.get(path`/agents/sessions/${session_id}/artifacts/${artifactID}/content`, resolveResourceRequestOptions$63(options, (options) => ({ + ...options, + headers: buildHeaders([{ + "OpenAI-Beta": "agents=v1", + Accept: "application/octet-stream" + }, options?.headers]), + __security: { bearerAuth: true }, + __binaryResponse: true + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/agents/sessions/events.mjs +function resolveResourceRequestOptions$62(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var Events = class extends APIResource { + /** + * Submits message, cancellation, tool-result, or computer-use approval-response + * events to a managed agent session. Cancellation can recover a still-open turn + * whose backend execution has ended by marking it cancelled and abandoning + * unpublished outputs. Saved results, published files, and existing terminal + * outcomes are preserved. HTTP 202 confirms acceptance, not durable completion. + * See + * [session events](https://developers.openai.com/api/docs/guides/agents-api/sessions/events). + * + * @example + * ```ts + * await client.beta.agents.sessions.events.create( + * 'session_id', + * { + * events: [ + * { + * request_id: 'request_id', + * response: { + * action: 'submit', + * fields: [ + * { field_id: 'field_id', value: 'value' }, + * ], + * type: 'browser_authentication', + * }, + * type: + * 'agent.session.input.computer_use_approval_request_result', + * }, + * ], + * }, + * ); + * ``` + */ + create(sessionID, params, options) { + const { "Idempotency-Key": idempotencyKey, ...body } = params; + return this._client.post(path`/agents/sessions/${sessionID}/events`, resolveResourceRequestOptions$62(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ + "OpenAI-Beta": "agents=v1", + Accept: "*/*", + ...idempotencyKey != null ? { "Idempotency-Key": idempotencyKey } : void 0 + }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Streams live events for an agent session. See + * [session events](https://developers.openai.com/api/docs/guides/agents-api/sessions/events). + * + * @example + * ```ts + * const agentSessionEvent = + * await client.beta.agents.sessions.events.stream( + * 'session_id', + * ); + * ``` + */ + stream(sessionID, options) { + return this._client.get(path`/agents/sessions/${sessionID}/events`, resolveResourceRequestOptions$62(options, (options) => ({ + ...options, + headers: buildHeaders([{ + "OpenAI-Beta": "agents=v1", + Accept: "text/event-stream" + }, options?.headers]), + stream: true, + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/agents/sessions/items.mjs +function resolveResourceRequestOptions$61(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$29 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$29(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$29.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$29.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Items$4 = class extends APIResource { + list(sessionID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$29(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/agents/sessions/${sessionID}/items`, CursorPage, resolveResourceRequestOptions$61(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/agents/sessions/traces.mjs +function resolveResourceRequestOptions$60(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$28 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$28(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$28.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$28.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Traces = class extends APIResource { + list(sessionID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$28(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/agents/sessions/${sessionID}/traces`, CursorPage, resolveResourceRequestOptions$60(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/agents/sessions/subagents/items.mjs +function resolveResourceRequestOptions$59(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var Items$3 = class extends APIResource { + /** + * Lists this subagent's own items across all of its turns. See + * [subagent workflows](https://developers.openai.com/api/docs/guides/agents-api/multi-agent). + * + * @example + * ```ts + * // Automatically fetches more pages as needed. + * for await (const agentSessionItem of client.beta.agents.sessions.subagents.items.list( + * 'subagent_id', + * { session_id: 'session_id' }, + * )) { + * // ... + * } + * ``` + */ + list(subagentID, params, options) { + const { session_id, ...query } = params; + return this._client.getAPIList(path`/agents/sessions/${session_id}/subagents/${subagentID}/items`, CursorPage, resolveResourceRequestOptions$59(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/agents/sessions/subagents/turns/items.mjs +function resolveResourceRequestOptions$58(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var Items$2 = class extends APIResource { + /** + * Lists items belonging to one turn of this subagent. See + * [subagent workflows](https://developers.openai.com/api/docs/guides/agents-api/multi-agent). + * + * @example + * ```ts + * // Automatically fetches more pages as needed. + * for await (const agentSessionItem of client.beta.agents.sessions.subagents.turns.items.list( + * 'turn_id', + * { session_id: 'session_id', subagent_id: 'subagent_id' }, + * )) { + * // ... + * } + * ``` + */ + list(turnID, params, options) { + const { session_id, subagent_id, ...query } = params; + return this._client.getAPIList(path`/agents/sessions/${session_id}/subagents/${subagent_id}/turns/${turnID}/items`, CursorPage, resolveResourceRequestOptions$58(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/agents/sessions/subagents/turns/turns.mjs +function resolveResourceRequestOptions$57(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var Turns$1 = class extends APIResource { + constructor() { + super(...arguments); + this.items = new Items$2(this._client); + } + /** + * Retrieves a turn belonging to this subagent. See + * [subagent workflows](https://developers.openai.com/api/docs/guides/agents-api/multi-agent). + * + * @example + * ```ts + * const turn = + * await client.beta.agents.sessions.subagents.turns.retrieve( + * 'turn_id', + * { + * session_id: 'session_id', + * subagent_id: 'subagent_id', + * }, + * ); + * ``` + */ + retrieve(turnID, params, options) { + const { session_id, subagent_id } = params; + return this._client.get(path`/agents/sessions/${session_id}/subagents/${subagent_id}/turns/${turnID}`, resolveResourceRequestOptions$57(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Lists all turns of this subagent, including turns after a resume. See + * [subagent workflows](https://developers.openai.com/api/docs/guides/agents-api/multi-agent). + * + * @example + * ```ts + * // Automatically fetches more pages as needed. + * for await (const turn of client.beta.agents.sessions.subagents.turns.list( + * 'subagent_id', + * { session_id: 'session_id' }, + * )) { + * // ... + * } + * ``` + */ + list(subagentID, params, options) { + const { session_id, ...query } = params; + return this._client.getAPIList(path`/agents/sessions/${session_id}/subagents/${subagentID}/turns`, CursorPage, resolveResourceRequestOptions$57(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +Turns$1.Items = Items$2; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/agents/sessions/subagents/subagents.mjs +function resolveResourceRequestOptions$56(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$27 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$27(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$27.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$27.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Subagents = class extends APIResource { + constructor() { + super(...arguments); + this.items = new Items$3(this._client); + this.turns = new Turns$1(this._client); + } + /** + * Retrieves a subagent belonging to this session. See + * [subagent workflows](https://developers.openai.com/api/docs/guides/agents-api/multi-agent). + * + * @example + * ```ts + * const subagent = + * await client.beta.agents.sessions.subagents.retrieve( + * 'subagent_id', + * { session_id: 'session_id' }, + * ); + * ``` + */ + retrieve(subagentID, params, options) { + const { session_id } = params; + return this._client.get(path`/agents/sessions/${session_id}/subagents/${subagentID}`, resolveResourceRequestOptions$56(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + list(sessionID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$27(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/agents/sessions/${sessionID}/subagents`, CursorPage, resolveResourceRequestOptions$56(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +Subagents.Items = Items$3; +Subagents.Turns = Turns$1; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/agents/sessions/turns/items.mjs +function resolveResourceRequestOptions$55(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var Items$1 = class extends APIResource { + /** + * Lists items belonging to one root-agent turn, including its interactions with + * subagents. See + * [inspecting agent output](https://developers.openai.com/api/docs/guides/agents-api/observability). + * + * @example + * ```ts + * // Automatically fetches more pages as needed. + * for await (const agentSessionItem of client.beta.agents.sessions.turns.items.list( + * 'turn_id', + * { session_id: 'session_id' }, + * )) { + * // ... + * } + * ``` + */ + list(turnID, params, options) { + const { session_id, ...query } = params; + return this._client.getAPIList(path`/agents/sessions/${session_id}/turns/${turnID}/items`, ConversationCursorPage, resolveResourceRequestOptions$55(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/agents/sessions/turns/turns.mjs +function resolveResourceRequestOptions$54(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$26 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$26(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$26.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$26.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Turns = class extends APIResource { + constructor() { + super(...arguments); + this.items = new Items$1(this._client); + } + /** + * Retrieves a turn's current status, timestamps, usage, and error. Returns 404 if + * the turn does not belong to the session. See + * [session turns](https://developers.openai.com/api/docs/guides/agents-api/sessions/manage#inspect-session-turns). + * + * @example + * ```ts + * const turn = + * await client.beta.agents.sessions.turns.retrieve( + * 'turn_id', + * { session_id: 'session_id' }, + * ); + * ``` + */ + retrieve(turnID, params, options) { + const { session_id } = params; + return this._client.get(path`/agents/sessions/${session_id}/turns/${turnID}`, resolveResourceRequestOptions$54(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + list(sessionID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$26(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/agents/sessions/${sessionID}/turns`, CursorPage, resolveResourceRequestOptions$54(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +Turns.Items = Items$1; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/agents/sessions/sessions.mjs +function resolveResourceRequestOptions$53(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$25 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$25(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$25.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$25.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Sessions$2 = class extends APIResource { + constructor() { + super(...arguments); + this.subagents = new Subagents(this._client); + this.artifacts = new Artifacts(this._client); + this.items = new Items$4(this._client); + this.events = new Events(this._client); + this.traces = new Traces(this._client); + this.turns = new Turns(this._client); + } + /** Stream one turn on an idle session with a single input writer. See AgentSessionStream for lifecycle and tool handling. */ + stream(sessionID, params, options) { + return new AgentSessionStream(this, sessionID, params, options); + } + create(body, options) { + const creation = captureCreationTools(body, options); + const output = captureAgentOutput(creation.body, creation.options); + return this._client.post("/agents/sessions", resolveResourceRequestOptions$53(output.options, (options) => ({ + body: output.body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + stream: output.body.stream ?? false, + __security: { bearerAuth: true } + })))._thenUnwrap((data, { options }) => options.stream ? withAgentTurnResult(data, output.format, creation.handlers ? { + sessions: this, + handlers: creation.handlers, + options: output.options + } : void 0) : data); + } + /** + * Retrieves the current state of a managed agent session. See + * [managing sessions](https://developers.openai.com/api/docs/guides/agents-api/sessions/manage). + * + * @example + * ```ts + * const agentSession = + * await client.beta.agents.sessions.retrieve('session_id'); + * ``` + */ + retrieve(sessionID, options) { + return this._client.get(path`/agents/sessions/${sessionID}`, resolveResourceRequestOptions$53(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Updates session metadata, model, reasoning effort, or service tier. Model + * settings apply to subsequent turns. Omitted fields are unchanged. See + * [managing sessions](https://developers.openai.com/api/docs/guides/agents-api/sessions/manage). + * + * @example + * ```ts + * const agentSession = + * await client.beta.agents.sessions.update('session_id'); + * ``` + */ + update(sessionID, body = {}, options) { + return this._client.post(path`/agents/sessions/${sessionID}`, resolveResourceRequestOptions$53(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$25(query, [ + "after", + "agent_id", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/agents/sessions", CursorPage, resolveResourceRequestOptions$53(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Removes a managed agent session from the public API and returns a deletion + * confirmation. If backend execution has ended, deletion can cancel a still-open + * public turn and abandon unpublished outputs. Running execution must be cancelled + * first. Physical cleanup may continue asynchronously. See + * [managing sessions](https://developers.openai.com/api/docs/guides/agents-api/sessions/manage). + * + * @example + * ```ts + * const agentSessionDeleted = + * await client.beta.agents.sessions.delete('session_id'); + * ``` + */ + delete(sessionID, options) { + return this._client.delete(path`/agents/sessions/${sessionID}`, resolveResourceRequestOptions$53(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +Sessions$2.Subagents = Subagents; +Sessions$2.Artifacts = Artifacts; +Sessions$2.Items = Items$4; +Sessions$2.Events = Events; +Sessions$2.Traces = Traces; +Sessions$2.Turns = Turns; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/agents/vaults/credentials.mjs +function resolveResourceRequestOptions$52(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$24 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$24(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$24.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$24.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Credentials = class extends APIResource { + /** + * Creates a vault credential. Secret values are write-only and are never returned. + * See + * [vaults](https://developers.openai.com/api/docs/guides/agents-api/tools/vaults). + * + * @example + * ```ts + * const credential = + * await client.beta.agents.vaults.credentials.create( + * 'vault_id', + * { + * auth: { + * access_token: 'access_token', + * mcp_server_url: 'mcp_server_url', + * type: 'mcp_oauth', + * }, + * name: 'x', + * }, + * ); + * ``` + */ + create(vaultID, body, options) { + return this._client.post(path`/vaults/${vaultID}/credentials`, resolveResourceRequestOptions$52(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Retrieves vault credential metadata without returning secret values. See + * [vaults](https://developers.openai.com/api/docs/guides/agents-api/tools/vaults). + * + * @example + * ```ts + * const credential = + * await client.beta.agents.vaults.credentials.retrieve( + * 'credential_id', + * { vault_id: 'vault_id' }, + * ); + * ``` + */ + retrieve(credentialID, params, options) { + const { vault_id } = params; + return this._client.get(path`/vaults/${vault_id}/credentials/${credentialID}`, resolveResourceRequestOptions$52(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Updates credential metadata or rotates its write-only secret. See + * [vaults](https://developers.openai.com/api/docs/guides/agents-api/tools/vaults). + * + * @example + * ```ts + * const credential = + * await client.beta.agents.vaults.credentials.update( + * 'credential_id', + * { vault_id: 'vault_id', metadata: {} }, + * ); + * ``` + */ + update(credentialID, params, options) { + const { vault_id, ...body } = params; + return this._client.post(path`/vaults/${vault_id}/credentials/${credentialID}`, resolveResourceRequestOptions$52(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + list(vaultID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$24(query, [ + "after", + "limit", + "metadata", + "order", + "status" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/vaults/${vaultID}/credentials`, CursorPage, resolveResourceRequestOptions$52(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Deletes a vault credential. See + * [vaults](https://developers.openai.com/api/docs/guides/agents-api/tools/vaults). + * + * @example + * ```ts + * const credentialDeleted = + * await client.beta.agents.vaults.credentials.delete( + * 'credential_id', + * { vault_id: 'vault_id' }, + * ); + * ``` + */ + delete(credentialID, params, options) { + const { vault_id } = params; + return this._client.delete(path`/vaults/${vault_id}/credentials/${credentialID}`, resolveResourceRequestOptions$52(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/agents/vaults/vaults.mjs +function resolveResourceRequestOptions$51(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$23 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$23(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$23.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$23.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Vaults = class extends APIResource { + constructor() { + super(...arguments); + this.credentials = new Credentials(this._client); + } + /** + * Creates a vault for the current project. See + * [vaults](https://developers.openai.com/api/docs/guides/agents-api/tools/vaults). + * + * @example + * ```ts + * const vault = await client.beta.agents.vaults.create(); + * ``` + */ + create(body = {}, options) { + return this._client.post("/vaults", resolveResourceRequestOptions$51(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Retrieves a vault by its ID. See + * [vaults](https://developers.openai.com/api/docs/guides/agents-api/tools/vaults). + * + * @example + * ```ts + * const vault = await client.beta.agents.vaults.retrieve( + * 'vault_id', + * ); + * ``` + */ + retrieve(vaultID, options) { + return this._client.get(path`/vaults/${vaultID}`, resolveResourceRequestOptions$51(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Updates the name or metadata of an active vault. Omitted fields remain + * unchanged. See + * [vaults](https://developers.openai.com/api/docs/guides/agents-api/tools/vaults). + * + * @example + * ```ts + * const vault = await client.beta.agents.vaults.update( + * 'vault_id', + * { name: 'Research vault' }, + * ); + * ``` + */ + update(vaultID, body, options) { + return this._client.post(path`/vaults/${vaultID}`, resolveResourceRequestOptions$51(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$23(query, [ + "after", + "limit", + "metadata", + "order", + "status" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/vaults", CursorPage, resolveResourceRequestOptions$51(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Deletes a vault and all its credentials. See + * [vaults](https://developers.openai.com/api/docs/guides/agents-api/tools/vaults). + * + * @example + * ```ts + * const vaultDeleted = await client.beta.agents.vaults.delete( + * 'vault_id', + * ); + * ``` + */ + delete(vaultID, options) { + return this._client.delete(path`/vaults/${vaultID}`, resolveResourceRequestOptions$51(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +Vaults.Credentials = Credentials; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/agents/agents.mjs +function resolveResourceRequestOptions$50(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$22 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$22(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$22.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$22.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Agents = class extends APIResource { + constructor() { + super(...arguments); + this.environments = new Environments(this._client); + this.vaults = new Vaults(this._client); + this.sessions = new Sessions$2(this._client); + } + /** + * Creates a reusable agent without storing credentials. See + * [agent configuration](https://developers.openai.com/api/docs/guides/agents-api/configuration). + * + * @example + * ```ts + * const agent = await client.beta.agents.create({ + * model: 'model', + * }); + * ``` + */ + create(body, options) { + return this._client.post("/agents", resolveResourceRequestOptions$50(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Retrieves a reusable agent by ID. See + * [agent configuration](https://developers.openai.com/api/docs/guides/agents-api/configuration). + * + * @example + * ```ts + * const agent = await client.beta.agents.retrieve('agent_id'); + * ``` + */ + retrieve(agentID, options) { + return this._client.get(path`/agents/${agentID}`, resolveResourceRequestOptions$50(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Updates a reusable agent. See + * [agent configuration](https://developers.openai.com/api/docs/guides/agents-api/configuration). + * + * @example + * ```ts + * const agent = await client.beta.agents.update('agent_id'); + * ``` + */ + update(agentID, body = {}, options) { + return this._client.post(path`/agents/${agentID}`, resolveResourceRequestOptions$50(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$22(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/agents", CursorPage, resolveResourceRequestOptions$50(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Deletes a reusable agent. See + * [agent configuration](https://developers.openai.com/api/docs/guides/agents-api/configuration). + * + * @example + * ```ts + * const agentDeleted = await client.beta.agents.delete( + * 'agent_id', + * ); + * ``` + */ + delete(agentID, options) { + return this._client.delete(path`/agents/${agentID}`, resolveResourceRequestOptions$50(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "agents=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +Agents.Environments = Environments; +Agents.Vaults = Vaults; +Agents.Sessions = Sessions$2; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/chatkit/sessions.mjs +function resolveResourceRequestOptions$49(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var Sessions$1 = class extends APIResource { + /** + * Create a ChatKit session. + * + * @example + * ```ts + * const chatSession = + * await client.beta.chatkit.sessions.create({ + * user: 'x', + * workflow: { id: 'id' }, + * }); + * ``` + */ + create(body, options) { + return this._client.post("/chatkit/sessions", resolveResourceRequestOptions$49(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "chatkit_beta=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Cancel an active ChatKit session and return its most recent metadata. + * + * Cancelling prevents new requests from using the issued client secret. + * + * @example + * ```ts + * const chatSession = + * await client.beta.chatkit.sessions.cancel('cksess_123'); + * ``` + */ + cancel(sessionID, options) { + return this._client.post(path`/chatkit/sessions/${sessionID}/cancel`, resolveResourceRequestOptions$49(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "chatkit_beta=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/chatkit/threads.mjs +function resolveResourceRequestOptions$48(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$21 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$21(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$21.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$21.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Threads$1 = class extends APIResource { + /** + * Retrieve a ChatKit thread by its identifier. + * + * @example + * ```ts + * const chatkitThread = + * await client.beta.chatkit.threads.retrieve('cthr_123'); + * ``` + */ + retrieve(threadID, options) { + return this._client.get(path`/chatkit/threads/${threadID}`, resolveResourceRequestOptions$48(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "chatkit_beta=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$21(query, [ + "after", + "before", + "limit", + "order", + "user" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/chatkit/threads", ConversationCursorPage, resolveResourceRequestOptions$48(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "chatkit_beta=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Delete a ChatKit thread along with its items and stored attachments. + * + * @example + * ```ts + * const thread = await client.beta.chatkit.threads.delete( + * 'cthr_123', + * ); + * ``` + */ + delete(threadID, options) { + return this._client.delete(path`/chatkit/threads/${threadID}`, resolveResourceRequestOptions$48(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "chatkit_beta=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + listItems(threadID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$21(query, [ + "after", + "before", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/chatkit/threads/${threadID}/items`, ConversationCursorPage, resolveResourceRequestOptions$48(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "chatkit_beta=v1" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/chatkit/chatkit.mjs +var ChatKit = class extends APIResource { + constructor() { + super(...arguments); + this.sessions = new Sessions$1(this._client); + this.threads = new Threads$1(this._client); + } +}; +ChatKit.Sessions = Sessions$1; +ChatKit.Threads = Threads$1; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/responses/input-items.mjs +function resolveResourceRequestOptions$47(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$20 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$20(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$20.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$20.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +/** +* Create and manage model responses. +*/ +var InputItems$1 = class extends APIResource { + list(responseID, params = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$20(params, [ + "after", + "betas", + "include", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + params = {}; + } + params = params; + const { betas, ...query } = params ?? {}; + return this._client.getAPIList(path`/responses/${responseID}/input_items?beta=true`, CursorPage, resolveResourceRequestOptions$47(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ ...betas?.toString() != null ? { "openai-beta": betas?.toString() } : void 0 }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/responses/input-tokens.mjs +function resolveResourceRequestOptions$46(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +/** +* Create and manage model responses. +*/ +var InputTokens$1 = class extends APIResource { + /** + * Returns input token counts of the request. + * + * Returns an object with `object` set to `response.input_tokens` and an + * `input_tokens` count. + * + * @example + * ```ts + * const response = + * await client.beta.responses.inputTokens.count(); + * ``` + */ + count(params = {}, options) { + const { betas, ...body } = params ?? {}; + return this._client.post("/responses/input_tokens?beta=true", resolveResourceRequestOptions$46(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ ...betas?.toString() != null ? { "openai-beta": betas?.toString() } : void 0 }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/responses/responses.mjs +function resolveResourceRequestOptions$45(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$19 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$19(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$19.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$19.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +/** +* Create and manage model responses. +*/ +var Responses$1 = class extends APIResource { + constructor() { + super(...arguments); + this.inputItems = new InputItems$1(this._client); + this.inputTokens = new InputTokens$1(this._client); + } + create(params, options) { + const { betas, ...body } = params; + return this._client.post("/responses?beta=true", resolveResourceRequestOptions$45(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ ...betas?.toString() != null ? { "openai-beta": betas?.toString() } : void 0 }, options?.headers]), + stream: params.stream ?? false, + __security: { bearerAuth: true } + }))); + } + retrieve(responseID, params = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$19(params, [ + "betas", + "include", + "include_obfuscation", + "starting_after", + "stream" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + params = {}; + } + params = params; + const { betas, ...query } = params ?? {}; + return this._client.get(path`/responses/${responseID}?beta=true`, resolveResourceRequestOptions$45(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ ...betas?.toString() != null ? { "openai-beta": betas?.toString() } : void 0 }, options?.headers]), + stream: params?.stream ?? false, + __security: { bearerAuth: true } + }))); + } + /** + * Deletes a model response with the given ID. + * + * @example + * ```ts + * await client.beta.responses.delete( + * 'resp_677efb5139a88190b512bc3fef8e535d', + * ); + * ``` + */ + delete(responseID, params = {}, options) { + const { betas } = params ?? {}; + return this._client.delete(path`/responses/${responseID}?beta=true`, resolveResourceRequestOptions$45(options, (options) => ({ + ...options, + headers: buildHeaders([{ + Accept: "*/*", + ...betas?.toString() != null ? { "openai-beta": betas?.toString() } : void 0 + }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Cancels a model response with the given ID. Only responses created with the + * `background` parameter set to `true` can be cancelled. + * [Learn more](https://developers.openai.com/api/docs/guides/background). + * + * @example + * ```ts + * const betaResponse = await client.beta.responses.cancel( + * 'resp_677efb5139a88190b512bc3fef8e535d', + * ); + * ``` + */ + cancel(responseID, params = {}, options) { + const { betas } = params ?? {}; + return this._client.post(path`/responses/${responseID}/cancel?beta=true`, resolveResourceRequestOptions$45(options, (options) => ({ + ...options, + headers: buildHeaders([{ ...betas?.toString() != null ? { "openai-beta": betas?.toString() } : void 0 }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Compact a conversation. Returns a compacted response object. + * + * Learn when and how to compact long-running conversations in the + * [conversation state guide](https://developers.openai.com/api/docs/guides/conversation-state#managing-the-context-window). + * For ZDR-compatible compaction details, see + * [Compaction (advanced)](https://developers.openai.com/api/docs/guides/conversation-state#compaction-advanced). + * + * @example + * ```ts + * const betaCompactedResponse = + * await client.beta.responses.compact({ + * model: 'gpt-6-astra', + * }); + * ``` + */ + compact(params, options) { + const { betas, ...body } = params; + return this._client.post("/responses/compact?beta=true", resolveResourceRequestOptions$45(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ ...betas?.toString() != null ? { "openai-beta": betas?.toString() } : void 0 }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +Responses$1.InputItems = InputItems$1; +Responses$1.InputTokens = InputTokens$1; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/threads/messages.mjs +function resolveResourceRequestOptions$44(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$18 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$18(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$18.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$18.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +/** +* Build Assistants that can call models and use tools. +* +* @deprecated The Assistants API is deprecated in favor of the Responses API +*/ +var Messages = class extends APIResource { + /** + * Create a message. + * + * @deprecated The Assistants API is deprecated in favor of the Responses API + */ + create(threadID, body, options) { + return this._client.post(path`/threads/${threadID}/messages`, resolveResourceRequestOptions$44(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Retrieve a message. + * + * @deprecated The Assistants API is deprecated in favor of the Responses API + */ + retrieve(messageID, params, options) { + const { thread_id } = params; + return this._client.get(path`/threads/${thread_id}/messages/${messageID}`, resolveResourceRequestOptions$44(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Modifies a message. + * + * @deprecated The Assistants API is deprecated in favor of the Responses API + */ + update(messageID, params, options) { + const { thread_id, ...body } = params; + return this._client.post(path`/threads/${thread_id}/messages/${messageID}`, resolveResourceRequestOptions$44(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + list(threadID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$18(query, [ + "after", + "before", + "limit", + "order", + "run_id" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/threads/${threadID}/messages`, CursorPage, resolveResourceRequestOptions$44(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Deletes a message. + * + * @deprecated The Assistants API is deprecated in favor of the Responses API + */ + delete(messageID, params, options) { + const { thread_id } = params; + return this._client.delete(path`/threads/${thread_id}/messages/${messageID}`, resolveResourceRequestOptions$44(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/threads/runs/steps.mjs +function resolveResourceRequestOptions$43(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +/** +* Build Assistants that can call models and use tools. +* +* @deprecated The Assistants API is deprecated in favor of the Responses API +*/ +var Steps = class extends APIResource { + /** + * Retrieves a run step. + * + * @deprecated The Assistants API is deprecated in favor of the Responses API + */ + retrieve(stepID, params, options) { + const { thread_id, run_id, ...query } = params; + return this._client.get(path`/threads/${thread_id}/runs/${run_id}/steps/${stepID}`, resolveResourceRequestOptions$43(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Returns a list of run steps belonging to a run. + * + * @deprecated The Assistants API is deprecated in favor of the Responses API + */ + list(runID, params, options) { + const { thread_id, ...query } = params; + return this._client.getAPIList(path`/threads/${thread_id}/runs/${runID}/steps`, CursorPage, resolveResourceRequestOptions$43(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/utils/base64.mjs +const fromBase64 = (str) => { + if (typeof globalThis.Buffer !== "undefined") { + const buf = globalThis.Buffer.from(str, "base64"); + return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength); + } + if (typeof atob !== "undefined") { + const bstr = atob(str); + const buf = new Uint8Array(bstr.length); + for (let i = 0; i < bstr.length; i++) buf[i] = bstr.charCodeAt(i); + return buf; + } + throw new OpenAIError("Cannot decode base64 string; Expected `Buffer` or `atob` to be defined"); +}; +/** +* Converts a Base64 encoded string to a Float32Array. +* @param base64Str - The Base64 encoded string. +* @returns An Array of numbers interpreted as Float32 values. +*/ +const toFloat32Array = (base64Str) => { + if (typeof Buffer !== "undefined") { + const buf = Buffer.from(base64Str, "base64"); + if (buf.length % Float32Array.BYTES_PER_ELEMENT !== 0) throw new RangeError("Invalid base64-encoded float32 array: byte length must be a multiple of 4"); + return Array.from(new Float32Array(buf.buffer, buf.byteOffset, buf.length / Float32Array.BYTES_PER_ELEMENT)); + } else { + const binaryStr = atob(base64Str); + const len = binaryStr.length; + const bytes = new Uint8Array(len); + for (let i = 0; i < len; i++) bytes[i] = binaryStr.charCodeAt(i); + return Array.from(new Float32Array(bytes.buffer)); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/utils/env.mjs +/** +* Read an environment variable. +* +* Trims beginning and trailing whitespace. +* +* Will return undefined if the environment variable doesn't exist or cannot be accessed. +*/ +const readEnv = (env) => { + try { + if (typeof globalThis.process !== "undefined") return globalThis.process.env?.[env]?.trim() || void 0; + if (typeof globalThis.Deno !== "undefined") return globalThis.Deno.env?.get?.(env)?.trim() || void 0; + } catch { + return; + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/assistant-stream-delta.mjs +const MAX_ASSISTANT_STREAM_ARRAY_GROWTH = 1024; +const MAX_EXTERNALLY_MUTABLE_ASSISTANT_STREAM_ARRAY_LENGTH = 65536; +function getAssistantStreamDiagnosticProperty(property) { + switch (property) { + case "value": + case "arguments": + case "input": + case "text": + case "content": + case "annotations": + case "metadata": + case "name": + case "role": + case "status": + case "tool_calls": + case "step_details": return property; + default: return "unknown"; + } +} +const assistantStreamArrayStates = /* @__PURE__ */ new WeakMap(); +const externallyMutableAssistantStreamValues = /* @__PURE__ */ new WeakSet(); +function createAssistantStreamDeltaProjection(cacheArrays) { + return { + arrays: /* @__PURE__ */ new Map(), + cacheArrays, + records: /* @__PURE__ */ new WeakMap() + }; +} +function commitAssistantStreamArrayProjection(projection) { + for (const [array, projected] of projection.arrays) if (projected.cacheable && !externallyMutableAssistantStreamValues.has(array)) assistantStreamArrayStates.set(array, { + length: projected.length, + ownEntryCount: projected.ownEntryCount + }); + else assistantStreamArrayStates.delete(array); +} +function isPrimitiveAssistantStreamValue(value) { + return typeof value === "string" || typeof value === "number"; +} +function isPrimitiveAssistantStreamArrayDelta(accumulator, delta) { + return delta.every(isPrimitiveAssistantStreamValue) && accumulator.every(isPrimitiveAssistantStreamValue); +} +function countOwnAssistantStreamArrayEntries(accumulator) { + let count = 0; + for (const key of Object.keys(accumulator)) { + const index = Number(key); + if (Number.isSafeInteger(index) && index >= 0 && index < accumulator.length && String(index) === key) count += 1; + } + return count; +} +function getAssistantStreamArrayOwnEntryCount(accumulator, enforceSparseHoleBudget, cachedState) { + if (!enforceSparseHoleBudget) return 0; + if (cachedState?.length === accumulator.length) return cachedState.ownEntryCount; + return countOwnAssistantStreamArrayEntries(accumulator); +} +function getAssistantStreamDeltaIndex(deltaEntry, kind, baselineLength) { + const { index } = deltaEntry; + if (kind === "array" && (index === null || index === void 0)) throw new Error("Expected array delta entry to have an `index` property"); + if (kind === "array" && typeof index !== "number") throw new TypeError("Expected array delta entry `index` property to be a number but got an invalid value"); + if (!Number.isSafeInteger(index) || index < 0 || index >= baselineLength + MAX_ASSISTANT_STREAM_ARRAY_GROWTH || index >= MAX_EXTERNALLY_MUTABLE_ASSISTANT_STREAM_ARRAY_LENGTH) throw new OpenAIError(`Assistant stream delta contains an invalid ${kind} index: ${typeof index === "number" ? index : "unknown"}`); + return index; +} +function assertValidAssistantStreamArrayDelta(accumulator, delta, kind, projection, validateRecord) { + let projectedArray = projection.arrays.get(accumulator); + if (!projectedArray) { + const enforceSparseHoleBudget = projection.cacheArrays && !externallyMutableAssistantStreamValues.has(accumulator); + const cachedState = enforceSparseHoleBudget ? assistantStreamArrayStates.get(accumulator) : void 0; + projectedArray = { + baselineLength: accumulator.length, + cacheable: enforceSparseHoleBudget, + enforceSparseHoleBudget, + entries: /* @__PURE__ */ new Map(), + length: accumulator.length, + ownEntryCount: getAssistantStreamArrayOwnEntryCount(accumulator, enforceSparseHoleBudget, cachedState) + }; + projection.arrays.set(accumulator, projectedArray); + } + for (const deltaEntry of delta) { + if (!isObj(deltaEntry)) throw new Error("Expected array delta entry to be an object but got an invalid value"); + const validatedIndex = getAssistantStreamDeltaIndex(deltaEntry, kind, projectedArray.baselineLength); + let accumulatedEntry; + if (projectedArray.entries.has(validatedIndex)) accumulatedEntry = projectedArray.entries.get(validatedIndex); + else if (hasOwn(accumulator, validatedIndex)) { + accumulatedEntry = accumulator[validatedIndex]; + if (accumulatedEntry === null || accumulatedEntry === void 0) projectedArray.entries.set(validatedIndex, deltaEntry); + } else { + projectedArray.entries.set(validatedIndex, deltaEntry); + projectedArray.ownEntryCount += 1; + } + const projectedLength = Math.max(projectedArray.length, validatedIndex + 1); + if (projectedArray.enforceSparseHoleBudget && projectedLength - projectedArray.ownEntryCount > MAX_ASSISTANT_STREAM_ARRAY_GROWTH) throw new OpenAIError(`Assistant stream delta contains an invalid ${kind} index: ${validatedIndex}`); + if (isObj(accumulatedEntry)) validateRecord(accumulatedEntry, deltaEntry, projection); + projectedArray.length = projectedLength; + } +} +function assertValidAssistantStreamDeltaIndices(accumulator, delta, projection) { + let projectedValues = projection.records.get(accumulator); + for (const [key, deltaValue] of Object.entries(delta)) { + if (key === "index" || key === "type") continue; + let accumulatedValue; + if (projectedValues?.has(key)) accumulatedValue = projectedValues.get(key); + else if (hasOwn(accumulator, key)) accumulatedValue = accumulator[key]; + if (accumulatedValue === null || accumulatedValue === void 0) { + if (!projectedValues) { + projectedValues = /* @__PURE__ */ new Map(); + projection.records.set(accumulator, projectedValues); + } + projectedValues.set(key, deltaValue); + continue; + } + if (isObj(accumulatedValue) && isObj(deltaValue)) assertValidAssistantStreamDeltaIndices(accumulatedValue, deltaValue, projection); + else if (Array.isArray(accumulatedValue) && Array.isArray(deltaValue) && !isPrimitiveAssistantStreamArrayDelta(accumulatedValue, deltaValue)) assertValidAssistantStreamArrayDelta(accumulatedValue, deltaValue, "array", projection, assertValidAssistantStreamDeltaIndices); + } +} +function isAssistantStreamValueExternallyMutable(value) { + return (isObj(value) || Array.isArray(value)) && externallyMutableAssistantStreamValues.has(value); +} +function markAssistantStreamValueExternallyMutable(value) { + if (!isObj(value) && !Array.isArray(value) || externallyMutableAssistantStreamValues.has(value)) return; + externallyMutableAssistantStreamValues.add(value); + if (Array.isArray(value)) assistantStreamArrayStates.delete(value); + for (const key of Reflect.ownKeys(value)) { + const descriptor = Object.getOwnPropertyDescriptor(value, key); + if (descriptor && "value" in descriptor) markAssistantStreamValueExternallyMutable(descriptor.value); + } +} +function defineAssistantStreamArrayEntry(accumulator, index, value) { + if (externallyMutableAssistantStreamValues.has(accumulator)) markAssistantStreamValueExternallyMutable(value); + Object.defineProperty(accumulator, index, { + configurable: true, + enumerable: true, + value, + writable: true + }); +} +function getRequiredAssistantStreamArrayIndex(deltaEntry) { + const { index } = deltaEntry; + if (index === null || index === void 0) throw new Error("Expected array delta entry to have an `index` property"); + if (typeof index !== "number") throw new TypeError("Expected array delta entry `index` property to be a number but got an invalid value"); + return index; +} +function applyAssistantStreamArrayDelta(accumulator, delta, applyRecord) { + if (isPrimitiveAssistantStreamArrayDelta(accumulator, delta)) { + accumulator.push(...delta); + assistantStreamArrayStates.delete(accumulator); + return; + } + for (const deltaEntry of delta) { + if (!isObj(deltaEntry)) throw new Error("Expected array delta entry to be an object but got an invalid value"); + const index = getRequiredAssistantStreamArrayIndex(deltaEntry); + if (hasOwn(accumulator, index)) { + const accumulatedEntry = accumulator[index]; + if (accumulatedEntry === null || accumulatedEntry === void 0) { + if (externallyMutableAssistantStreamValues.has(accumulator)) markAssistantStreamValueExternallyMutable(deltaEntry); + accumulator[index] = deltaEntry; + } else accumulator[index] = applyRecord(accumulatedEntry, deltaEntry); + } else defineAssistantStreamArrayEntry(accumulator, index, deltaEntry); + } +} +function applyAssistantStreamDelta(accumulator, delta) { + const externallyMutable = externallyMutableAssistantStreamValues.has(accumulator); + for (const [key, deltaValue] of Object.entries(delta)) { + if (key === "__proto__" || key === "constructor" || key === "prototype") throw new OpenAIError(`Assistant stream delta contains an unsafe property: ${key}`); + if (!hasOwn(accumulator, key)) { + if (externallyMutable) markAssistantStreamValueExternallyMutable(deltaValue); + accumulator[key] = deltaValue; + continue; + } + let accumulatedValue = accumulator[key]; + if (accumulatedValue === null || accumulatedValue === void 0) { + if (externallyMutable) markAssistantStreamValueExternallyMutable(deltaValue); + accumulator[key] = deltaValue; + continue; + } + if (key === "index" || key === "type") { + accumulator[key] = deltaValue; + continue; + } + if (typeof accumulatedValue === "string" && typeof deltaValue === "string") accumulatedValue += deltaValue; + else if (typeof accumulatedValue === "number" && typeof deltaValue === "number") accumulatedValue += deltaValue; + else if (isObj(accumulatedValue) && isObj(deltaValue)) accumulatedValue = applyAssistantStreamDelta(accumulatedValue, deltaValue); + else if (Array.isArray(accumulatedValue) && Array.isArray(deltaValue)) { + applyAssistantStreamArrayDelta(accumulatedValue, deltaValue, applyAssistantStreamDelta); + continue; + } else throw new TypeError(`Unhandled record type: ${getAssistantStreamDiagnosticProperty(key)}`); + accumulator[key] = accumulatedValue; + } + return accumulator; +} +function assertSafeAssistantStreamDelta(value) { + if (!isObj(value) && !Array.isArray(value)) return; + for (const [key, nestedValue] of Object.entries(value)) { + if (key === "__proto__" || key === "constructor" || key === "prototype") throw new OpenAIError(`Assistant stream delta contains an unsafe property: ${key}`); + assertSafeAssistantStreamDelta(nestedValue); + } +} +function accumulateAssistantStreamDelta(accumulator, delta, cacheArrays = false) { + assertSafeAssistantStreamDelta(delta); + const accumulatorRecord = accumulator; + const deltaRecord = delta; + const projection = createAssistantStreamDeltaProjection(cacheArrays && !isAssistantStreamValueExternallyMutable(accumulator)); + assertValidAssistantStreamDeltaIndices(accumulatorRecord, deltaRecord, projection); + applyAssistantStreamDelta(accumulatorRecord, deltaRecord); + commitAssistantStreamArrayProjection(projection); + return accumulator; +} +function createAssistantStreamArrayDeltaCommit(accumulator, delta, kind, cacheArrays = true) { + assertSafeAssistantStreamDelta(delta); + const projection = createAssistantStreamDeltaProjection(cacheArrays && !isAssistantStreamValueExternallyMutable(accumulator)); + assertValidAssistantStreamArrayDelta(accumulator, delta, kind, projection, assertValidAssistantStreamDeltaIndices); + return () => commitAssistantStreamArrayProjection(projection); +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/AssistantStream.mjs +var _AssistantStream_instances; +var _AssistantStream_runStepSnapshots; +var _AssistantStream_runStepIDOwners; +var _AssistantStream_activeRunStepID; +var _AssistantStream_messageSnapshots; +var _AssistantStream_messageIDOwners; +var _AssistantStream_messageSnapshot; +var _AssistantStream_activeMessageID; +var _AssistantStream_finalRun; +var _AssistantStream_currentContentIndex; +var _AssistantStream_currentContent; +var _AssistantStream_currentToolCallIndex; +var _AssistantStream_currentToolCall; +var _AssistantStream_currentEvent; +var _AssistantStream_currentRunSnapshot; +var _AssistantStream_currentRunStepSnapshot; +var _AssistantStream_addEvent; +var _AssistantStream_endRequest; +var _AssistantStream_validateRunStepEvent; +var _AssistantStream_reserveRunStepAlias; +var _AssistantStream_validateMessageEvent; +var _AssistantStream_reserveMessageAlias; +var _AssistantStream_handleMessage; +var _AssistantStream_handleRunStep; +var _AssistantStream_emitExposed; +var _AssistantStream_handleEvent; +var _AssistantStream_accumulateRunStep; +var _AssistantStream_accumulateMessage; +var _AssistantStream_accumulateContent; +var _AssistantStream_handleRun; +function stabilizeAssistantStreamEvent(event) { + const eventDescriptor = Object.getOwnPropertyDescriptor(event, "event"); + const dataDescriptor = Object.getOwnPropertyDescriptor(event, "data"); + const eventType = Reflect.get(event, "event", event); + const data = Reflect.get(event, "data", event); + let stableData = data; + if (eventType === "thread.message.created" || eventType === "thread.message.in_progress" || eventType === "thread.message.delta" || eventType === "thread.message.completed" || eventType === "thread.message.incomplete" || eventType === "thread.run.step.created" || eventType === "thread.run.step.in_progress" || eventType === "thread.run.step.delta" || eventType === "thread.run.step.completed" || eventType === "thread.run.step.failed" || eventType === "thread.run.step.cancelled" || eventType === "thread.run.step.expired") { + const messageID = Object.getOwnPropertyDescriptor(data, "id"); + if (messageID && "value" in messageID && data.id !== messageID.value) { + const canonicalID = messageID.value; + stableData = new Proxy(data, { get(target, property) { + return property === "id" ? canonicalID : Reflect.get(target, property, target); + } }); + } + } + return { + event: Object.freeze({ + event: eventType, + data: stableData + }), + exposedEvent: eventDescriptor !== void 0 && "value" in eventDescriptor && eventDescriptor.value === eventType && dataDescriptor !== void 0 && "value" in dataDescriptor && dataDescriptor.value === data && stableData === data ? event : { + event: eventType, + data: stableData + } + }; +} +/** Streams assistant-run events while accumulating messages, run steps, and tool-call snapshots. */ +var AssistantStream = class AssistantStream extends EventStream { + constructor() { + super(...arguments); + _AssistantStream_instances.add(this); + _AssistantStream_runStepSnapshots.set(this, Object.create(null)); + _AssistantStream_runStepIDOwners.set(this, /* @__PURE__ */ new Map()); + _AssistantStream_activeRunStepID.set(this, void 0); + _AssistantStream_messageSnapshots.set(this, Object.create(null)); + _AssistantStream_messageIDOwners.set(this, /* @__PURE__ */ new Map()); + _AssistantStream_messageSnapshot.set(this, void 0); + _AssistantStream_activeMessageID.set(this, void 0); + _AssistantStream_finalRun.set(this, void 0); + _AssistantStream_currentContentIndex.set(this, void 0); + _AssistantStream_currentContent.set(this, void 0); + _AssistantStream_currentToolCallIndex.set(this, void 0); + _AssistantStream_currentToolCall.set(this, void 0); + _AssistantStream_currentEvent.set(this, void 0); + _AssistantStream_currentRunSnapshot.set(this, void 0); + _AssistantStream_currentRunStepSnapshot.set(this, void 0); + } + /** Iterates over cloned raw assistant events; stopping early aborts the underlying request. */ + [(_AssistantStream_runStepSnapshots = /* @__PURE__ */ new WeakMap(), _AssistantStream_runStepIDOwners = /* @__PURE__ */ new WeakMap(), _AssistantStream_activeRunStepID = /* @__PURE__ */ new WeakMap(), _AssistantStream_messageSnapshots = /* @__PURE__ */ new WeakMap(), _AssistantStream_messageIDOwners = /* @__PURE__ */ new WeakMap(), _AssistantStream_messageSnapshot = /* @__PURE__ */ new WeakMap(), _AssistantStream_activeMessageID = /* @__PURE__ */ new WeakMap(), _AssistantStream_finalRun = /* @__PURE__ */ new WeakMap(), _AssistantStream_currentContentIndex = /* @__PURE__ */ new WeakMap(), _AssistantStream_currentContent = /* @__PURE__ */ new WeakMap(), _AssistantStream_currentToolCallIndex = /* @__PURE__ */ new WeakMap(), _AssistantStream_currentToolCall = /* @__PURE__ */ new WeakMap(), _AssistantStream_currentEvent = /* @__PURE__ */ new WeakMap(), _AssistantStream_currentRunSnapshot = /* @__PURE__ */ new WeakMap(), _AssistantStream_currentRunStepSnapshot = /* @__PURE__ */ new WeakMap(), _AssistantStream_instances = /* @__PURE__ */ new WeakSet(), Symbol.asyncIterator)]() { + return this._createIterator((push) => { + const onEvent = (event) => push(structuredClone(event)); + this.on("event", onEvent); + return () => this.off("event", onEvent); + }, { onReturn: () => this.abort() }); + } + /** Restores an assistant stream from events serialized by `toReadableStream()`. */ + static fromReadableStream(stream) { + const runner = new AssistantStream(); + runner._run(() => runner._fromReadableStream(stream)); + return runner; + } + async _fromReadableStream(readableStream, options) { + this._listenForAbort(options?.signal); + this._connected(); + const stream = Stream.fromReadableStream(readableStream, this.controller); + for await (const event of stream) __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_addEvent).call(this, event); + if (stream.controller.signal?.aborted) throw this._userAbortError(); + return this._addRun(__classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_endRequest).call(this)); + } + /** Serializes assistant events into a readable stream for transfer to another runtime. */ + toReadableStream() { + return new Stream(this[Symbol.asyncIterator].bind(this), this.controller).toReadableStream(); + } + /** Submits tool outputs and starts streaming the continuation of an existing assistant run. */ + static createToolAssistantStream(runId, runs, params, options) { + const runner = new AssistantStream(); + runner._run(() => runner._runToolAssistantStream(runId, runs, params, { + ...options, + __metadata: { + ...options?.__metadata, + helperMethod: "stream" + } + })); + return runner; + } + async _createToolAssistantStream(run, runId, params, options) { + this._listenForAbort(options?.signal); + const body = { + ...params, + stream: true + }; + const stream = await run.submitToolOutputs(runId, body, { + ...options, + signal: this.controller.signal + }); + this._connected(); + for await (const event of stream) __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_addEvent).call(this, event); + if (stream.controller.signal?.aborted) throw this._userAbortError(); + return this._addRun(__classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_endRequest).call(this)); + } + /** Creates an assistant thread and starts streaming its newly created run. */ + static createThreadAssistantStream(params, thread, options) { + const runner = new AssistantStream(); + runner._run(() => runner._threadAssistantStream(params, thread, { + ...options, + __metadata: { + ...options?.__metadata, + helperMethod: "stream" + } + })); + return runner; + } + /** Creates a run on an existing assistant thread and starts streaming its events. */ + static createAssistantStream(threadId, runs, params, options) { + const runner = new AssistantStream(); + runner._run(() => runner._runAssistantStream(threadId, runs, params, { + ...options, + __metadata: { + ...options?.__metadata, + helperMethod: "stream" + } + })); + return runner; + } + /** Returns the most recent raw event, or `undefined` before any event arrives. */ + currentEvent() { + markAssistantStreamValueExternallyMutable(__classPrivateFieldGet(this, _AssistantStream_currentEvent, "f")); + return __classPrivateFieldGet(this, _AssistantStream_currentEvent, "f"); + } + /** Returns the latest run snapshot, or `undefined` before a run event arrives. */ + currentRun() { + markAssistantStreamValueExternallyMutable(__classPrivateFieldGet(this, _AssistantStream_currentRunSnapshot, "f")); + return __classPrivateFieldGet(this, _AssistantStream_currentRunSnapshot, "f"); + } + /** Returns the message currently being accumulated, or `undefined` before message creation. */ + currentMessageSnapshot() { + markAssistantStreamValueExternallyMutable(__classPrivateFieldGet(this, _AssistantStream_messageSnapshot, "f")); + return __classPrivateFieldGet(this, _AssistantStream_messageSnapshot, "f"); + } + /** Returns the run step currently being accumulated, or `undefined` before a step begins. */ + currentRunStepSnapshot() { + markAssistantStreamValueExternallyMutable(__classPrivateFieldGet(this, _AssistantStream_currentRunStepSnapshot, "f")); + return __classPrivateFieldGet(this, _AssistantStream_currentRunStepSnapshot, "f"); + } + /** Waits for successful completion and returns the final snapshot of every observed run step. */ + async finalRunSteps() { + await this.done(); + return Object.values(__classPrivateFieldGet(this, _AssistantStream_runStepSnapshots, "f")); + } + /** + * Waits for successful completion and returns the final snapshot of every observed message. + * Terminal message events replace accumulated snapshots without mutating earlier snapshots. + */ + async finalMessages() { + await this.done(); + return Object.values(__classPrivateFieldGet(this, _AssistantStream_messageSnapshots, "f")); + } + /** Waits for completion and returns the final run, or rejects if no terminal run was received. */ + async finalRun() { + await this.done(); + if (!__classPrivateFieldGet(this, _AssistantStream_finalRun, "f")) throw new Error("Final run was not received."); + return __classPrivateFieldGet(this, _AssistantStream_finalRun, "f"); + } + async _createThreadAssistantStream(thread, params, options) { + this._listenForAbort(options?.signal); + const body = { + ...params, + stream: true + }; + const stream = await thread.createAndRun(body, { + ...options, + signal: this.controller.signal + }); + this._connected(); + for await (const event of stream) __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_addEvent).call(this, event); + if (stream.controller.signal?.aborted) throw this._userAbortError(); + return this._addRun(__classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_endRequest).call(this)); + } + async _createAssistantStream(run, threadId, params, options) { + this._listenForAbort(options?.signal); + const body = { + ...params, + stream: true + }; + const stream = await run.create(threadId, body, { + ...options, + signal: this.controller.signal + }); + this._connected(); + for await (const event of stream) __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_addEvent).call(this, event); + if (stream.controller.signal?.aborted) throw this._userAbortError(); + return this._addRun(__classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_endRequest).call(this)); + } + /** + * Applies an assistant delta to its mutable snapshot, concatenating text and + * merging nested objects and indexed array entries. + */ + static accumulateDelta(acc, delta) { + return accumulateAssistantStreamDelta(acc, delta); + } + _addRun(run) { + __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_emitExposed).call(this, "run", run); + return run; + } + async _threadAssistantStream(params, thread, options) { + return await this._createThreadAssistantStream(thread, params, options); + } + async _runAssistantStream(threadId, runs, params, options) { + return await this._createAssistantStream(runs, threadId, params, options); + } + async _runToolAssistantStream(runId, runs, params, options) { + return await this._createToolAssistantStream(runs, runId, params, options); + } +}; +_AssistantStream_addEvent = function _AssistantStream_addEvent(event) { + if (this.ended) return; + const { event: stableEvent, exposedEvent } = stabilizeAssistantStreamEvent(event); + let messageID; + let messageData; + let runStepID; + let runStepData; + switch (stableEvent.event) { + case "thread.message.created": + case "thread.message.in_progress": + case "thread.message.delta": + case "thread.message.completed": + case "thread.message.incomplete": + messageID = __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_validateMessageEvent).call(this, stableEvent); + messageData = stableEvent.data; + break; + case "thread.run.step.created": + case "thread.run.step.in_progress": + case "thread.run.step.delta": + case "thread.run.step.completed": + case "thread.run.step.failed": + case "thread.run.step.cancelled": + case "thread.run.step.expired": + runStepID = __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_validateRunStepEvent).call(this, stableEvent); + runStepData = stableEvent.data; + } + __classPrivateFieldSet(this, _AssistantStream_currentEvent, exposedEvent, "f"); + __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_handleEvent).call(this, exposedEvent); + if (messageID !== void 0 && messageData !== void 0) __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_reserveMessageAlias).call(this, messageData, messageID); + if (runStepID !== void 0 && runStepData !== void 0) __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_reserveRunStepAlias).call(this, runStepData, runStepID); + if (runStepID === void 0 && __classPrivateFieldGet(this, _AssistantStream_activeRunStepID, "f") !== void 0 && __classPrivateFieldGet(this, _AssistantStream_currentRunStepSnapshot, "f")) __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_reserveRunStepAlias).call(this, __classPrivateFieldGet(this, _AssistantStream_currentRunStepSnapshot, "f"), __classPrivateFieldGet(this, _AssistantStream_activeRunStepID, "f")); + switch (stableEvent.event) { + case "thread.created": break; + case "thread.run.created": + case "thread.run.queued": + case "thread.run.in_progress": + case "thread.run.requires_action": + case "thread.run.completed": + case "thread.run.incomplete": + case "thread.run.failed": + case "thread.run.cancelling": + case "thread.run.cancelled": + case "thread.run.expired": + __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_handleRun).call(this, stableEvent); + break; + case "thread.run.step.created": + case "thread.run.step.in_progress": + case "thread.run.step.delta": + case "thread.run.step.completed": + case "thread.run.step.failed": + case "thread.run.step.cancelled": + case "thread.run.step.expired": { + if (runStepID === void 0) throw new OpenAIError("Received assistant run-step event without a canonical run-step ID"); + const activeRunStep = __classPrivateFieldGet(this, _AssistantStream_runStepSnapshots, "f")[runStepID]; + if (activeRunStep) __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_reserveRunStepAlias).call(this, activeRunStep, runStepID); + __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_handleRunStep).call(this, stableEvent, runStepID); + __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_reserveRunStepAlias).call(this, stableEvent.data, runStepID); + const retainedRunStep = __classPrivateFieldGet(this, _AssistantStream_runStepSnapshots, "f")[runStepID]; + if (retainedRunStep) __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_reserveRunStepAlias).call(this, retainedRunStep, runStepID); + break; + } + case "thread.message.created": + case "thread.message.in_progress": + case "thread.message.delta": + case "thread.message.completed": + case "thread.message.incomplete": + if (messageID !== void 0 && __classPrivateFieldGet(this, _AssistantStream_messageSnapshot, "f")) __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_reserveMessageAlias).call(this, __classPrivateFieldGet(this, _AssistantStream_messageSnapshot, "f"), messageID); + __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_handleMessage).call(this, stableEvent); + if (messageID !== void 0) { + __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_reserveMessageAlias).call(this, stableEvent.data, messageID); + const retainedMessage = __classPrivateFieldGet(this, _AssistantStream_messageSnapshots, "f")[messageID]; + if (retainedMessage) __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_reserveMessageAlias).call(this, retainedMessage, messageID); + } + break; + case "error": throw new APIError(void 0, stableEvent.data, void 0, void 0); + } +}, _AssistantStream_endRequest = function _AssistantStream_endRequest() { + if (this.ended) throw new OpenAIError(`stream has ended, this shouldn't happen`); + if (!__classPrivateFieldGet(this, _AssistantStream_finalRun, "f")) throw new Error("Final run has not been received"); + return __classPrivateFieldGet(this, _AssistantStream_finalRun, "f"); +}, _AssistantStream_validateRunStepEvent = function _AssistantStream_validateRunStepEvent(event) { + const descriptor = Object.getOwnPropertyDescriptor(event.data, "id"); + const runStepID = descriptor && "value" in descriptor ? descriptor.value : void 0; + if (typeof runStepID !== "string" || runStepID.length === 0) throw new OpenAIError("Received assistant run-step event with an invalid run-step ID"); + if (event.event === "thread.run.step.delta") { + const delta = event.data.delta; + if (delta && hasOwn(delta, "id")) throw new OpenAIError("Run-step deltas must not contain an id field"); + } + if (event.event === "thread.run.step.created") { + if (__classPrivateFieldGet(this, _AssistantStream_activeRunStepID, "f") !== void 0) throw new OpenAIError(`Received run-step creation for "${runStepID}" before the active run step "${__classPrivateFieldGet(this, _AssistantStream_activeRunStepID, "f")}" reached a terminal state`); + if (hasOwn(__classPrivateFieldGet(this, _AssistantStream_runStepSnapshots, "f"), runStepID) || __classPrivateFieldGet(this, _AssistantStream_runStepIDOwners, "f").has(runStepID)) throw new OpenAIError(`Received run-step creation for run step "${runStepID}", which has already been created`); + __classPrivateFieldSet(this, _AssistantStream_activeRunStepID, runStepID, "f"); + __classPrivateFieldGet(this, _AssistantStream_runStepIDOwners, "f").set(runStepID, runStepID); + return runStepID; + } + if (__classPrivateFieldGet(this, _AssistantStream_activeRunStepID, "f") !== void 0) { + if (runStepID !== __classPrivateFieldGet(this, _AssistantStream_activeRunStepID, "f")) throw new OpenAIError(`Received ${event.event} for run step "${runStepID}", which does not match the active run step "${__classPrivateFieldGet(this, _AssistantStream_activeRunStepID, "f")}"`); + return runStepID; + } + if (event.event === "thread.run.step.delta") { + if (!hasOwn(__classPrivateFieldGet(this, _AssistantStream_runStepSnapshots, "f"), runStepID)) throw new OpenAIError("Received a RunStepDelta before creation of a snapshot"); + throw new OpenAIError(`Received run-step delta for "${runStepID}" with no active run step`); + } + if (hasOwn(__classPrivateFieldGet(this, _AssistantStream_runStepSnapshots, "f"), runStepID) || __classPrivateFieldGet(this, _AssistantStream_runStepIDOwners, "f").has(runStepID)) throw new OpenAIError(`Received run-step event for run step "${runStepID}", which has already been created`); + __classPrivateFieldGet(this, _AssistantStream_runStepIDOwners, "f").set(runStepID, runStepID); + if (event.event === "thread.run.step.in_progress") __classPrivateFieldSet(this, _AssistantStream_activeRunStepID, runStepID, "f"); + return runStepID; +}, _AssistantStream_reserveRunStepAlias = function _AssistantStream_reserveRunStepAlias(data, canonicalID) { + const descriptor = Object.getOwnPropertyDescriptor(data, "id"); + const runStepID = descriptor && "value" in descriptor ? descriptor.value : void 0; + if (typeof runStepID !== "string" || runStepID.length === 0) throw new OpenAIError("Received assistant run-step event with an invalid run-step ID"); + const owner = __classPrivateFieldGet(this, _AssistantStream_runStepIDOwners, "f").get(runStepID); + if (owner !== void 0 && owner !== canonicalID) throw new OpenAIError(`Received run-step creation for run step "${runStepID}", which has already been created`); + __classPrivateFieldGet(this, _AssistantStream_runStepIDOwners, "f").set(runStepID, canonicalID); +}, _AssistantStream_validateMessageEvent = function _AssistantStream_validateMessageEvent(event) { + const descriptor = Object.getOwnPropertyDescriptor(event.data, "id"); + const messageID = descriptor && "value" in descriptor ? descriptor.value : void 0; + if (typeof messageID !== "string" || messageID.length === 0) throw new OpenAIError("Received assistant message event with an invalid message ID"); + if (event.event === "thread.message.created") { + if (__classPrivateFieldGet(this, _AssistantStream_messageSnapshot, "f")) throw new OpenAIError(`Received message creation for "${messageID}" before the active message "${__classPrivateFieldGet(this, _AssistantStream_activeMessageID, "f")}" reached a terminal state`); + if (hasOwn(__classPrivateFieldGet(this, _AssistantStream_messageSnapshots, "f"), messageID) || __classPrivateFieldGet(this, _AssistantStream_messageIDOwners, "f").has(messageID)) throw new OpenAIError(`Received message creation for message "${messageID}", which has already been created`); + __classPrivateFieldSet(this, _AssistantStream_activeMessageID, messageID, "f"); + __classPrivateFieldGet(this, _AssistantStream_messageIDOwners, "f").set(messageID, messageID); + return messageID; + } + if (!__classPrivateFieldGet(this, _AssistantStream_messageSnapshot, "f")) { + if (event.event === "thread.message.delta") throw new OpenAIError("Received a delta with no existing snapshot (there should be one from message creation)"); + throw new OpenAIError("Received thread message event with no existing snapshot"); + } + if (messageID !== __classPrivateFieldGet(this, _AssistantStream_activeMessageID, "f")) throw new OpenAIError(`Received ${event.event} for message "${messageID}", which does not match the active message "${__classPrivateFieldGet(this, _AssistantStream_activeMessageID, "f")}"`); + return messageID; +}, _AssistantStream_reserveMessageAlias = function _AssistantStream_reserveMessageAlias(data, canonicalID) { + const descriptor = Object.getOwnPropertyDescriptor(data, "id"); + const messageID = descriptor && "value" in descriptor ? descriptor.value : void 0; + if (typeof messageID !== "string" || messageID.length === 0) throw new OpenAIError("Received assistant message event with an invalid message ID"); + const owner = __classPrivateFieldGet(this, _AssistantStream_messageIDOwners, "f").get(messageID); + if (owner !== void 0 && owner !== canonicalID) throw new OpenAIError(`Received message creation for message "${messageID}", which has already been created`); + __classPrivateFieldGet(this, _AssistantStream_messageIDOwners, "f").set(messageID, canonicalID); +}, _AssistantStream_handleMessage = function _AssistantStream_handleMessage(event) { + const [accumulatedMessage, newContent] = __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_accumulateMessage).call(this, event, __classPrivateFieldGet(this, _AssistantStream_messageSnapshot, "f")); + __classPrivateFieldSet(this, _AssistantStream_messageSnapshot, accumulatedMessage, "f"); + if (!__classPrivateFieldGet(this, _AssistantStream_activeMessageID, "f")) throw new OpenAIError("Received thread message event with no active message ID"); + __classPrivateFieldGet(this, _AssistantStream_messageSnapshots, "f")[__classPrivateFieldGet(this, _AssistantStream_activeMessageID, "f")] = accumulatedMessage; + for (const content of newContent) { + const snapshotContent = accumulatedMessage.content[content.index]; + if (snapshotContent?.type === "text") __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_emitExposed).call(this, "textCreated", snapshotContent.text); + } + switch (event.event) { + case "thread.message.created": + __classPrivateFieldSet(this, _AssistantStream_currentContentIndex, void 0, "f"); + __classPrivateFieldSet(this, _AssistantStream_currentContent, void 0, "f"); + __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_emitExposed).call(this, "messageCreated", event.data); + break; + case "thread.message.in_progress": break; + case "thread.message.delta": + __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_emitExposed).call(this, "messageDelta", event.data.delta, accumulatedMessage); + if (event.data.delta.content) for (const content of event.data.delta.content) { + if (content.type === "text" && content.text) { + const textDelta = content.text; + const snapshot = accumulatedMessage.content[content.index]; + if (snapshot && snapshot.type === "text") __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_emitExposed).call(this, "textDelta", textDelta, snapshot.text); + else throw new Error("The snapshot associated with this text delta is not text or missing"); + } + if (content.index !== __classPrivateFieldGet(this, _AssistantStream_currentContentIndex, "f")) { + if (__classPrivateFieldGet(this, _AssistantStream_currentContent, "f")) switch (__classPrivateFieldGet(this, _AssistantStream_currentContent, "f").type) { + case "text": + __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_emitExposed).call(this, "textDone", __classPrivateFieldGet(this, _AssistantStream_currentContent, "f").text, __classPrivateFieldGet(this, _AssistantStream_messageSnapshot, "f")); + break; + case "image_file": __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_emitExposed).call(this, "imageFileDone", __classPrivateFieldGet(this, _AssistantStream_currentContent, "f").image_file, __classPrivateFieldGet(this, _AssistantStream_messageSnapshot, "f")); + } + __classPrivateFieldSet(this, _AssistantStream_currentContentIndex, content.index, "f"); + } + __classPrivateFieldSet(this, _AssistantStream_currentContent, accumulatedMessage.content[content.index], "f"); + } + break; + case "thread.message.completed": + case "thread.message.incomplete": + if (__classPrivateFieldGet(this, _AssistantStream_currentContentIndex, "f") !== void 0) { + const currentContent = event.data.content[__classPrivateFieldGet(this, _AssistantStream_currentContentIndex, "f")]; + if (currentContent) switch (currentContent.type) { + case "image_file": + __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_emitExposed).call(this, "imageFileDone", currentContent.image_file, __classPrivateFieldGet(this, _AssistantStream_messageSnapshot, "f")); + break; + case "text": __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_emitExposed).call(this, "textDone", currentContent.text, __classPrivateFieldGet(this, _AssistantStream_messageSnapshot, "f")); + } + } + if (__classPrivateFieldGet(this, _AssistantStream_messageSnapshot, "f")) __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_emitExposed).call(this, "messageDone", event.data); + __classPrivateFieldSet(this, _AssistantStream_currentContentIndex, void 0, "f"); + __classPrivateFieldSet(this, _AssistantStream_currentContent, void 0, "f"); + __classPrivateFieldSet(this, _AssistantStream_messageSnapshot, void 0, "f"); + __classPrivateFieldSet(this, _AssistantStream_activeMessageID, void 0, "f"); + } +}, _AssistantStream_handleRunStep = function _AssistantStream_handleRunStep(event, runStepID) { + const accumulatedRunStep = __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_accumulateRunStep).call(this, event, runStepID); + __classPrivateFieldSet(this, _AssistantStream_currentRunStepSnapshot, accumulatedRunStep, "f"); + switch (event.event) { + case "thread.run.step.created": + __classPrivateFieldSet(this, _AssistantStream_currentToolCallIndex, void 0, "f"); + __classPrivateFieldSet(this, _AssistantStream_currentToolCall, void 0, "f"); + __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_emitExposed).call(this, "runStepCreated", event.data); + break; + case "thread.run.step.delta": { + const delta = event.data.delta; + if (delta.step_details && delta.step_details.type === "tool_calls" && delta.step_details.tool_calls && accumulatedRunStep.step_details.type === "tool_calls") for (const toolCall of delta.step_details.tool_calls) if (toolCall.index === __classPrivateFieldGet(this, _AssistantStream_currentToolCallIndex, "f")) __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_emitExposed).call(this, "toolCallDelta", toolCall, accumulatedRunStep.step_details.tool_calls[toolCall.index]); + else { + if (__classPrivateFieldGet(this, _AssistantStream_currentToolCall, "f")) __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_emitExposed).call(this, "toolCallDone", __classPrivateFieldGet(this, _AssistantStream_currentToolCall, "f")); + __classPrivateFieldSet(this, _AssistantStream_currentToolCallIndex, toolCall.index, "f"); + __classPrivateFieldSet(this, _AssistantStream_currentToolCall, accumulatedRunStep.step_details.tool_calls[toolCall.index], "f"); + if (__classPrivateFieldGet(this, _AssistantStream_currentToolCall, "f")) __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_emitExposed).call(this, "toolCallCreated", __classPrivateFieldGet(this, _AssistantStream_currentToolCall, "f")); + } + __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_emitExposed).call(this, "runStepDelta", event.data.delta, accumulatedRunStep); + break; + } + case "thread.run.step.completed": + case "thread.run.step.failed": + case "thread.run.step.cancelled": + case "thread.run.step.expired": + __classPrivateFieldSet(this, _AssistantStream_currentRunStepSnapshot, void 0, "f"); + __classPrivateFieldSet(this, _AssistantStream_activeRunStepID, void 0, "f"); + if (event.data.step_details.type === "tool_calls" && __classPrivateFieldGet(this, _AssistantStream_currentToolCall, "f")) __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_emitExposed).call(this, "toolCallDone", __classPrivateFieldGet(this, _AssistantStream_currentToolCall, "f")); + __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_emitExposed).call(this, "runStepDone", event.data, accumulatedRunStep); + __classPrivateFieldSet(this, _AssistantStream_currentToolCallIndex, void 0, "f"); + __classPrivateFieldSet(this, _AssistantStream_currentToolCall, void 0, "f"); + } +}, _AssistantStream_emitExposed = function _AssistantStream_emitExposed(event, ...args) { + if (this._hasListeners(event)) for (const value of args) markAssistantStreamValueExternallyMutable(value); + this._emit(event, ...args); +}, _AssistantStream_handleEvent = function _AssistantStream_handleEvent(event) { + __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_emitExposed).call(this, "event", event); +}, _AssistantStream_accumulateRunStep = function _AssistantStream_accumulateRunStep(event, runStepID) { + switch (event.event) { + case "thread.run.step.created": + __classPrivateFieldGet(this, _AssistantStream_runStepSnapshots, "f")[runStepID] = event.data; + return event.data; + case "thread.run.step.delta": { + const snapshot = __classPrivateFieldGet(this, _AssistantStream_runStepSnapshots, "f")[runStepID]; + if (!snapshot) throw new Error("Received a RunStepDelta before creation of a snapshot"); + const delta = event.data.delta; + if (delta) { + if (hasOwn(delta, "id")) throw new OpenAIError("Run-step deltas must not contain an id field"); + const accumulated = accumulateAssistantStreamDelta(snapshot, delta, true); + __classPrivateFieldGet(this, _AssistantStream_runStepSnapshots, "f")[runStepID] = accumulated; + } + return __classPrivateFieldGet(this, _AssistantStream_runStepSnapshots, "f")[runStepID]; + } + case "thread.run.step.completed": + case "thread.run.step.failed": + case "thread.run.step.cancelled": + case "thread.run.step.expired": + case "thread.run.step.in_progress": __classPrivateFieldGet(this, _AssistantStream_runStepSnapshots, "f")[runStepID] = event.data; + } + if (__classPrivateFieldGet(this, _AssistantStream_runStepSnapshots, "f")[runStepID]) return __classPrivateFieldGet(this, _AssistantStream_runStepSnapshots, "f")[runStepID]; + throw new Error("No snapshot available"); +}, _AssistantStream_accumulateMessage = function _AssistantStream_accumulateMessage(event, snapshot) { + const newContent = []; + switch (event.event) { + case "thread.message.created": return [event.data, newContent]; + case "thread.message.delta": { + if (!snapshot) throw new Error("Received a delta with no existing snapshot (there should be one from message creation)"); + const data = event.data; + if (data.delta.content) { + assertSafeAssistantStreamDelta(data.delta); + const cacheArrays = !isAssistantStreamValueExternallyMutable(snapshot); + const commitProjection = createAssistantStreamArrayDeltaCommit(snapshot.content, data.delta.content, "content", cacheArrays); + for (const contentElement of data.delta.content) if (hasOwn(snapshot.content, contentElement.index)) { + const currentContent = snapshot.content[contentElement.index]; + snapshot.content[contentElement.index] = __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_accumulateContent).call(this, contentElement, currentContent, cacheArrays); + } else { + defineAssistantStreamArrayEntry(snapshot.content, contentElement.index, contentElement); + newContent.push(contentElement); + } + commitProjection(); + } + return [snapshot, newContent]; + } + case "thread.message.in_progress": + case "thread.message.completed": + case "thread.message.incomplete": + if (snapshot) return [event.event === "thread.message.in_progress" ? snapshot : event.data, newContent]; + throw new Error("Received thread message event with no existing snapshot"); + } + throw new Error("Tried to accumulate a non-message event"); +}, _AssistantStream_accumulateContent = function _AssistantStream_accumulateContent(contentElement, currentContent, cacheArrays) { + return accumulateAssistantStreamDelta(currentContent, contentElement, cacheArrays); +}, _AssistantStream_handleRun = function _AssistantStream_handleRun(event) { + __classPrivateFieldSet(this, _AssistantStream_currentRunSnapshot, event.data, "f"); + switch (event.event) { + case "thread.run.created": break; + case "thread.run.queued": break; + case "thread.run.in_progress": break; + case "thread.run.requires_action": + case "thread.run.cancelled": + case "thread.run.failed": + case "thread.run.completed": + case "thread.run.expired": + case "thread.run.incomplete": + __classPrivateFieldSet(this, _AssistantStream_finalRun, event.data, "f"); + if (__classPrivateFieldGet(this, _AssistantStream_currentToolCall, "f")) __classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_emitExposed).call(this, "toolCallDone", __classPrivateFieldGet(this, _AssistantStream_currentToolCall, "f")); + __classPrivateFieldSet(this, _AssistantStream_currentToolCallIndex, void 0, "f"); + __classPrivateFieldSet(this, _AssistantStream_currentToolCall, void 0, "f"); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/polling.mjs +function sleepUntilAborted(milliseconds, signal) { + return new Promise((resolve, reject) => { + let timer; + let registered; + let settled = false; + const removeAbortListener = (listener) => { + try { + signal.removeEventListener("abort", listener); + } catch {} + }; + const cleanup = () => { + if (timer !== void 0) { + clearTimeout(timer); + timer = void 0; + } + if (registered) { + const listener = registered; + registered = void 0; + removeAbortListener(listener); + } + }; + const abort = () => { + if (settled) return; + settled = true; + cleanup(); + try { + const error = new APIUserAbortError(); + Object.defineProperty(error, "cause", { + value: signal.reason, + writable: true, + configurable: true + }); + reject(error); + } catch (error) { + reject(error); + } + }; + if (signal.aborted) { + abort(); + return; + } + timer = setTimeout(() => { + if (settled) return; + settled = true; + cleanup(); + resolve(); + }, milliseconds); + registered = abort; + try { + signal.addEventListener("abort", abort, { once: true }); + if (settled) removeAbortListener(abort); + else if (signal.aborted) abort(); + } catch (error) { + if (settled) removeAbortListener(abort); + else { + settled = true; + cleanup(); + reject(error); + } + } + }); +} +/** +* Repeatedly retrieves a lifecycle resource using the existing polling-helper +* headers. Intermediate states wait for the explicit interval (including zero), +* the server interval, or five-second default; terminal states return the same parsed object. +* The caller's signal interrupts intermediate waits, unknown states retry +* immediately, and retrieval errors propagate unchanged. +* +* @internal +*/ +async function pollWithResponse(retrieve, intermediateStatuses, terminalStatuses, options) { + const headers = buildHeaders([options?.headers, { + "X-Stainless-Poll-Helper": "true", + "X-Stainless-Custom-Poll-Interval": options?.pollIntervalMs?.toString() ?? void 0 + }]); + while (true) { + const { data, response } = await retrieve(headers).withResponse(); + const { status } = data; + if (intermediateStatuses.includes(status)) { + let sleepInterval = 5e3; + const pollIntervalMs = options?.pollIntervalMs; + if (pollIntervalMs || pollIntervalMs === 0) sleepInterval = pollIntervalMs; + else { + const headerInterval = response.headers.get("openai-poll-after-ms"); + if (headerInterval) { + const headerIntervalMs = Number.parseInt(headerInterval); + if (!Number.isNaN(headerIntervalMs)) sleepInterval = headerIntervalMs; + } + } + const signal = options && Object.prototype.propertyIsEnumerable.call(options, "signal") ? options.signal : void 0; + await (signal ? sleepUntilAborted(sleepInterval, signal) : sleep(sleepInterval)); + } else if (terminalStatuses.includes(status)) return data; + } +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/assistant-run-polling.mjs +/** +* Polls an assistant run through the resource's retrieve method, preserving the +* original params object, request-header merge, and terminal run states. +* +* @internal +*/ +function pollAssistantRun(resource, runID, params, options) { + return pollWithResponse((headers) => resource.retrieve(runID, params, { + ...options, + headers: { + ...options?.headers, + ...headers + } + }), [ + "queued", + "in_progress", + "cancelling" + ], [ + "requires_action", + "incomplete", + "cancelled", + "completed", + "failed", + "expired" + ], options); +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/threads/runs/runs.mjs +function resolveResourceRequestOptions$42(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$17 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$17(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$17.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$17.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +/** +* Build Assistants that can call models and use tools. +* +* @deprecated The Assistants API is deprecated in favor of the Responses API +*/ +var Runs$1 = class extends APIResource { + constructor() { + super(...arguments); + this.steps = new Steps(this._client); + } + create(threadID, params, options) { + const { include, ...body } = params; + return this._client.post(path`/threads/${threadID}/runs`, resolveResourceRequestOptions$42(options, (options) => ({ + query: { include }, + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + stream: params.stream ?? false, + __synthesizeEventData: true, + __security: { bearerAuth: true } + }))); + } + /** + * Retrieves a run. + * + * @deprecated The Assistants API is deprecated in favor of the Responses API + */ + retrieve(runID, params, options) { + const { thread_id } = params; + return this._client.get(path`/threads/${thread_id}/runs/${runID}`, resolveResourceRequestOptions$42(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Modifies a run. + * + * @deprecated The Assistants API is deprecated in favor of the Responses API + */ + update(runID, params, options) { + const { thread_id, ...body } = params; + return this._client.post(path`/threads/${thread_id}/runs/${runID}`, resolveResourceRequestOptions$42(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + list(threadID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$17(query, [ + "after", + "before", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/threads/${threadID}/runs`, CursorPage, resolveResourceRequestOptions$42(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Cancels a run that is `in_progress`. + * + * @deprecated The Assistants API is deprecated in favor of the Responses API + */ + cancel(runID, params, options) { + const { thread_id } = params; + return this._client.post(path`/threads/${thread_id}/runs/${runID}/cancel`, resolveResourceRequestOptions$42(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * A helper to create a run an poll for a terminal state. More information on Run + * lifecycles can be found here: + * https://platform.openai.com/docs/assistants/how-it-works/runs-and-run-steps + */ + async createAndPoll(threadId, body, options) { + const run = await this.create(threadId, body, options); + return await this.poll(run.id, { thread_id: threadId }, options); + } + /** + * Create a Run stream + * + * @deprecated use `stream` instead + */ + createAndStream(threadId, body, options) { + return AssistantStream.createAssistantStream(threadId, this._client.beta.threads.runs, body, options); + } + /** + * A helper to poll a run status until it reaches a terminal state. More + * information on Run lifecycles can be found here: + * https://platform.openai.com/docs/assistants/how-it-works/runs-and-run-steps + */ + async poll(runId, params, options) { + return await pollAssistantRun(this, runId, params, options); + } + /** + * Create a Run stream + */ + stream(threadId, body, options) { + return AssistantStream.createAssistantStream(threadId, this._client.beta.threads.runs, body, options); + } + submitToolOutputs(runID, params, options) { + const { thread_id, ...body } = params; + return this._client.post(path`/threads/${thread_id}/runs/${runID}/submit_tool_outputs`, resolveResourceRequestOptions$42(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + stream: params.stream ?? false, + __synthesizeEventData: true, + __security: { bearerAuth: true } + }))); + } + /** + * A helper to submit a tool output to a run and poll for a terminal run state. + * More information on Run lifecycles can be found here: + * https://platform.openai.com/docs/assistants/how-it-works/runs-and-run-steps + */ + async submitToolOutputsAndPoll(runId, params, options) { + const run = await this.submitToolOutputs(runId, params, options); + return await this.poll(run.id, params, options); + } + /** + * Submit the tool outputs from a previous run and stream the run to a terminal + * state. More information on Run lifecycles can be found here: + * https://platform.openai.com/docs/assistants/how-it-works/runs-and-run-steps + */ + submitToolOutputsStream(runId, params, options) { + return AssistantStream.createToolAssistantStream(runId, this._client.beta.threads.runs, params, options); + } +}; +Runs$1.Steps = Steps; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/threads/threads.mjs +function resolveResourceRequestOptions$41(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +/** +* Build Assistants that can call models and use tools. +* +* @deprecated The Assistants API is deprecated in favor of the Responses API +*/ +var Threads = class extends APIResource { + constructor() { + super(...arguments); + this.runs = new Runs$1(this._client); + this.messages = new Messages(this._client); + } + /** + * Create a thread. + * + * @deprecated The Assistants API is deprecated in favor of the Responses API + */ + create(body = {}, options) { + return this._client.post("/threads", resolveResourceRequestOptions$41(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Retrieves a thread. + * + * @deprecated The Assistants API is deprecated in favor of the Responses API + */ + retrieve(threadID, options) { + return this._client.get(path`/threads/${threadID}`, resolveResourceRequestOptions$41(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Modifies a thread. + * + * @deprecated The Assistants API is deprecated in favor of the Responses API + */ + update(threadID, body, options) { + return this._client.post(path`/threads/${threadID}`, resolveResourceRequestOptions$41(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Delete a thread. + * + * @deprecated The Assistants API is deprecated in favor of the Responses API + */ + delete(threadID, options) { + return this._client.delete(path`/threads/${threadID}`, resolveResourceRequestOptions$41(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + createAndRun(body, options) { + return this._client.post("/threads/runs", resolveResourceRequestOptions$41(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + stream: body.stream ?? false, + __synthesizeEventData: true, + __security: { bearerAuth: true } + }))); + } + /** + * A helper to create a thread, start a run and then poll for a terminal state. + * More information on Run lifecycles can be found here: + * https://platform.openai.com/docs/assistants/how-it-works/runs-and-run-steps + */ + async createAndRunPoll(body, options) { + const run = await this.createAndRun(body, options); + return await this.runs.poll(run.id, { thread_id: run.thread_id }, options); + } + /** + * Create a thread and stream the run back + */ + createAndRunStream(body, options) { + return AssistantStream.createThreadAssistantStream(body, this._client.beta.threads, options); + } +}; +Threads.Runs = Runs$1; +Threads.Messages = Messages; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/beta/beta.mjs +var Beta = class extends APIResource { + constructor() { + super(...arguments); + this.realtime = new Realtime$1(this._client); + this.agents = new Agents(this._client); + this.responses = new Responses$1(this._client); + this.chatkit = new ChatKit(this._client); + this.assistants = new Assistants(this._client); + this.threads = new Threads(this._client); + } +}; +Beta.Realtime = Realtime$1; +Beta.Agents = Agents; +Beta.Responses = Responses$1; +Beta.ChatKit = ChatKit; +Beta.Assistants = Assistants; +Beta.Threads = Threads; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/completions.mjs +function resolveResourceRequestOptions$40(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +/** +* Given a prompt, the model will return one or more predicted completions, and can also return the probabilities of alternative tokens at each position. +*/ +var Completions = class extends APIResource { + create(body, options) { + return this._client.post("/completions", resolveResourceRequestOptions$40(options, (options) => ({ + body, + ...options, + stream: body.stream ?? false, + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/containers/files/content.mjs +function resolveResourceRequestOptions$39(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var Content$2 = class extends APIResource { + /** + * Retrieve Container File Content + */ + retrieve(fileID, params, options) { + const { container_id } = params; + return this._client.get(path`/containers/${container_id}/files/${fileID}/content`, resolveResourceRequestOptions$39(options, (options) => ({ + ...options, + headers: buildHeaders([{ Accept: "application/binary" }, options?.headers]), + __security: { bearerAuth: true }, + __binaryResponse: true + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/containers/files/files.mjs +function resolveResourceRequestOptions$38(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$16 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$16(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$16.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$16.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Files$2 = class extends APIResource { + constructor() { + super(...arguments); + this.content = new Content$2(this._client); + } + /** + * Create a Container File + * + * You can send either a multipart/form-data request with the raw file content, or + * a JSON request with a file ID. + */ + create(containerID, body, options) { + return this._client.post(path`/containers/${containerID}/files`, resolveResourceRequestOptions$38(options, (options) => maybeMultipartFormRequestOptions({ + body, + ...options, + __security: { bearerAuth: true } + }, this._client))); + } + /** + * Retrieve Container File + */ + retrieve(fileID, params, options) { + const { container_id } = params; + return this._client.get(path`/containers/${container_id}/files/${fileID}`, resolveResourceRequestOptions$38(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + list(containerID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$16(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/containers/${containerID}/files`, CursorPage, resolveResourceRequestOptions$38(options, (options) => ({ + query, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Delete Container File + */ + delete(fileID, params, options) { + const { container_id } = params; + return this._client.delete(path`/containers/${container_id}/files/${fileID}`, resolveResourceRequestOptions$38(options, (options) => ({ + ...options, + headers: buildHeaders([{ Accept: "*/*" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +Files$2.Content = Content$2; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/containers/containers.mjs +function resolveResourceRequestOptions$37(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$15 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$15(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$15.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$15.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Containers = class extends APIResource { + constructor() { + super(...arguments); + this.files = new Files$2(this._client); + } + /** + * Create Container + */ + create(body, options) { + return this._client.post("/containers", resolveResourceRequestOptions$37(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Retrieve Container + */ + retrieve(containerID, options) { + return this._client.get(path`/containers/${containerID}`, resolveResourceRequestOptions$37(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$15(query, [ + "after", + "limit", + "name", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/containers", CursorPage, resolveResourceRequestOptions$37(options, (options) => ({ + query, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Delete Container + */ + delete(containerID, options) { + return this._client.delete(path`/containers/${containerID}`, resolveResourceRequestOptions$37(options, (options) => ({ + ...options, + headers: buildHeaders([{ Accept: "*/*" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +Containers.Files = Files$2; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/content-provenance-checks.mjs +function resolveResourceRequestOptions$36(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var ContentProvenanceChecks = class extends APIResource { + /** + * Check whether an image or audio file contains known OpenAI provenance signals. + * [Learn more about content provenance](https://developers.openai.com/api/docs/guides/content-provenance). + * + * If `not_detected`, it means the tool did not find supported signals in the + * uploaded file. The content could still have been generated by OpenAI if the + * metadata was stripped or has evidence of tampering, the watermark was degraded, + * it comes from a legacy generation model, or it was created before provenance + * signals were available. Content could also still be AI-generated by another + * company's model, which the tool currently does not detect. + */ + create(body, options) { + return this._client.post("/content_provenance_checks", resolveResourceRequestOptions$36(options, (options) => multipartFormRequestOptions({ + body, + ...options, + __security: { bearerAuth: true } + }, this._client))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/conversations/items.mjs +function resolveResourceRequestOptions$35(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$14 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$14(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$14.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$14.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +/** +* Manage conversations and conversation items. +*/ +var Items = class extends APIResource { + /** + * Create items in a conversation with the given ID. + */ + create(conversationID, params, options) { + const { include, ...body } = params; + return this._client.post(path`/conversations/${conversationID}/items`, resolveResourceRequestOptions$35(options, (options) => ({ + query: { include }, + body, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Get a single item from a conversation with the given IDs. + */ + retrieve(itemID, params, options) { + const { conversation_id, ...query } = params; + return this._client.get(path`/conversations/${conversation_id}/items/${itemID}`, resolveResourceRequestOptions$35(options, (options) => ({ + query, + ...options, + __security: { bearerAuth: true } + }))); + } + list(conversationID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$14(query, [ + "after", + "include", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/conversations/${conversationID}/items`, ConversationCursorPage, resolveResourceRequestOptions$35(options, (options) => ({ + query, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Delete an item from a conversation with the given IDs. + */ + delete(itemID, params, options) { + const { conversation_id } = params; + return this._client.delete(path`/conversations/${conversation_id}/items/${itemID}`, resolveResourceRequestOptions$35(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/conversations/conversations.mjs +function resolveResourceRequestOptions$34(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +/** +* Manage conversations and conversation items. +*/ +var Conversations = class extends APIResource { + constructor() { + super(...arguments); + this.items = new Items(this._client); + } + /** + * Create a conversation. + */ + create(body = {}, options) { + return this._client.post("/conversations", resolveResourceRequestOptions$34(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Get a conversation + */ + retrieve(conversationID, options) { + return this._client.get(path`/conversations/${conversationID}`, resolveResourceRequestOptions$34(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Update a conversation + */ + update(conversationID, body, options) { + return this._client.post(path`/conversations/${conversationID}`, resolveResourceRequestOptions$34(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Delete a conversation. Items in the conversation will not be deleted. + */ + delete(conversationID, options) { + return this._client.delete(path`/conversations/${conversationID}`, resolveResourceRequestOptions$34(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } +}; +Conversations.Items = Items; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/decisions.mjs +function resolveResourceRequestOptions$33(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var Decisions = class extends APIResource { + /** + * Use this endpoint to quickly answer classification or scoring questions about + * some input. You can ask multiple questions in one request. + */ + create(body, options) { + return this._client.post("/decisions", resolveResourceRequestOptions$33(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/embeddings.mjs +/** +* Sends the optimized embeddings request while preserving explicit encodings and +* the original APIPromise response accessors. +* +* @internal +*/ +function createEmbedding(client, body, options) { + const hasUserProvidedEncodingFormat = !!body.encoding_format; + const encodingFormat = hasUserProvidedEncodingFormat ? body.encoding_format : "base64"; + if (hasUserProvidedEncodingFormat) loggerFor(client).debug("embeddings/user defined encoding_format:", body.encoding_format); + const requestOptions = { + body: { + ...body, + encoding_format: encodingFormat + }, + ...options, + __security: { bearerAuth: true } + }; + const response = client.post("/embeddings", requestOptions); + if (hasUserProvidedEncodingFormat) return response; + loggerFor(client).debug("embeddings/decoding base64 embeddings from base64"); + return response._thenUnwrap((data) => { + const embeddings = data?.data; + if (embeddings !== void 0) { + if (!Array.isArray(embeddings)) throw new TypeError("Expected embeddings response data to be an array"); + const { length } = embeddings; + for (let index = 0; index < length; index += 1) if (index in embeddings) { + const embeddingBase64Obj = embeddings[index]; + const { embedding } = embeddingBase64Obj; + if (Array.isArray(embedding)) continue; + embeddingBase64Obj.embedding = toFloat32Array(embedding); + } + } + return data; + }); +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/embeddings.mjs +/** +* Get a vector representation of a given input that can be easily consumed by machine learning models and algorithms. +*/ +var Embeddings = class extends APIResource { + create(body, options) { + return createEmbedding(this._client, body, options); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/evals/runs/output-items.mjs +function resolveResourceRequestOptions$32(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +/** +* Manage and run evals in the OpenAI platform. +*/ +var OutputItems = class extends APIResource { + /** + * Get an evaluation run output item by ID. + */ + retrieve(outputItemID, params, options) { + const { eval_id, run_id } = params; + return this._client.get(path`/evals/${eval_id}/runs/${run_id}/output_items/${outputItemID}`, resolveResourceRequestOptions$32(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Get a list of output items for an evaluation run. + */ + list(runID, params, options) { + const { eval_id, ...query } = params; + return this._client.getAPIList(path`/evals/${eval_id}/runs/${runID}/output_items`, CursorPage, resolveResourceRequestOptions$32(options, (options) => ({ + query, + ...options, + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/evals/runs/runs.mjs +function resolveResourceRequestOptions$31(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$13 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$13(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$13.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$13.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +/** +* Manage and run evals in the OpenAI platform. +*/ +var Runs = class extends APIResource { + constructor() { + super(...arguments); + this.outputItems = new OutputItems(this._client); + } + /** + * Kicks off a new run for a given evaluation, specifying the data source, and what + * model configuration to use to test. The datasource will be validated against the + * schema specified in the config of the evaluation. + */ + create(evalID, body, options) { + return this._client.post(path`/evals/${evalID}/runs`, resolveResourceRequestOptions$31(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Get an evaluation run by ID. + */ + retrieve(runID, params, options) { + const { eval_id } = params; + return this._client.get(path`/evals/${eval_id}/runs/${runID}`, resolveResourceRequestOptions$31(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + list(evalID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$13(query, [ + "after", + "limit", + "order", + "status" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/evals/${evalID}/runs`, CursorPage, resolveResourceRequestOptions$31(options, (options) => ({ + query, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Delete an eval run. + */ + delete(runID, params, options) { + const { eval_id } = params; + return this._client.delete(path`/evals/${eval_id}/runs/${runID}`, resolveResourceRequestOptions$31(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Cancel an ongoing evaluation run. + */ + cancel(runID, params, options) { + const { eval_id } = params; + return this._client.post(path`/evals/${eval_id}/runs/${runID}/cancel`, resolveResourceRequestOptions$31(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } +}; +Runs.OutputItems = OutputItems; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/evals/evals.mjs +function resolveResourceRequestOptions$30(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$12 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$12(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$12.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$12.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +/** +* Manage and run evals in the OpenAI platform. +*/ +var Evals = class extends APIResource { + constructor() { + super(...arguments); + this.runs = new Runs(this._client); + } + /** + * Create the structure of an evaluation that can be used to test a model's + * performance. An evaluation is a set of testing criteria and the config for a + * data source, which dictates the schema of the data used in the evaluation. After + * creating an evaluation, you can run it on different models and model parameters. + * We support several types of graders and datasources. For more information, see + * the [Evals guide](https://developers.openai.com/api/docs/guides/evals). + */ + create(body, options) { + return this._client.post("/evals", resolveResourceRequestOptions$30(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Get an evaluation by ID. + */ + retrieve(evalID, options) { + return this._client.get(path`/evals/${evalID}`, resolveResourceRequestOptions$30(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Update certain properties of an evaluation. + */ + update(evalID, body, options) { + return this._client.post(path`/evals/${evalID}`, resolveResourceRequestOptions$30(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$12(query, [ + "after", + "limit", + "order", + "order_by" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/evals", CursorPage, resolveResourceRequestOptions$30(options, (options) => ({ + query, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Delete an evaluation. + */ + delete(evalID, options) { + return this._client.delete(path`/evals/${evalID}`, resolveResourceRequestOptions$30(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } +}; +Evals.Runs = Runs; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/file-processing.mjs +/** +* Waits for file processing through the resource's retrieve method. Elapsed time +* uses a monotonic clock so system clock changes do not affect the timeout, +* which is checked after each subsequent retrieval, preserving the existing behavior +* for an initially terminal file and for a terminal response received too late. +* +* @internal +*/ +async function waitForFileProcessing(resource, id, pollInterval, maxWait) { + const terminalStates = /* @__PURE__ */ new Set([ + "processed", + "error", + "deleted" + ]); + const start = performance.now(); + let file = await resource.retrieve(id); + while (!file.status || !terminalStates.has(file.status)) { + await sleep(pollInterval); + file = await resource.retrieve(id); + if (performance.now() - start > maxWait) throw new APIConnectionTimeoutError({ message: `Giving up on waiting for file ${id} to finish processing after ${maxWait} milliseconds.` }); + } + return file; +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/files.mjs +function resolveResourceRequestOptions$29(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$11 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$11(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$11.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$11.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +/** +* Files are used to upload documents that can be used with features like Assistants and Fine-tuning. +*/ +var Files$1 = class extends APIResource { + /** + * Upload a file that can be used across various endpoints. Individual files can be + * up to 512 MB, and each project can store up to 2.5 TB of files in total. There + * is no organization-wide storage limit. Uploads to this endpoint are rate-limited + * to 1,000 requests per minute per authenticated user. + * + * - The Assistants API supports files up to 2 million tokens and of specific file + * types. See the + * [Assistants Tools guide](https://developers.openai.com/api/docs/guides/tools) + * for details. + * - The Fine-tuning API only supports `.jsonl` files. The input also has certain + * required formats for fine-tuning + * [chat](https://developers.openai.com/api/docs/guides/supervised-fine-tuning#formatting-your-data) + * or + * [completions](https://developers.openai.com/api/docs/guides/supervised-fine-tuning#formatting-your-data) + * models. + * - The Batch API only supports `.jsonl` files up to 200 MB in size. The input + * also has a specific required + * [format](https://developers.openai.com/api/docs/guides/batch#1-prepare-your-batch-file). + * - For Retrieval or `file_search` ingestion, upload files here first. If you need + * to attach multiple uploaded files to the same vector store, use + * [`/vector_stores/{vector_store_id}/file_batches`](https://developers.openai.com/api/reference/resources/vector_stores/subresources/file_batches/methods/create) + * instead of attaching them one by one. Vector store attachment has separate + * limits from file upload, including 2,000 attached files per minute per + * organization. + * + * Please [contact us](https://help.openai.com/) if you need to increase these + * storage limits. + */ + create(body, options) { + return this._client.post("/files", resolveResourceRequestOptions$29(options, (options) => multipartFormRequestOptions({ + body, + ...options, + __security: { bearerAuth: true } + }, this._client))); + } + /** + * Returns information about a specific file. + */ + retrieve(fileID, options) { + return this._client.get(path`/files/${fileID}`, resolveResourceRequestOptions$29(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$11(query, [ + "after", + "limit", + "order", + "purpose" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/files", CursorPage, resolveResourceRequestOptions$29(options, (options) => ({ + query, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Delete a file and remove it from all vector stores. + */ + delete(fileID, options) { + return this._client.delete(path`/files/${fileID}`, resolveResourceRequestOptions$29(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Returns a response containing the contents of the specified file. + */ + content(fileID, options) { + return this._client.get(path`/files/${fileID}/content`, resolveResourceRequestOptions$29(options, (options) => ({ + ...options, + headers: buildHeaders([{ Accept: "application/binary" }, options?.headers]), + __security: { bearerAuth: true }, + __binaryResponse: true + }))); + } + /** + * Waits for the given file to be processed, default timeout is 30 mins. + */ + async waitForProcessing(id, { pollInterval = 5e3, maxWait = 18e5 } = {}) { + return await waitForFileProcessing(this, id, pollInterval, maxWait); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/fine-tuning/methods.mjs +var Methods = class extends APIResource {}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/fine-tuning/alpha/graders.mjs +function resolveResourceRequestOptions$28(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +/** +* Manage fine-tuning jobs to tailor a model to your specific training data. +*/ +var Graders$1 = class extends APIResource { + /** + * Run a grader. + * + * @example + * ```ts + * const response = await client.fineTuning.alpha.graders.run({ + * grader: { + * input: 'input', + * name: 'name', + * operation: 'eq', + * reference: 'reference', + * type: 'string_check', + * }, + * model_sample: 'model_sample', + * }); + * ``` + */ + run(body, options) { + return this._client.post("/fine_tuning/alpha/graders/run", resolveResourceRequestOptions$28(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Validate a grader. + * + * @example + * ```ts + * const response = + * await client.fineTuning.alpha.graders.validate({ + * grader: { + * input: 'input', + * name: 'name', + * operation: 'eq', + * reference: 'reference', + * type: 'string_check', + * }, + * }); + * ``` + */ + validate(body, options) { + return this._client.post("/fine_tuning/alpha/graders/validate", resolveResourceRequestOptions$28(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/fine-tuning/alpha/alpha.mjs +var Alpha = class extends APIResource { + constructor() { + super(...arguments); + this.graders = new Graders$1(this._client); + } +}; +Alpha.Graders = Graders$1; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/fine-tuning/checkpoints/permissions.mjs +function resolveResourceRequestOptions$27(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$10 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$10(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$10.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$10.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +/** +* Manage fine-tuning jobs to tailor a model to your specific training data. +*/ +var Permissions = class extends APIResource { + /** + * **NOTE:** Calling this endpoint requires an + * [admin API key](https://developers.openai.com/api/reference/resources/admin/subresources/organization/subresources/admin_api_keys). + * + * This enables organization owners to share fine-tuned models with other projects + * in their organization. + * + * @example + * ```ts + * // Automatically fetches more pages as needed. + * for await (const permissionCreateResponse of client.fineTuning.checkpoints.permissions.create( + * 'ft:gpt-4o-mini-2024-07-18:org:weather:B7R9VjQd', + * { project_ids: ['string'] }, + * )) { + * // ... + * } + * ``` + */ + create(fineTunedModelCheckpoint, body, options) { + return this._client.getAPIList(path`/fine_tuning/checkpoints/${fineTunedModelCheckpoint}/permissions`, Page, resolveResourceRequestOptions$27(options, (options) => ({ + body, + method: "post", + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + retrieve(fineTunedModelCheckpoint, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$10(query, [ + "after", + "limit", + "order", + "project_id" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.get(path`/fine_tuning/checkpoints/${fineTunedModelCheckpoint}/permissions`, resolveResourceRequestOptions$27(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + list(fineTunedModelCheckpoint, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$10(query, [ + "after", + "limit", + "order", + "project_id" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/fine_tuning/checkpoints/${fineTunedModelCheckpoint}/permissions`, ConversationCursorPage, resolveResourceRequestOptions$27(options, (options) => ({ + query, + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } + /** + * **NOTE:** This endpoint requires an + * [admin API key](https://developers.openai.com/api/reference/resources/admin/subresources/organization/subresources/admin_api_keys). + * + * Organization owners can use this endpoint to delete a permission for a + * fine-tuned model checkpoint. + * + * @example + * ```ts + * const permission = + * await client.fineTuning.checkpoints.permissions.delete( + * 'cp_zc4Q7MP6XxulcVzj4MZdwsAB', + * { + * fine_tuned_model_checkpoint: + * 'ft:gpt-4o-mini-2024-07-18:org:weather:B7R9VjQd', + * }, + * ); + * ``` + */ + delete(permissionID, params, options) { + const { fine_tuned_model_checkpoint } = params; + return this._client.delete(path`/fine_tuning/checkpoints/${fine_tuned_model_checkpoint}/permissions/${permissionID}`, resolveResourceRequestOptions$27(options, (options) => ({ + ...options, + __security: { adminAPIKeyAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/fine-tuning/checkpoints/checkpoints.mjs +var Checkpoints$1 = class extends APIResource { + constructor() { + super(...arguments); + this.permissions = new Permissions(this._client); + } +}; +Checkpoints$1.Permissions = Permissions; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/fine-tuning/jobs/checkpoints.mjs +function resolveResourceRequestOptions$26(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$9 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$9(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$9.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$9.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +/** +* Manage fine-tuning jobs to tailor a model to your specific training data. +*/ +var Checkpoints = class extends APIResource { + list(fineTuningJobID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$9(query, ["after", "limit"], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/fine_tuning/jobs/${fineTuningJobID}/checkpoints`, CursorPage, resolveResourceRequestOptions$26(options, (options) => ({ + query, + ...options, + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/fine-tuning/jobs/jobs.mjs +function resolveResourceRequestOptions$25(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$8 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$8(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$8.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$8.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +/** +* Manage fine-tuning jobs to tailor a model to your specific training data. +*/ +var Jobs = class extends APIResource { + constructor() { + super(...arguments); + this.checkpoints = new Checkpoints(this._client); + } + /** + * Creates a fine-tuning job which begins the process of creating a new model from + * a given dataset. + * + * Response includes details of the enqueued job including job status and the name + * of the fine-tuned models once complete. + * + * [Learn more about fine-tuning](https://developers.openai.com/api/docs/guides/model-optimization) + * + * @example + * ```ts + * const fineTuningJob = await client.fineTuning.jobs.create({ + * model: 'gpt-4o-mini', + * training_file: 'file-abc123', + * }); + * ``` + */ + create(body, options) { + return this._client.post("/fine_tuning/jobs", resolveResourceRequestOptions$25(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Get info about a fine-tuning job. + * + * [Learn more about fine-tuning](https://developers.openai.com/api/docs/guides/model-optimization) + * + * @example + * ```ts + * const fineTuningJob = await client.fineTuning.jobs.retrieve( + * 'ft-AF1WoRqd3aJAHsqc9NY7iL8F', + * ); + * ``` + */ + retrieve(fineTuningJobID, options) { + return this._client.get(path`/fine_tuning/jobs/${fineTuningJobID}`, resolveResourceRequestOptions$25(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$8(query, [ + "after", + "limit", + "metadata" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/fine_tuning/jobs", CursorPage, resolveResourceRequestOptions$25(options, (options) => ({ + query, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Immediately cancel a fine-tune job. + * + * @example + * ```ts + * const fineTuningJob = await client.fineTuning.jobs.cancel( + * 'ft-AF1WoRqd3aJAHsqc9NY7iL8F', + * ); + * ``` + */ + cancel(fineTuningJobID, options) { + return this._client.post(path`/fine_tuning/jobs/${fineTuningJobID}/cancel`, resolveResourceRequestOptions$25(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + listEvents(fineTuningJobID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$8(query, ["after", "limit"], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/fine_tuning/jobs/${fineTuningJobID}/events`, CursorPage, resolveResourceRequestOptions$25(options, (options) => ({ + query, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Pause a fine-tune job. + * + * @example + * ```ts + * const fineTuningJob = await client.fineTuning.jobs.pause( + * 'ft-AF1WoRqd3aJAHsqc9NY7iL8F', + * ); + * ``` + */ + pause(fineTuningJobID, options) { + return this._client.post(path`/fine_tuning/jobs/${fineTuningJobID}/pause`, resolveResourceRequestOptions$25(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Resume a fine-tune job. + * + * @example + * ```ts + * const fineTuningJob = await client.fineTuning.jobs.resume( + * 'ft-AF1WoRqd3aJAHsqc9NY7iL8F', + * ); + * ``` + */ + resume(fineTuningJobID, options) { + return this._client.post(path`/fine_tuning/jobs/${fineTuningJobID}/resume`, resolveResourceRequestOptions$25(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } +}; +Jobs.Checkpoints = Checkpoints; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/fine-tuning/fine-tuning.mjs +var FineTuning = class extends APIResource { + constructor() { + super(...arguments); + this.methods = new Methods(this._client); + this.jobs = new Jobs(this._client); + this.checkpoints = new Checkpoints$1(this._client); + this.alpha = new Alpha(this._client); + } +}; +FineTuning.Methods = Methods; +FineTuning.Jobs = Jobs; +FineTuning.Checkpoints = Checkpoints$1; +FineTuning.Alpha = Alpha; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/graders/grader-models.mjs +var GraderModels = class extends APIResource {}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/graders/graders.mjs +var Graders = class extends APIResource { + constructor() { + super(...arguments); + this.graderModels = new GraderModels(this._client); + } +}; +Graders.GraderModels = GraderModels; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/images.mjs +function resolveResourceRequestOptions$24(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +/** +* Given a prompt and/or an input image, the model will generate a new image. +*/ +var Images = class extends APIResource { + /** + * This endpoint is retired and no longer available. Use the image edits endpoint + * with a GPT Image model and a prompt to create a variation of an image. The + * request and response schemas below describe the legacy contract. + * + * @deprecated + */ + createVariation(body, options) { + return this._client.post("/images/variations", resolveResourceRequestOptions$24(options, (options) => multipartFormRequestOptions({ + body, + ...options, + __security: { bearerAuth: true } + }, this._client))); + } + edit(body, options) { + return this._client.post("/images/edits", resolveResourceRequestOptions$24(options, (options) => multipartFormRequestOptions({ + body, + ...options, + stream: body.stream ?? false, + __metadata: { + ...options?.__metadata, + ...body.model == null ? {} : { model: body.model } + }, + __security: { bearerAuth: true } + }, this._client))); + } + generate(body, options) { + return this._client.post("/images/generations", resolveResourceRequestOptions$24(options, (options) => ({ + body, + ...options, + stream: body.stream ?? false, + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/live/sessions.mjs +function resolveResourceRequestOptions$23(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var Sessions = class extends APIResource { + /** + * Accept an incoming SIP call. Supply session with type live, the model, and + * startup configuration. Before accepting calls, follow the + * [Live prompting guide](https://developers.openai.com/api/docs/guides/live-prompting) + * to write frontend conversation instructions and a separate backend prompt. SIP + * media format is negotiated; omit audio.format. + * + * @example + * ```ts + * await client.live.sessions.accept('session_id', { + * session: { model: 'gpt-live-1', type: 'live' }, + * }); + * ``` + */ + accept(sessionID, body, options) { + return this._client.post(path`/live/sessions/${sessionID}/accept`, resolveResourceRequestOptions$23(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ Accept: "*/*" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Get Live session content + * + * @example + * ```ts + * const response = + * await client.live.sessions.downloadRecording('live_SQ'); + * + * const content = await response.blob(); + * console.log(content); + * ``` + */ + downloadRecording(sessionID, options) { + return this._client.get(path`/live/sessions/${sessionID}/content`, resolveResourceRequestOptions$23(options, (options) => ({ + ...options, + headers: buildHeaders([{ Accept: "application/binary" }, options?.headers]), + __security: { bearerAuth: true }, + __binaryResponse: true + }))); + } + /** + * Fork a stored Live session onto a new WebRTC connection. + * + * @example + * ```ts + * const response = await client.live.sessions.fork( + * 'session_id', + * { transport: { sdp: 'x', type: 'webrtc' } }, + * ); + * ``` + */ + fork(sessionID, body, options) { + return this._client.post(path`/live/sessions/${sessionID}/fork`, resolveResourceRequestOptions$23(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * End a SIP call identified by session_id. + * + * @example + * ```ts + * await client.live.sessions.hangup('session_id'); + * ``` + */ + hangup(sessionID, options) { + return this._client.post(path`/live/sessions/${sessionID}/hangup`, resolveResourceRequestOptions$23(options, (options) => ({ + ...options, + headers: buildHeaders([{ Accept: "*/*" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Transfer a SIP call to another destination. Supply a nonblank target_uri for the + * SIP Refer-To header. + * + * @example + * ```ts + * await client.live.sessions.refer('session_id', { + * target_uri: 'tel:+14155550123', + * }); + * ``` + */ + refer(sessionID, body, options) { + return this._client.post(path`/live/sessions/${sessionID}/refer`, resolveResourceRequestOptions$23(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ Accept: "*/*" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Reject an incoming SIP call. Send a required SIP rejection status_code between + * 300 and 699. + * + * @example + * ```ts + * await client.live.sessions.reject('session_id', { + * status_code: 486, + * }); + * ``` + */ + reject(sessionID, body, options) { + return this._client.post(path`/live/sessions/${sessionID}/reject`, resolveResourceRequestOptions$23(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ Accept: "*/*" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/live/forks/forks.mjs +var Forks = class extends APIResource {}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/live/sideband/sideband.mjs +var Sideband = class extends APIResource {}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/live/live.mjs +function resolveResourceRequestOptions$22(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var Live = class extends APIResource { + constructor() { + super(...arguments); + this.sideband = new Sideband(this._client); + this.forks = new Forks(this._client); + this.sessions = new Sessions(this._client); + } + /** + * Create a Live WebRTC session. Start with the + * [Live prompting guide](https://developers.openai.com/api/docs/guides/live-prompting). + * + * @example + * ```ts + * const live = await client.live.create({ + * session: { model: 'gpt-live-1' }, + * transport: { sdp: 'x', type: 'webrtc' }, + * }); + * ``` + */ + create(body, options) { + return this._client.post("/live/sessions", resolveResourceRequestOptions$22(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } +}; +Live.Sideband = Sideband; +Live.Forks = Forks; +Live.Sessions = Sessions; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/models.mjs +function resolveResourceRequestOptions$21(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +/** +* List and describe the various models available in the API. +*/ +var Models = class extends APIResource { + /** + * Retrieves a model instance, providing basic information about the model such as + * the owner and permissioning. + */ + retrieve(model, options) { + return this._client.get(path`/models/${model}`, resolveResourceRequestOptions$21(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Lists the currently available models, and provides basic information about each + * one such as the owner and availability. + */ + list(options) { + return this._client.getAPIList("/models", Page, resolveResourceRequestOptions$21(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Delete a fine-tuned model. You must have the Owner role in your organization to + * delete a model. + */ + delete(model, options) { + return this._client.delete(path`/models/${model}`, resolveResourceRequestOptions$21(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/moderations.mjs +function resolveResourceRequestOptions$20(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +/** +* Given text and/or image inputs, classifies if those inputs are potentially harmful. +*/ +var Moderations = class extends APIResource { + /** + * Classifies if text and/or image inputs are potentially harmful. Learn more in + * the + * [moderation guide](https://developers.openai.com/api/docs/guides/moderation). + */ + create(body, options) { + return this._client.post("/moderations", resolveResourceRequestOptions$20(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/multipart-encoding.mjs +/** Encode explicitly typed fields as single, filename-less multipart parts. */ +async function encodedMultipartFormRequestOptions(options, client, encodings, rawBodyField = null) { + if (options.body === null || typeof options.body !== "object" || Array.isArray(options.body)) throw new TypeError("Multipart request body must be an object"); + const body = Object.fromEntries(Object.entries(options.body).filter(([, value]) => value !== void 0)); + if (rawBodyField !== null && Object.keys(body).length === 1 && Object.prototype.hasOwnProperty.call(body, rawBodyField)) { + const value = body[rawBodyField]; + if (typeof value !== "string") throw new TypeError("Raw multipart alternative must be a string"); + return { + ...options, + body: value, + headers: buildHeaders([options.headers, { "content-type": encodings[rawBodyField].content_type }]) + }; + } + const encoded = []; + for (const [name, encoding] of Object.entries(encodings)) { + if (!Object.prototype.hasOwnProperty.call(body, name)) continue; + const value = body[name]; + const data = encoding.json ? JSON.stringify(value) : value; + if (typeof data !== "string") throw new TypeError(`Multipart field ${name} must encode as a string`); + encoded.push([name, makeFile([data], "", { type: encoding.content_type })]); + delete body[name]; + } + const form = (await multipartFormRequestOptions({ + ...options, + body + }, client)).body; + if (!(form instanceof FormData)) { + await form.cancel(); + throw new TypeError("Unexpected streaming upload in typed multipart request body"); + } + for (const [name, part] of encoded) form.append(name, part, ""); + return { + ...options, + body: form, + headers: buildHeaders([options.headers, { "content-type": null }]) + }; +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/realtime/calls.mjs +function resolveResourceRequestOptions$19(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var Calls = class extends APIResource { + /** + * Create a new Realtime API call over WebRTC and receive the SDP answer needed to + * complete the peer connection. + * + * @example + * ```ts + * await client.realtime.calls.create({ + * sdp: 'sdp', + * }); + * ``` + */ + create(body, options) { + return this._client.post("/realtime/calls", resolveResourceRequestOptions$19(options, (options) => encodedMultipartFormRequestOptions({ + body, + ...options, + headers: buildHeaders([{ Accept: "application/sdp" }, options?.headers]), + __security: { bearerAuth: true }, + __binaryResponse: true + }, this._client, { + sdp: { + content_type: "application/sdp", + json: false + }, + session: { + content_type: "application/json", + json: true + } + }, "sdp"))); + } + /** + * Accept an incoming SIP call and configure the realtime session that will handle + * it. + * + * @example + * ```ts + * await client.realtime.calls.accept('call_id', { + * type: 'realtime', + * }); + * ``` + */ + accept(callID, body, options) { + return this._client.post(path`/realtime/calls/${callID}/accept`, resolveResourceRequestOptions$19(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ Accept: "*/*" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * End an active Realtime API call, whether it was initiated over SIP or WebRTC. + * + * @example + * ```ts + * await client.realtime.calls.hangup('call_id'); + * ``` + */ + hangup(callID, options) { + return this._client.post(path`/realtime/calls/${callID}/hangup`, resolveResourceRequestOptions$19(options, (options) => ({ + ...options, + headers: buildHeaders([{ Accept: "*/*" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Transfer an active SIP call to a new destination using the SIP REFER verb. + * + * @example + * ```ts + * await client.realtime.calls.refer('call_id', { + * target_uri: 'tel:+14155550123', + * }); + * ``` + */ + refer(callID, body, options) { + return this._client.post(path`/realtime/calls/${callID}/refer`, resolveResourceRequestOptions$19(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ Accept: "*/*" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Decline an incoming SIP call by returning a SIP status code to the caller. + * + * @example + * ```ts + * await client.realtime.calls.reject('call_id'); + * ``` + */ + reject(callID, body = {}, options) { + return this._client.post(path`/realtime/calls/${callID}/reject`, resolveResourceRequestOptions$19(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ Accept: "*/*" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/realtime/client-secrets.mjs +function resolveResourceRequestOptions$18(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var ClientSecrets$1 = class extends APIResource { + /** + * Create a Realtime client secret with an associated session configuration. + * + * Client secrets are short-lived tokens that can be passed to a client app, such + * as a web frontend or mobile client, which grants access to the Realtime API + * without leaking your main API key. You can configure a custom TTL for each + * client secret. + * + * You can also attach session configuration options to the client secret, which + * will be applied to any sessions created using that client secret, but these can + * also be overridden by the client connection. + * + * [Learn more about authentication with client secrets over WebRTC](https://developers.openai.com/api/docs/guides/realtime-webrtc). + * + * Returns the created client secret and the effective session object. The client + * secret is a string that looks like `ek_1234`. + * + * @example + * ```ts + * const clientSecret = + * await client.realtime.clientSecrets.create(); + * ``` + */ + create(body, options) { + return this._client.post("/realtime/client_secrets", resolveResourceRequestOptions$18(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/realtime/translations/client-secrets.mjs +function resolveResourceRequestOptions$17(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var ClientSecrets = class extends APIResource { + /** + * Create a Realtime translation client secret with an associated translation + * session configuration. + * + * Client secrets are short-lived tokens that can be passed to a client app, such + * as a web frontend or mobile client, which grants access to the Realtime + * Translation API without leaking your main API key. You can configure a custom + * TTL for each client secret. + * + * Returns the created client secret and the effective translation session object. + * The client secret is a string that looks like `ek_1234`. + * + * @example + * ```ts + * const realtimeTranslationClientSecretCreateResponse = + * await client.realtime.translations.clientSecrets.create( + * { session: { model: 'model' } }, + * ); + * ``` + */ + create(body, options) { + return this._client.post("/realtime/translations/client_secrets", resolveResourceRequestOptions$17(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/realtime/translations/translations.mjs +var Translations = class extends APIResource { + constructor() { + super(...arguments); + this.clientSecrets = new ClientSecrets(this._client); + } +}; +Translations.ClientSecrets = ClientSecrets; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/realtime/realtime.mjs +var Realtime = class extends APIResource { + constructor() { + super(...arguments); + this.clientSecrets = new ClientSecrets$1(this._client); + this.calls = new Calls(this._client); + this.translations = new Translations(this._client); + } +}; +Realtime.ClientSecrets = ClientSecrets$1; +Realtime.Calls = Calls; +Realtime.Translations = Translations; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/ResponsesParser.mjs +/** +* Adds parsed-output fields to a response, invoking parsers only when its request +* includes an auto-parseable text format or strict function tool. +*/ +function maybeParseResponse(response, params) { + if (!params || !hasAutoParseableInput(params)) { + const parsed = { + ...response, + output_parsed: null, + output: response.output.map((item) => { + if (item.type === "function_call") return { + ...item, + parsed_arguments: null + }; + if (item.type === "message") return { + ...item, + content: item.content.map((content) => ({ + ...content, + parsed: null + })) + }; + return item; + }) + }; + if (needsOutputText(response, parsed)) addOutputText(parsed); + return parsed; + } + return parseResponse(response, params); +} +/** +* Parses completed response text and strict function-tool arguments, matching +* namespaced functions by both namespace and name. +* +* Incomplete responses and messages with an explicit non-final phase stay unparsed. +* `output_parsed` returns the first successfully parsed output-text item. +*/ +function parseResponse(response, params) { + const shouldParse = !response.status || response.status === "completed"; + const output = response.output.map((item) => { + if (item.type === "function_call") return shouldParse ? parseToolCall(params, item) : { + ...item, + parsed_arguments: null + }; + if (item.type === "message") { + const content = item.content.map((content) => { + if (content.type === "output_text") return { + ...content, + parsed: shouldParse && (item.phase == null || item.phase === "final_answer") ? parseTextFormat(params, content.text) : null + }; + return content; + }); + return { + ...item, + content + }; + } + return item; + }); + const parsed = { + ...response, + output + }; + if (needsOutputText(response, parsed)) addOutputText(parsed); + Object.defineProperty(parsed, "output_parsed", { + enumerable: true, + get() { + for (const output of parsed.output) { + if (output.type !== "message") continue; + for (const content of output.content) if (content.type === "output_text" && content.parsed !== null) return content.parsed; + } + return null; + } + }); + return parsed; +} +function parseTextFormat(params, content) { + return parseResponseFormatContent(params.text?.format, content); +} +/** Returns whether the request includes an auto-parseable text format or strict function tool. */ +function hasAutoParseableInput(params) { + if (isParseableResponseFormat(params.text?.format)) return true; + return Array.isArray(params.tools) && params.tools.some((tool) => isAutoParsableTool(tool) || tool.type === "function" && tool.strict === true || tool.type === "namespace" && tool.tools.some((nested) => nested.type === "function" && (isAutoParsableTool(nested) || nested.strict === true))); +} +/** Returns whether a Responses API tool carries the SDK's argument-parser marker. */ +function isAutoParsableTool(tool) { + return tool?.["$brand"] === "auto-parseable-tool"; +} +function getInputToolByName(input_tools, name, namespace) { + for (const tool of input_tools) if (namespace == null) { + if (tool.type === "function" && tool.name === name) return tool; + } else if (tool.type === "namespace" && tool.name === namespace) return tool.tools.find((nested) => nested.type === "function" && nested.name === name); + if (namespace === name) return input_tools.find((tool) => tool.type === "function" && tool.name === name && tool.defer_loading === true); +} +function parseToolCall(params, toolCall) { + const inputTool = getInputToolByName(params.tools ?? [], toolCall.name, toolCall.namespace); + let parsedArguments = null; + if (isAutoParsableTool(inputTool)) parsedArguments = inputTool.$parseRaw(toolCall.arguments); + else if (inputTool?.strict) parsedArguments = parseResponseFormatContent({ + type: "json_schema", + $parseRaw: void 0 + }, toolCall.arguments); + return { + ...toolCall, + parsed_arguments: parsedArguments + }; +} +function needsOutputText(response, target) { + return !Object.getOwnPropertyDescriptor(response, "output_text") || target.output_text == null; +} +/** Replaces `output_text` with the concatenated text from every response output message. */ +function addOutputText(rsp) { + const texts = []; + for (const output of rsp.output) { + if (output.type !== "message") continue; + for (const content of output.content) if (content.type === "output_text") texts.push(content.text); + } + rsp.output_text = texts.join(""); +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/responses/output-text-index.mjs +/** +* Stores output text lengths in a complete binary segment tree. +* +* Leaves begin at `capacity`; each parent contains the sum of its children. +* Rebuilding when capacity doubles preserves every existing contribution and +* makes growth linear in the total number of appended outputs. +*/ +var OutputTextIndex = class { + constructor() { + this.capacity = 1; + this.values = [0, 0]; + this.size = 0; + } + get length() { + return this.size; + } + append(value) { + if (this.size === this.capacity) this.grow(); + const index = this.size; + this.size += 1; + this.update(index, value); + } + update(index, value) { + if (!Number.isSafeInteger(index) || index < 0 || index >= this.size) throw new RangeError(`missing output at index ${index}`); + let node = this.capacity + index; + const difference = value - (this.values[node] ?? 0); + if (difference === 0) return; + while (node >= 1) { + this.values[node] = (this.values[node] ?? 0) + difference; + node = Math.floor(node / 2); + } + } + prefixSum(end) { + if (!Number.isSafeInteger(end) || end < 0 || end > this.size) throw new RangeError(`missing output at index ${end}`); + let start = this.capacity; + let stop = this.capacity + end; + let sum = 0; + while (start < stop) { + if (start % 2 === 1) { + sum += this.values[start] ?? 0; + start += 1; + } + if (stop % 2 === 1) { + stop -= 1; + sum += this.values[stop] ?? 0; + } + start = Math.floor(start / 2); + stop = Math.floor(stop / 2); + } + return sum; + } + grow() { + const previousCapacity = this.capacity; + this.capacity *= 2; + const values = Array.from({ length: this.capacity * 2 }, () => 0); + for (let index = 0; index < this.size; index += 1) values[this.capacity + index] = this.values[previousCapacity + index] ?? 0; + for (let index = this.capacity - 1; index > 0; index -= 1) values[index] = (values[index * 2] ?? 0) + (values[index * 2 + 1] ?? 0); + this.values = values; + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/responses/canonical-output-text.mjs +function createCanonicalResponseContext() { + return { + canonicalSnapshot: void 0, + outputTextLengths: /* @__PURE__ */ new WeakMap(), + outputTextIndex: new OutputTextIndex() + }; +} +function getOutputText(context, output) { + if (output.type !== "message") return ""; + let text = ""; + for (const content of output.content) if (content.type === "output_text") text += content.text; + context.outputTextLengths.set(output, text.length); + return text; +} +function ensureCanonicalOutputText(context, snapshot) { + if (context.deferOutputText) { + context.canonicalSnapshot = void 0; + return; + } + if (context.canonicalSnapshot === snapshot) return; + const outputTextIndex = new OutputTextIndex(); + let text = ""; + for (const output of snapshot.output) { + const outputText = getOutputText(context, output); + text += outputText; + outputTextIndex.append(outputText.length); + } + snapshot.output_text = text; + context.outputTextIndex = outputTextIndex; + context.canonicalSnapshot = snapshot; +} +function cloneResponse(context, response) { + context.canonicalSnapshot = void 0; + context.outputTextLengths = /* @__PURE__ */ new WeakMap(); + context.outputTextIndex = new OutputTextIndex(); + const snapshot = structuredClone(response); + if (!Object.getOwnPropertyDescriptor(snapshot, "output_text") || snapshot.output_text === null || snapshot.output_text === void 0) ensureCanonicalOutputText(context, snapshot); + else if (snapshot.output.length === 0 && snapshot.output_text === "") context.canonicalSnapshot = snapshot; + return snapshot; +} +function updateCachedOutputTextLength(context, output, outputIndex, previousText, nextText) { + if (context.deferOutputText) return; + const length = context.outputTextLengths.get(output); + if (length !== void 0) { + const nextLength = length - previousText.length + nextText.length; + context.outputTextLengths.set(output, nextLength); + context.outputTextIndex.update(outputIndex, nextLength); + } +} +function replaceOutputTextSuffix(snapshot, previousText, nextText) { + if (previousText.length === 0) { + snapshot.output_text += nextText; + return; + } + snapshot.output_text = snapshot.output_text.slice(0, snapshot.output_text.length - previousText.length) + nextText; +} +function getPrecedingContentTextLength(context, output, contentIndex, nextText) { + if (contentIndex === void 0 || output?.type !== "message") return 0; + if (contentIndex < output.content.length - contentIndex - 1) { + let precedingContentLength = 0; + for (let index = 0; index < contentIndex; index += 1) { + const precedingContent = output.content[index]; + if (precedingContent?.type === "output_text") precedingContentLength += precedingContent.text.length; + } + return precedingContentLength; + } + let followingContentLength = 0; + for (let index = contentIndex + 1; index < output.content.length; index += 1) { + const followingContent = output.content[index]; + if (followingContent?.type === "output_text") followingContentLength += followingContent.text.length; + } + return (context.outputTextLengths.get(output) ?? getOutputText(context, output).length) - followingContentLength - nextText.length; +} +function updateOutputText(context, snapshot, outputIndex, previousText, nextText, contentIndex) { + if (previousText === nextText) return; + if (context.deferOutputText) { + context.outputTextDirty = true; + return; + } + const output = snapshot.output[outputIndex]; + if (outputIndex === snapshot.output.length - 1 && (contentIndex === void 0 || output?.type === "message" && contentIndex === output.content.length - 1)) { + replaceOutputTextSuffix(snapshot, previousText, nextText); + return; + } + const precedingContentLength = getPrecedingContentTextLength(context, output, contentIndex, nextText); + const offset = context.outputTextIndex.prefixSum(outputIndex) + precedingContentLength; + if (offset + previousText.length === snapshot.output_text.length) { + replaceOutputTextSuffix(snapshot, previousText, nextText); + return; + } + snapshot.output_text = snapshot.output_text.slice(0, offset) + nextText + snapshot.output_text.slice(offset + previousText.length); +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/responses/response-accumulator.mjs +const responseOutputIdentityIndexes = /* @__PURE__ */ new WeakMap(); +function validateArrayIndex(collection, index, kind, allowAppend = false) { + if (!Array.isArray(collection) || !Number.isSafeInteger(index) || index < 0 || index > collection.length || (index === collection.length ? !allowAppend || index in collection : !hasOwn(collection, index))) throw new OpenAIError(`missing ${kind} at index ${index}`); +} +function validateArrayAppend(collection, index, kind) { + if (index !== collection.length) throw new OpenAIError(`missing ${kind} at index ${index}`); + validateArrayIndex(collection, index, kind, true); +} +function getOutput(snapshot, outputIndex) { + validateArrayIndex(snapshot.output, outputIndex, "output"); + const output = snapshot.output[outputIndex]; + if (!output) throw new OpenAIError(`missing output at index ${outputIndex}`); + return output; +} +function hasRoutedOutputCallIdentity(output) { + return output.type === "function_call" || output.type === "custom_tool_call" || output.type === "shell_call" || output.type === "shell_call_output"; +} +function getOutputItemIdentityKeys(output, eventType) { + if (!hasOwn(output, "type") || typeof output.type !== "string") throw new OpenAIError(`expected an own output item type for ${eventType}`); + const optionalPlatformID = output.type === "function_call" || output.type === "custom_tool_call"; + const identities = []; + if (hasOwn(output, "id")) { + if (typeof output.id !== "string" || output.id.length === 0 && output.type !== "computer_call") throw new OpenAIError(`expected a non-empty output item id for ${eventType}`); + identities.push(`id:${output.id}`); + } else if (!optionalPlatformID) throw new OpenAIError(`expected a non-empty output item id for ${eventType}`); + if (hasRoutedOutputCallIdentity(output)) { + if (!hasOwn(output, "call_id") || typeof output.call_id !== "string" || output.call_id.length === 0 && output.type !== "function_call") throw new OpenAIError(`expected a non-empty output item call_id for ${eventType}`); + identities.push(`call:${output.type}:${output.call_id}`); + } + return identities; +} +function assertOutputItemIdentitiesAvailable(identities, keys) { + for (const key of keys) if (identities.has(key)) throw new OpenAIError(`duplicate output item identity '${key}'`); +} +function addOutputItemIdentities(identities, keys) { + assertOutputItemIdentitiesAvailable(identities, keys); + for (const key of keys) identities.add(key); +} +function createResponseOutputIdentityIndex(snapshot) { + const identityIndex = { + snapshot, + output: snapshot.output, + length: snapshot.output.length, + identities: /* @__PURE__ */ new Set() + }; + for (let index = 0; index < snapshot.output.length; index += 1) { + const output = getOutput(snapshot, index); + addOutputItemIdentities(identityIndex.identities, getOutputItemIdentityKeys(output, "response snapshot")); + } + return identityIndex; +} +function getResponseOutputIdentityIndex(context, snapshot) { + const cached = responseOutputIdentityIndexes.get(context); + if (cached && cached.snapshot === snapshot && cached.output === snapshot.output && cached.length === snapshot.output.length) return cached; + const identityIndex = createResponseOutputIdentityIndex(snapshot); + responseOutputIdentityIndexes.set(context, identityIndex); + return identityIndex; +} +function cloneValidatedResponse(context, response) { + const nextContext = createCanonicalResponseContext(); + const snapshot = cloneResponse(nextContext, response); + const identityIndex = createResponseOutputIdentityIndex(snapshot); + context.canonicalSnapshot = nextContext.canonicalSnapshot; + context.outputTextLengths = nextContext.outputTextLengths; + context.outputTextIndex = nextContext.outputTextIndex; + responseOutputIdentityIndexes.set(context, identityIndex); + return snapshot; +} +const expectedOutputItemTypes = { + "response.output_text.delta": "message", + "response.output_text.done": "message", + "response.output_text.annotation.added": "message", + "response.refusal.delta": "message", + "response.refusal.done": "message", + "response.function_call_arguments.delta": "function_call", + "response.function_call_arguments.done": "function_call", + "response.custom_tool_call_input.delta": "custom_tool_call", + "response.custom_tool_call_input.done": "custom_tool_call", + "response.mcp_call_arguments.delta": "mcp_call", + "response.mcp_call_arguments.done": "mcp_call", + "response.mcp_call.in_progress": "mcp_call", + "response.mcp_call.completed": "mcp_call", + "response.mcp_call.failed": "mcp_call", + "response.shell_call_output_content.delta": "shell_call_output", + "response.shell_call_output_content.done": "shell_call_output", + "response.reasoning_text.delta": "reasoning", + "response.reasoning_text.done": "reasoning", + "response.reasoning_summary_part.added": "reasoning", + "response.reasoning_summary_part.done": "reasoning", + "response.reasoning_summary_text.delta": "reasoning", + "response.reasoning_summary_text.done": "reasoning", + "response.code_interpreter_call_code.delta": "code_interpreter_call", + "response.code_interpreter_call_code.done": "code_interpreter_call", + "response.code_interpreter_call.in_progress": "code_interpreter_call", + "response.code_interpreter_call.interpreting": "code_interpreter_call", + "response.code_interpreter_call.completed": "code_interpreter_call", + "response.file_search_call.in_progress": "file_search_call", + "response.file_search_call.searching": "file_search_call", + "response.file_search_call.completed": "file_search_call", + "response.web_search_call.in_progress": "web_search_call", + "response.web_search_call.searching": "web_search_call", + "response.web_search_call.completed": "web_search_call", + "response.image_generation_call.in_progress": "image_generation_call", + "response.image_generation_call.generating": "image_generation_call", + "response.image_generation_call.completed": "image_generation_call", + "response.image_generation_call.partial_image": "image_generation_call", + "response.mcp_list_tools.in_progress": "mcp_list_tools", + "response.mcp_list_tools.completed": "mcp_list_tools", + "response.mcp_list_tools.failed": "mcp_list_tools", + "response.compaction.compacting": "compaction" +}; +function getExpectedOutputItemType(event) { + if (event.type === "response.content_part.added" || event.type === "response.content_part.done") return event.part.type === "reasoning_text" ? "reasoning" : "message"; + return expectedOutputItemTypes[event.type]; +} +function validateResponseOutputItemIdentity(output, replacement, eventType) { + getOutputItemIdentityKeys(output, eventType); + getOutputItemIdentityKeys(replacement, eventType); + if (!hasOwn(replacement, "type") || output.type !== replacement.type) throw new OpenAIError(`expected output item type '${output.type}', got '${replacement.type}'`); + const outputID = hasOwn(output, "id") ? output.id : void 0; + const replacementID = hasOwn(replacement, "id") ? replacement.id : void 0; + const addsOptionalID = outputID === void 0 && (output.type === "function_call" || output.type === "custom_tool_call"); + if (outputID !== replacementID && !addsOptionalID) throw new OpenAIError(`expected output item id '${outputID}', got '${replacementID}'`); + if (hasRoutedOutputCallIdentity(output) && hasRoutedOutputCallIdentity(replacement) && output.call_id !== replacement.call_id) throw new OpenAIError(`expected output item call_id '${output.call_id}', got '${replacement.call_id}'`); +} +function validateOutputItemIdentity(event, snapshot, rejectInvalidShellTargets) { + if (event.type === "response.output_item.done") return; + if (rejectInvalidShellTargets && (event.type === "response.shell_call_command.added" || event.type === "response.shell_call_command.delta" || event.type === "response.shell_call_command.done")) { + const output = getOutput(snapshot, event.output_index); + if (!hasOwn(output, "type") || output.type !== "shell_call") throw new OpenAIError(`expected output item type 'shell_call', got '${output.type}'`); + return; + } + if (event.type !== "response.content_part.added" && event.type !== "response.content_part.done" && !hasOwn(expectedOutputItemTypes, event.type)) return; + const itemEvent = event; + if (!hasOwn(event, "item_id") || typeof itemEvent.item_id !== "string" || itemEvent.item_id.length === 0) throw new OpenAIError(`expected a non-empty item_id for ${event.type}`); + const output = getOutput(snapshot, itemEvent.output_index); + const outputID = hasOwn(output, "id") ? output.id : void 0; + if (outputID !== itemEvent.item_id) throw new OpenAIError(`expected item_id '${outputID}', got '${itemEvent.item_id}'`); + const expectedType = getExpectedOutputItemType(itemEvent); + if (output.type !== expectedType) throw new OpenAIError(`expected output item type '${expectedType}', got '${output.type}'`); +} +function getContent(content, contentIndex) { + validateArrayIndex(content, contentIndex, "content"); + const part = content[contentIndex]; + if (!part) throw new OpenAIError(`missing content at index ${contentIndex}`); + return part; +} +function getShellOutputContent(snapshot, output, commandIndex) { + const shellCall = snapshot.output.find((item) => item.type === "shell_call" && item.call_id === output.call_id); + if (shellCall) validateArrayIndex(shellCall.action.commands, commandIndex, "command"); + else validateArrayIndex(output.output, commandIndex, "content", true); + while (output.output.length <= commandIndex) output.output.push({ + stdout: "", + stderr: "", + outcome: { + type: "exit", + exit_code: 0 + } + }); + return getContent(output.output, commandIndex); +} +function createSupportedResponseEventTypes(eventTypes) { + return new Set(eventTypes); +} +const supportedResponseEventTypes = createSupportedResponseEventTypes([ + "response.output_item.added", + "response.output_item.done", + "response.content_part.added", + "response.content_part.done", + "response.output_text.delta", + "response.output_text.done", + "response.output_text.annotation.added", + "response.refusal.delta", + "response.refusal.done", + "response.function_call_arguments.delta", + "response.function_call_arguments.done", + "response.custom_tool_call_input.delta", + "response.custom_tool_call_input.done", + "response.mcp_call_arguments.delta", + "response.mcp_call_arguments.done", + "response.shell_call_command.added", + "response.shell_call_command.done", + "response.shell_call_command.delta", + "response.shell_call_output_content.delta", + "response.shell_call_output_content.done", + "response.reasoning_text.delta", + "response.reasoning_text.done", + "response.reasoning_summary_part.added", + "response.reasoning_summary_part.done", + "response.reasoning_summary_text.delta", + "response.reasoning_summary_text.done", + "response.code_interpreter_call_code.delta", + "response.code_interpreter_call_code.done", + "response.code_interpreter_call.in_progress", + "response.code_interpreter_call.interpreting", + "response.code_interpreter_call.completed", + "response.file_search_call.in_progress", + "response.file_search_call.searching", + "response.file_search_call.completed", + "response.web_search_call.in_progress", + "response.web_search_call.searching", + "response.web_search_call.completed", + "response.image_generation_call.in_progress", + "response.image_generation_call.generating", + "response.image_generation_call.completed", + "response.mcp_call.in_progress", + "response.mcp_call.completed", + "response.mcp_call.failed", + "response.created", + "response.queued", + "response.in_progress", + "response.completed", + "response.failed", + "response.incomplete", + "response.audio.delta", + "response.audio.done", + "response.audio.transcript.delta", + "response.audio.transcript.done", + "response.compaction.compacting", + "response.image_generation_call.partial_image", + "response.mcp_list_tools.in_progress", + "response.mcp_list_tools.completed", + "response.mcp_list_tools.failed", + "keepalive", + "error" +]); +function assertNever(_value) { + throw new OpenAIError("Unhandled response stream event: unknown"); +} +const responseEventRoutingFields = [ + "item_id", + "output_index", + "content_index", + "annotation_index", + "command_index", + "summary_index" +]; +function sanitizeResponseEvent(event) { + let descriptor; + try { + descriptor = Object.getOwnPropertyDescriptor(event, "type"); + } catch { + return assertNever(event); + } + const type = descriptor?.value; + if (typeof type !== "string" || !supportedResponseEventTypes.has(type)) return assertNever(event); + const stableValues = /* @__PURE__ */ new Map([["type", type]]); + if (type === "response.output_item.added" || type === "response.output_item.done" || type === "response.content_part.added" || type === "response.content_part.done" || type === "response.shell_call_command.added" || type === "response.shell_call_command.delta" || type === "response.shell_call_command.done" || hasOwn(expectedOutputItemTypes, type)) try { + for (const field of responseEventRoutingFields) { + const routingDescriptor = Object.getOwnPropertyDescriptor(event, field); + stableValues.set(field, routingDescriptor ? event[field] : void 0); + } + if (type === "response.output_item.added" || type === "response.output_item.done") stableValues.set("item", structuredClone(event.item)); + else if (type === "response.content_part.added" || type === "response.content_part.done") stableValues.set("part", structuredClone(event.part)); + } catch { + return assertNever(event); + } + return new Proxy(event, { get(target, property) { + return stableValues.has(property) ? stableValues.get(property) : Reflect.get(target, property, target); + } }); +} +/** Replace one existing native item, preserving its routing identity and aggregate-text index. */ +function replaceResponseOutputItem(context, snapshot, outputIndex, replacement, updateText = true) { + const output = getOutput(snapshot, outputIndex); + validateResponseOutputItemIdentity(output, replacement, "response.output_item.done"); + if (!hasOwn(output, "id") && hasOwn(replacement, "id")) { + const { identities } = getResponseOutputIdentityIndex(context, snapshot); + addOutputItemIdentities(identities, [`id:${replacement.id}`]); + } + if (!updateText) { + snapshot.output[outputIndex] = replacement; + return; + } + const previousText = getOutputText(context, output); + if (output.type === "message" || replacement.type === "message") ensureCanonicalOutputText(context, snapshot); + snapshot.output[outputIndex] = replacement; + const nextText = getOutputText(context, replacement); + if (context.canonicalSnapshot === snapshot) context.outputTextIndex.update(outputIndex, nextText.length); + updateOutputText(context, snapshot, outputIndex, previousText, nextText); +} +function accumulateOutputItemEvent(event, snapshot, context) { + switch (event.type) { + case "response.output_item.added": { + validateArrayAppend(snapshot.output, event.output_index, "output"); + const identityIndex = getResponseOutputIdentityIndex(context, snapshot); + const output = event.item; + const identities = getOutputItemIdentityKeys(output, event.type); + assertOutputItemIdentitiesAvailable(identityIndex.identities, identities); + if (output.type === "message") ensureCanonicalOutputText(context, snapshot); + snapshot.output.push(output); + addOutputItemIdentities(identityIndex.identities, identities); + identityIndex.length = snapshot.output.length; + const text = getOutputText(context, output); + if (context.canonicalSnapshot === snapshot) context.outputTextIndex.append(text.length); + if (text) { + if (context.deferOutputText) context.outputTextDirty = true; + else snapshot.output_text += text; + } + return true; + } + case "response.output_item.done": + replaceResponseOutputItem(context, snapshot, event.output_index, event.item); + return true; + default: return false; + } +} +function accumulateContentPartAddedEvent(event, snapshot, context) { + switch (event.type) { + case "response.content_part.added": { + const output = getOutput(snapshot, event.output_index); + const { type } = output; + const { part } = event; + if (type === "message" && part.type !== "reasoning_text") { + validateArrayAppend(output.content, event.content_index, "content"); + const content = part; + if (content.type === "output_text") ensureCanonicalOutputText(context, snapshot); + output.content.push(content); + if (content.type === "output_text") { + updateCachedOutputTextLength(context, output, event.output_index, "", content.text); + updateOutputText(context, snapshot, event.output_index, "", content.text, event.content_index); + } + } else if (type === "reasoning" && part.type === "reasoning_text") { + const content = output.content ?? []; + validateArrayAppend(content, event.content_index, "content"); + if (!output.content) output.content = content; + content.push(part); + } + return true; + } + default: return false; + } +} +function accumulateContentPartDoneEvent(event, snapshot, context) { + switch (event.type) { + case "response.content_part.done": { + const output = getOutput(snapshot, event.output_index); + const { part } = event; + if (output.type === "message" && part.type !== "reasoning_text") { + const content = getContent(output.content, event.content_index); + const previousText = content.type === "output_text" ? content.text : ""; + const replacement = part; + if (content.type === "output_text" || replacement.type === "output_text") ensureCanonicalOutputText(context, snapshot); + output.content[event.content_index] = replacement; + const nextText = replacement.type === "output_text" ? replacement.text : ""; + updateCachedOutputTextLength(context, output, event.output_index, previousText, nextText); + updateOutputText(context, snapshot, event.output_index, previousText, nextText, event.content_index); + } else if (output.type === "reasoning" && part.type === "reasoning_text") { + const { content } = output; + if (!content) throw new OpenAIError(`missing content at index ${event.content_index}`); + getContent(content, event.content_index); + content[event.content_index] = part; + } + return true; + } + default: return false; + } +} +function isLogprobWithBytes(value) { + return isObj(value) && typeof value["token"] === "string" && typeof value["logprob"] === "number" && Array.isArray(value["bytes"]) && value["bytes"].every((byte) => typeof byte === "number"); +} +function isOutputLogprobs(value) { + return Array.isArray(value) && value.every((entry) => isLogprobWithBytes(entry) && "top_logprobs" in entry && Array.isArray(entry.top_logprobs) && entry.top_logprobs.every(isLogprobWithBytes)); +} +function accumulateOutputLogprobs(content, event) { + const logprobs = structuredClone(event.logprobs); + if (!isOutputLogprobs(logprobs)) return; + if (event.type === "response.output_text.done") { + if (logprobs.length > 0 || Array.isArray(content.logprobs) && content.logprobs.length > 0) content.logprobs = logprobs; + } else if (logprobs.length > 0) { + if (!Array.isArray(content.logprobs)) content.logprobs = []; + for (const logprob of logprobs) content.logprobs.push(logprob); + } +} +function accumulateOutputTextEvent(event, snapshot, context) { + switch (event.type) { + case "response.output_text.delta": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "message") { + const content = getContent(output.content, event.content_index); + if (content.type !== "output_text") throw new OpenAIError(`expected content to be 'output_text', got ${content.type}`); + accumulateOutputLogprobs(content, event); + const previousText = content.text; + ensureCanonicalOutputText(context, snapshot); + content.text = previousText + event.delta; + updateCachedOutputTextLength(context, output, event.output_index, previousText, content.text); + if (event.output_index === snapshot.output.length - 1 && event.content_index === output.content.length - 1) { + if (context.deferOutputText) { + if (event.delta !== "") context.outputTextDirty = true; + } else snapshot.output_text += event.delta; + } else updateOutputText(context, snapshot, event.output_index, previousText, content.text, event.content_index); + } + return true; + } + case "response.output_text.done": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "message") { + const content = getContent(output.content, event.content_index); + if (content.type !== "output_text") throw new OpenAIError(`expected content to be 'output_text', got ${content.type}`); + accumulateOutputLogprobs(content, event); + const previousText = content.text; + ensureCanonicalOutputText(context, snapshot); + content.text = event.text; + updateCachedOutputTextLength(context, output, event.output_index, previousText, event.text); + updateOutputText(context, snapshot, event.output_index, previousText, event.text, event.content_index); + } + return true; + } + case "response.output_text.annotation.added": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "message") { + const content = getContent(output.content, event.content_index); + if (content.type !== "output_text") throw new OpenAIError(`expected content to be 'output_text', got ${content.type}`); + validateArrayIndex(content.annotations, event.annotation_index, "annotation", true); + content.annotations[event.annotation_index] = structuredClone(event.annotation); + } + return true; + } + default: return false; + } +} +function accumulateRefusalAndArgumentsEvent(event, snapshot) { + switch (event.type) { + case "response.refusal.delta": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "message") { + const content = getContent(output.content, event.content_index); + if (content.type !== "refusal") throw new OpenAIError(`expected content to be 'refusal', got ${content.type}`); + content.refusal += event.delta; + } + return true; + } + case "response.refusal.done": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "message") { + const content = getContent(output.content, event.content_index); + if (content.type !== "refusal") throw new OpenAIError(`expected content to be 'refusal', got ${content.type}`); + content.refusal = event.refusal; + } + return true; + } + case "response.function_call_arguments.delta": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "function_call") output.arguments += event.delta; + return true; + } + case "response.function_call_arguments.done": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "function_call") output.arguments = event.arguments; + return true; + } + case "response.custom_tool_call_input.delta": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "custom_tool_call") output.input += event.delta; + return true; + } + case "response.custom_tool_call_input.done": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "custom_tool_call") output.input = event.input; + return true; + } + case "response.mcp_call_arguments.delta": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "mcp_call") output.arguments += event.delta; + return true; + } + case "response.mcp_call_arguments.done": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "mcp_call") output.arguments = event.arguments; + return true; + } + default: return false; + } +} +function accumulateShellEvent(event, snapshot) { + switch (event.type) { + case "response.shell_call_command.added": + case "response.shell_call_command.done": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "shell_call") { + const allowAppend = event.type === "response.shell_call_command.added"; + validateArrayIndex(output.action.commands, event.command_index, "command", allowAppend); + output.action.commands[event.command_index] = event.command; + } + return true; + } + case "response.shell_call_command.delta": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "shell_call") { + validateArrayIndex(output.action.commands, event.command_index, "command"); + output.action.commands[event.command_index] += event.delta; + } + return true; + } + case "response.shell_call_output_content.delta": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "shell_call_output") { + const content = getShellOutputContent(snapshot, output, event.command_index); + content.stdout += event.delta.stdout ?? ""; + content.stderr += event.delta.stderr ?? ""; + } + return true; + } + case "response.shell_call_output_content.done": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "shell_call_output") { + const content = getContent(event.output, 0); + getShellOutputContent(snapshot, output, event.command_index); + output.output[event.command_index] = structuredClone(content); + } + return true; + } + default: return false; + } +} +function accumulateReasoningEvent(event, snapshot) { + switch (event.type) { + case "response.reasoning_text.delta": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "reasoning") { + if (!output.content) throw new OpenAIError(`missing content at index ${event.content_index}`); + const content = getContent(output.content, event.content_index); + if (content.type !== "reasoning_text") throw new OpenAIError(`expected content to be 'reasoning_text', got ${content.type}`); + content.text += event.delta; + } + return true; + } + case "response.reasoning_text.done": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "reasoning") { + if (!output.content) throw new OpenAIError(`missing content at index ${event.content_index}`); + const content = getContent(output.content, event.content_index); + if (content.type !== "reasoning_text") throw new OpenAIError(`expected content to be 'reasoning_text', got ${content.type}`); + content.text = event.text; + } + return true; + } + case "response.reasoning_summary_part.added": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "reasoning") { + validateArrayAppend(output.summary, event.summary_index, "content"); + output.summary.push(structuredClone(event.part)); + } + return true; + } + case "response.reasoning_summary_part.done": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "reasoning") { + getContent(output.summary, event.summary_index); + output.summary[event.summary_index] = structuredClone(event.part); + } + return true; + } + case "response.reasoning_summary_text.delta": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "reasoning") { + const part = getContent(output.summary, event.summary_index); + part.text += event.delta; + } + return true; + } + case "response.reasoning_summary_text.done": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "reasoning") { + const part = getContent(output.summary, event.summary_index); + part.text = event.text; + } + return true; + } + default: return false; + } +} +function accumulateCodeInterpreterEvent(event, snapshot) { + switch (event.type) { + case "response.code_interpreter_call_code.delta": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "code_interpreter_call") output.code = (output.code ?? "") + event.delta; + return true; + } + case "response.code_interpreter_call_code.done": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "code_interpreter_call") output.code = event.code; + return true; + } + case "response.code_interpreter_call.in_progress": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "code_interpreter_call") output.status = "in_progress"; + return true; + } + case "response.code_interpreter_call.interpreting": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "code_interpreter_call") output.status = "interpreting"; + return true; + } + case "response.code_interpreter_call.completed": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "code_interpreter_call") output.status = "completed"; + return true; + } + default: return false; + } +} +function accumulateSearchStatusEvent(event, snapshot) { + switch (event.type) { + case "response.file_search_call.in_progress": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "file_search_call") output.status = "in_progress"; + return true; + } + case "response.file_search_call.searching": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "file_search_call") output.status = "searching"; + return true; + } + case "response.file_search_call.completed": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "file_search_call") output.status = "completed"; + return true; + } + case "response.web_search_call.in_progress": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "web_search_call") output.status = "in_progress"; + return true; + } + case "response.web_search_call.searching": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "web_search_call") output.status = "searching"; + return true; + } + case "response.web_search_call.completed": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "web_search_call") output.status = "completed"; + return true; + } + default: return false; + } +} +function accumulateImageAndMcpStatusEvent(event, snapshot) { + switch (event.type) { + case "response.image_generation_call.in_progress": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "image_generation_call") output.status = "in_progress"; + return true; + } + case "response.image_generation_call.generating": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "image_generation_call") output.status = "generating"; + return true; + } + case "response.image_generation_call.completed": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "image_generation_call") output.status = "completed"; + return true; + } + case "response.mcp_call.in_progress": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "mcp_call") output.status = "in_progress"; + return true; + } + case "response.mcp_call.completed": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "mcp_call") output.status = "completed"; + return true; + } + case "response.mcp_call.failed": { + const output = getOutput(snapshot, event.output_index); + if (output.type === "mcp_call") output.status = "failed"; + return true; + } + default: return false; + } +} +function isResponseLifecycleEvent(event) { + switch (event.type) { + case "response.created": + case "response.queued": + case "response.in_progress": + case "response.completed": + case "response.failed": + case "response.incomplete": return true; + default: return false; + } +} +function isIgnoredResponseEvent(event) { + switch (event.type) { + case "response.audio.delta": + case "response.audio.done": + case "response.audio.transcript.delta": + case "response.audio.transcript.done": + case "response.compaction.compacting": + case "response.image_generation_call.partial_image": + case "response.mcp_list_tools.in_progress": + case "response.mcp_list_tools.completed": + case "response.mcp_list_tools.failed": + case "keepalive": + case "error": return true; + default: return false; + } +} +function createResponseContext() { + return createCanonicalResponseContext(); +} +function accumulateResponseOutput(dispatchEvent, snapshot, context, rejectInvalidShellTargets) { + validateOutputItemIdentity(dispatchEvent, snapshot, rejectInvalidShellTargets); + if (accumulateOutputItemEvent(dispatchEvent, snapshot, context)) return true; + if (accumulateContentPartAddedEvent(dispatchEvent, snapshot, context)) return true; + if (accumulateContentPartDoneEvent(dispatchEvent, snapshot, context)) return true; + if (accumulateOutputTextEvent(dispatchEvent, snapshot, context)) return true; + if (accumulateRefusalAndArgumentsEvent(dispatchEvent, snapshot)) return true; + if (accumulateShellEvent(dispatchEvent, snapshot)) return true; + if (accumulateReasoningEvent(dispatchEvent, snapshot)) return true; + if (accumulateCodeInterpreterEvent(dispatchEvent, snapshot)) return true; + if (accumulateSearchStatusEvent(dispatchEvent, snapshot)) return true; + if (accumulateImageAndMcpStatusEvent(dispatchEvent, snapshot)) return true; + if (isIgnoredResponseEvent(dispatchEvent)) return true; + return false; +} +function accumulateResponseWithContext(event, snapshot, context, rejectInvalidShellTargets = false, prepareSanitizedEvent) { + let dispatchEvent = sanitizeResponseEvent(event); + if (prepareSanitizedEvent && dispatchEvent.type !== "keepalive") { + const prepared = prepareSanitizedEvent(dispatchEvent); + if (prepared === null) { + if (!snapshot) throw new OpenAIError("Cannot ignore a response event before response.created."); + return snapshot; + } + dispatchEvent = prepared; + } + if (!snapshot) { + if (dispatchEvent.type !== "response.created") throw new OpenAIError(`When snapshot hasn't been set yet, expected 'response.created' event, got ${dispatchEvent.type}`); + return cloneValidatedResponse(context, dispatchEvent.response); + } + if (accumulateResponseOutput(dispatchEvent, snapshot, context, rejectInvalidShellTargets)) return snapshot; + if (isResponseLifecycleEvent(dispatchEvent)) return cloneValidatedResponse(context, dispatchEvent.response); + return assertNever(dispatchEvent); +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/responses/ResponseStream.mjs +var _ResponseStream_instances; +var _ResponseStream_params; +var _ResponseStream_currentResponseSnapshot; +var _ResponseStream_finalResponse; +var _ResponseStream_accumulatorContext; +var _ResponseStream_outputPositions; +var _ResponseStream_wireByIdentity; +var _ResponseStream_interimOrderDirty; +var _ResponseStream_completedOutput; +var _ResponseStream_unfinishedOutput; +var _ResponseStream_beginRequest; +var _ResponseStream_prepareEvent; +var _ResponseStream_prepareOutputEvent; +var _ResponseStream_outputAtWireIndex; +var _ResponseStream_assertComplete; +var _ResponseStream_recordOutput; +var _ResponseStream_reorderInterimOutput; +var _ResponseStream_updateInterimResponse; +var _ResponseStream_addEvent; +var _ResponseStream_endRequest; +const nativeEventFields = { + annotation: true, + annotation_index: true, + arguments: true, + background: true, + code: true, + command: true, + command_index: true, + content_index: true, + delta: true, + input: true, + item: true, + item_id: true, + logprobs: true, + message: true, + obfuscation: true, + output: true, + output_format: true, + output_index: true, + param: true, + part: true, + partial_image_b64: true, + partial_image_index: true, + quality: true, + refusal: true, + response: true, + sequence_number: true, + size: true, + status: true, + summary_index: true, + text: true, + type: true +}; +/** Streams Responses API events while accumulating the latest response and parsed output. */ +var ResponseStream = class ResponseStream extends EventStream { + /** Creates an unstarted stream, retaining request parameters for structured-output parsing. */ + constructor(params) { + super(); + _ResponseStream_instances.add(this); + _ResponseStream_params.set(this, void 0); + _ResponseStream_currentResponseSnapshot.set(this, void 0); + _ResponseStream_finalResponse.set(this, void 0); + _ResponseStream_accumulatorContext.set(this, createResponseContext()); + _ResponseStream_outputPositions.set(this, /* @__PURE__ */ new Map()); + _ResponseStream_wireByIdentity.set(this, /* @__PURE__ */ new Map()); + _ResponseStream_interimOrderDirty.set(this, false); + _ResponseStream_completedOutput.set(this, /* @__PURE__ */ new Map()); + _ResponseStream_unfinishedOutput.set(this, /* @__PURE__ */ new Map()); + __classPrivateFieldSet(this, _ResponseStream_params, params, "f"); + this.once("end", () => { + __classPrivateFieldGet(this, _ResponseStream_outputPositions, "f").clear(); + __classPrivateFieldGet(this, _ResponseStream_wireByIdentity, "f").clear(); + __classPrivateFieldGet(this, _ResponseStream_completedOutput, "f").clear(); + __classPrivateFieldGet(this, _ResponseStream_unfinishedOutput, "f").clear(); + }); + } + /** Starts a new response stream or replays an existing response by its identifier. */ + static createResponse(client, params, options) { + const runner = new ResponseStream(params); + runner._run(() => runner._createOrRetrieveResponse(client, params, { + ...options, + __metadata: { + ...options?.__metadata, + helperMethod: "stream" + } + })); + return runner; + } + /** Consumes serialized response events from a readable stream in another runtime. */ + static fromReadableStream(stream) { + const runner = new ResponseStream(null); + runner._run(() => runner._fromReadableStream(stream)); + return runner; + } + async _createOrRetrieveResponse(client, params, options) { + this._listenForAbort(options?.signal); + __classPrivateFieldGet(this, _ResponseStream_instances, "m", _ResponseStream_beginRequest).call(this); + let stream; + let starting_after = null; + if ("response_id" in params) { + stream = await client.responses.retrieve(params.response_id, { stream: true }, { + ...options, + signal: this.controller.signal, + stream: true + }); + starting_after = params.starting_after ?? null; + } else stream = await client.responses.create({ + ...params, + stream: true + }, { + ...options, + signal: this.controller.signal + }); + this._connected(); + for await (const event of stream) __classPrivateFieldGet(this, _ResponseStream_instances, "m", _ResponseStream_addEvent).call(this, event, starting_after); + if (stream.controller.signal?.aborted) throw this._userAbortError(); + return __classPrivateFieldGet(this, _ResponseStream_instances, "m", _ResponseStream_endRequest).call(this); + } + async _fromReadableStream(readableStream, options) { + this._listenForAbort(options?.signal); + __classPrivateFieldGet(this, _ResponseStream_instances, "m", _ResponseStream_beginRequest).call(this); + this._connected(); + const stream = Stream.fromReadableStream(readableStream, this.controller); + for await (const event of stream) __classPrivateFieldGet(this, _ResponseStream_instances, "m", _ResponseStream_addEvent).call(this, event, null); + if (stream.controller.signal?.aborted) throw this._userAbortError(); + return __classPrivateFieldGet(this, _ResponseStream_instances, "m", _ResponseStream_endRequest).call(this); + } + /** Iterates over response events; stopping iteration early aborts the underlying request. */ + [(_ResponseStream_params = /* @__PURE__ */ new WeakMap(), _ResponseStream_currentResponseSnapshot = /* @__PURE__ */ new WeakMap(), _ResponseStream_finalResponse = /* @__PURE__ */ new WeakMap(), _ResponseStream_accumulatorContext = /* @__PURE__ */ new WeakMap(), _ResponseStream_outputPositions = /* @__PURE__ */ new WeakMap(), _ResponseStream_wireByIdentity = /* @__PURE__ */ new WeakMap(), _ResponseStream_interimOrderDirty = /* @__PURE__ */ new WeakMap(), _ResponseStream_completedOutput = /* @__PURE__ */ new WeakMap(), _ResponseStream_unfinishedOutput = /* @__PURE__ */ new WeakMap(), _ResponseStream_instances = /* @__PURE__ */ new WeakSet(), _ResponseStream_beginRequest = function _ResponseStream_beginRequest() { + if (this.ended) return; + __classPrivateFieldSet(this, _ResponseStream_currentResponseSnapshot, void 0, "f"); + __classPrivateFieldSet(this, _ResponseStream_accumulatorContext, createResponseContext(), "f"); + __classPrivateFieldGet(this, _ResponseStream_outputPositions, "f").clear(); + __classPrivateFieldGet(this, _ResponseStream_wireByIdentity, "f").clear(); + __classPrivateFieldSet(this, _ResponseStream_interimOrderDirty, false, "f"); + __classPrivateFieldGet(this, _ResponseStream_completedOutput, "f").clear(); + __classPrivateFieldGet(this, _ResponseStream_unfinishedOutput, "f").clear(); + }, _ResponseStream_prepareEvent = function _ResponseStream_prepareEvent(event) { + if (event.type === "response.created" || event.type === "response.queued" || event.type === "response.in_progress" || event.type === "response.completed" || event.type === "response.failed" || event.type === "response.incomplete") { + if (!hasOwn(event, "response")) throw new OpenAIError("Lifecycle events require their own response field."); + const { response: wireResponse, ...fields } = event; + if (!isObj(wireResponse)) throw new OpenAIError("Lifecycle events require a response object."); + let response = structuredClone(wireResponse); + if (__classPrivateFieldGet(this, _ResponseStream_currentResponseSnapshot, "f") && response.id !== __classPrivateFieldGet(this, _ResponseStream_currentResponseSnapshot, "f").id) throw new OpenAIError("Lifecycle response identity changed."); + if (!hasOwn(response, "output") || response.output == null) { + let output; + if (event.type === "response.completed") output = [...__classPrivateFieldGet(this, _ResponseStream_completedOutput, "f")].sort(([left], [right]) => left - right).map(([, item]) => structuredClone(item)); + else if (event.type === "response.failed" || event.type === "response.incomplete") output = [...__classPrivateFieldGet(this, _ResponseStream_outputPositions, "f").keys()].sort((left, right) => left - right).map((index) => structuredClone(__classPrivateFieldGet(this, _ResponseStream_instances, "m", _ResponseStream_outputAtWireIndex).call(this, index))); + else output = []; + response = { + ...response, + output + }; + if (event.type === "response.completed" || event.type === "response.failed" || event.type === "response.incomplete") addOutputText(response); + } + if (event.type === "response.completed") __classPrivateFieldGet(this, _ResponseStream_instances, "m", _ResponseStream_assertComplete).call(this, response); + return { + ...fields, + type: event.type, + sequence_number: event.sequence_number, + response + }; + } + return __classPrivateFieldGet(this, _ResponseStream_instances, "m", _ResponseStream_prepareOutputEvent).call(this, event); + }, _ResponseStream_prepareOutputEvent = function _ResponseStream_prepareOutputEvent(event) { + if (!__classPrivateFieldGet(this, _ResponseStream_currentResponseSnapshot, "f") || !hasOwn(event, "output_index") || !("output_index" in event)) return event; + const index = event.output_index; + if (!Number.isSafeInteger(index) || index < 0) throw new OpenAIError("Invalid response output index."); + let position; + if (event.type === "response.output_item.added") { + if (event.item == null) return null; + if (__classPrivateFieldGet(this, _ResponseStream_completedOutput, "f").has(index) || __classPrivateFieldGet(this, _ResponseStream_unfinishedOutput, "f").has(index)) throw new OpenAIError(`Duplicate response output index ${index}.`); + position = __classPrivateFieldGet(this, _ResponseStream_currentResponseSnapshot, "f").output.length; + } else { + const existing = __classPrivateFieldGet(this, _ResponseStream_outputPositions, "f").get(index); + if (existing === void 0) throw new OpenAIError(`missing output at index ${index}`); + position = existing; + } + return new Proxy(event, { get(target, property) { + return property === "output_index" ? position : Reflect.get(target, property, target); + } }); + }, _ResponseStream_outputAtWireIndex = function _ResponseStream_outputAtWireIndex(wireIndex) { + const position = __classPrivateFieldGet(this, _ResponseStream_outputPositions, "f").get(wireIndex); + return __classPrivateFieldGet(this, _ResponseStream_completedOutput, "f").get(wireIndex) ?? (position === void 0 ? void 0 : __classPrivateFieldGet(this, _ResponseStream_currentResponseSnapshot, "f")?.output[position]); + }, _ResponseStream_assertComplete = function _ResponseStream_assertComplete(response) { + if (__classPrivateFieldGet(this, _ResponseStream_unfinishedOutput, "f").size === 0 && __classPrivateFieldGet(this, _ResponseStream_completedOutput, "f").size === 0) return; + const finalItems = new Map((response.output ?? []).map((item) => [outputIdentity(item), item])); + for (const item of __classPrivateFieldGet(this, _ResponseStream_completedOutput, "f").values()) { + const replacement = finalItems.get(outputIdentity(item)); + if (replacement) validateResponseOutputItemIdentity(item, replacement, "response.completed"); + } + for (const [wireIndex, identity] of __classPrivateFieldGet(this, _ResponseStream_unfinishedOutput, "f")) { + const replacement = finalItems.get(identity); + if (!replacement) throw new OpenAIError("Cannot complete response with unfinished output items."); + const previous = __classPrivateFieldGet(this, _ResponseStream_instances, "m", _ResponseStream_outputAtWireIndex).call(this, wireIndex); + if (!previous) throw new OpenAIError("Cannot complete response with a missing output identity."); + validateResponseOutputItemIdentity(previous, replacement, "response.completed"); + } + }, _ResponseStream_recordOutput = function _ResponseStream_recordOutput(event, response, position) { + if (event.type === "response.completed") { + __classPrivateFieldSet(this, _ResponseStream_interimOrderDirty, false, "f"); + return; + } + if (response !== __classPrivateFieldGet(this, _ResponseStream_currentResponseSnapshot, "f")) { + const previous = /* @__PURE__ */ new Map(); + for (const [wireIndex, item] of __classPrivateFieldGet(this, _ResponseStream_completedOutput, "f")) previous.set(outputIdentity(item), wireIndex); + for (const [wireIndex, identity] of __classPrivateFieldGet(this, _ResponseStream_unfinishedOutput, "f")) previous.set(identity, wireIndex); + const positions = /* @__PURE__ */ new Map(); + __classPrivateFieldGet(this, _ResponseStream_wireByIdentity, "f").clear(); + for (const [newPosition, item] of response.output.entries()) { + const identity = outputIdentity(item); + const wireIndex = previous.get(identity) ?? newPosition; + const done = __classPrivateFieldGet(this, _ResponseStream_completedOutput, "f").get(wireIndex); + const unfinished = __classPrivateFieldGet(this, _ResponseStream_unfinishedOutput, "f").get(wireIndex); + if (positions.has(wireIndex) || done && outputIdentity(done) !== identity || unfinished !== void 0 && unfinished !== identity) throw new OpenAIError("Response snapshot has conflicting output positions."); + const previousItem = __classPrivateFieldGet(this, _ResponseStream_instances, "m", _ResponseStream_outputAtWireIndex).call(this, wireIndex); + if (previousItem) validateResponseOutputItemIdentity(previousItem, item, event.type); + positions.set(wireIndex, newPosition); + __classPrivateFieldGet(this, _ResponseStream_wireByIdentity, "f").set(identity, wireIndex); + if (done) __classPrivateFieldGet(this, _ResponseStream_completedOutput, "f").set(wireIndex, structuredClone(item)); + else __classPrivateFieldGet(this, _ResponseStream_unfinishedOutput, "f").set(wireIndex, identity); + } + __classPrivateFieldSet(this, _ResponseStream_outputPositions, positions, "f"); + __classPrivateFieldSet(this, _ResponseStream_interimOrderDirty, !["response.failed", "response.incomplete"].includes(event.type), "f"); + if ([ + "response.created", + "response.queued", + "response.in_progress" + ].includes(event.type)) __classPrivateFieldGet(this, _ResponseStream_instances, "m", _ResponseStream_reorderInterimOutput).call(this, response); + return; + } + if (position === void 0) return; + if (event.type === "response.output_item.added" && event.item != null) { + __classPrivateFieldGet(this, _ResponseStream_outputPositions, "f").set(event.output_index, position); + const identity = outputIdentity(event.item); + __classPrivateFieldGet(this, _ResponseStream_unfinishedOutput, "f").set(event.output_index, identity); + __classPrivateFieldGet(this, _ResponseStream_wireByIdentity, "f").set(identity, event.output_index); + __classPrivateFieldSet(this, _ResponseStream_interimOrderDirty, true, "f"); + } else if (event.type === "response.output_item.done") { + const item = response.output[position]; + if (!item) throw new OpenAIError(`missing output at index ${event.output_index}`); + __classPrivateFieldGet(this, _ResponseStream_completedOutput, "f").set(event.output_index, structuredClone(item)); + __classPrivateFieldGet(this, _ResponseStream_unfinishedOutput, "f").delete(event.output_index); + } + }, _ResponseStream_reorderInterimOutput = function _ResponseStream_reorderInterimOutput(response) { + if (!__classPrivateFieldGet(this, _ResponseStream_interimOrderDirty, "f")) return; + const ordered = [...__classPrivateFieldGet(this, _ResponseStream_outputPositions, "f")]; + ordered.sort(([left], [right]) => left - right); + if (ordered.some(([, oldPosition], newPosition) => oldPosition !== newPosition)) { + const derivedText = __classPrivateFieldGet(this, _ResponseStream_accumulatorContext, "f").canonicalSnapshot === response; + response.output = ordered.map(([, oldPosition]) => response.output[oldPosition]); + __classPrivateFieldSet(this, _ResponseStream_outputPositions, new Map(ordered.map(([wireIndex], newPosition) => [wireIndex, newPosition])), "f"); + __classPrivateFieldSet(this, _ResponseStream_accumulatorContext, createResponseContext(), "f"); + if (derivedText) ensureCanonicalOutputText(__classPrivateFieldGet(this, _ResponseStream_accumulatorContext, "f"), response); + } + __classPrivateFieldSet(this, _ResponseStream_interimOrderDirty, false, "f"); + }, _ResponseStream_updateInterimResponse = function _ResponseStream_updateInterimResponse(incoming, snapshot) { + if (!Array.isArray(incoming.output)) return false; + const suppliedText = hasOwn(incoming, "output_text") ? incoming.output_text : void 0; + if (incoming.output.length !== 0) { + const validated = cloneValidatedResponse(createResponseContext(), incoming); + const replacements = []; + for (const item of validated.output) { + const wire = __classPrivateFieldGet(this, _ResponseStream_wireByIdentity, "f").get(outputIdentity(item)); + const position = wire === void 0 ? void 0 : __classPrivateFieldGet(this, _ResponseStream_outputPositions, "f").get(wire); + if (wire === void 0 || position === void 0) return false; + replacements.push({ + wire, + position, + item + }); + } + const updateText = suppliedText == null; + if (!updateText) __classPrivateFieldGet(this, _ResponseStream_accumulatorContext, "f").canonicalSnapshot = void 0; + for (const { wire, position, item } of replacements) { + replaceResponseOutputItem(__classPrivateFieldGet(this, _ResponseStream_accumulatorContext, "f"), snapshot, position, item, updateText); + if (__classPrivateFieldGet(this, _ResponseStream_completedOutput, "f").has(wire)) __classPrivateFieldGet(this, _ResponseStream_completedOutput, "f").set(wire, structuredClone(item)); + } + __classPrivateFieldGet(this, _ResponseStream_instances, "m", _ResponseStream_reorderInterimOutput).call(this, snapshot); + } + const { output } = snapshot; + let outputText = suppliedText; + if (outputText == null) { + ensureCanonicalOutputText(__classPrivateFieldGet(this, _ResponseStream_accumulatorContext, "f"), snapshot); + outputText = snapshot.output_text; + } else __classPrivateFieldGet(this, _ResponseStream_accumulatorContext, "f").canonicalSnapshot = void 0; + for (const key of Object.keys(snapshot)) if (!hasOwn(incoming, key)) Reflect.deleteProperty(snapshot, key); + Object.defineProperties(snapshot, Object.getOwnPropertyDescriptors({ + ...incoming, + output, + output_text: outputText + })); + return true; + }, _ResponseStream_addEvent = function _ResponseStream_addEvent(event, starting_after) { + if (this.ended) return; + const maybeEmit = (name, event) => { + if (starting_after == null || event.sequence_number > starting_after) this._emit(name, event); + }; + if (event.type === "error") throw new APIError(void 0, "error" in event && typeof event.error === "object" && event.error !== null ? event.error : event, event.message, void 0); + let dispatchEvent = event; + let outputPosition; + const response = accumulateResponseWithContext(event, __classPrivateFieldGet(this, _ResponseStream_currentResponseSnapshot, "f"), __classPrivateFieldGet(this, _ResponseStream_accumulatorContext, "f"), true, (sanitizedEvent) => { + dispatchEvent = sanitizedEvent; + const prepared = __classPrivateFieldGet(this, _ResponseStream_instances, "m", _ResponseStream_prepareEvent).call(this, sanitizedEvent); + if (prepared) { + if (hasOwn(prepared, "output_index") && "output_index" in prepared) outputPosition = prepared.output_index; + else if (hasOwn(prepared, "response") && "response" in prepared) { + dispatchEvent = prepared; + if ((prepared.type === "response.created" || prepared.type === "response.queued" || prepared.type === "response.in_progress") && __classPrivateFieldGet(this, _ResponseStream_currentResponseSnapshot, "f")) { + if (__classPrivateFieldGet(this, _ResponseStream_instances, "m", _ResponseStream_updateInterimResponse).call(this, prepared.response, __classPrivateFieldGet(this, _ResponseStream_currentResponseSnapshot, "f"))) return null; + const identities = new Set(prepared.response.output.map(outputIdentity)); + const retained = __classPrivateFieldGet(this, _ResponseStream_currentResponseSnapshot, "f").output.filter((item) => !identities.has(outputIdentity(item))); + if (retained.length) return { + ...prepared, + response: { + ...prepared.response, + output: [...prepared.response.output, ...retained] + } + }; + } + } + } + return prepared; + }); + __classPrivateFieldGet(this, _ResponseStream_instances, "m", _ResponseStream_recordOutput).call(this, dispatchEvent, response, outputPosition); + __classPrivateFieldSet(this, _ResponseStream_currentResponseSnapshot, response, "f"); + if (dispatchEvent.type === "response.output_item.added" && dispatchEvent.item == null) return; + const wireSnapshot = { ...dispatchEvent }; + for (const key of Object.keys(nativeEventFields)) { + const descriptor = Object.getOwnPropertyDescriptor(dispatchEvent, key); + if (descriptor && !descriptor.enumerable) Object.defineProperty(wireSnapshot, key, { + value: Reflect.get(dispatchEvent, key, dispatchEvent), + enumerable: true + }); + } + const eventSnapshot = structuredClone(wireSnapshot); + maybeEmit("event", eventSnapshot); + switch (wireSnapshot.type) { + case "response.output_text.delta": { + const output = response.output[outputPosition ?? wireSnapshot.output_index]; + if (!output) throw new OpenAIError(`missing output at index ${wireSnapshot.output_index}`); + if (output.type === "message") { + const content = output.content[wireSnapshot.content_index]; + if (!content) throw new OpenAIError(`missing content at index ${wireSnapshot.content_index}`); + if (content.type !== "output_text") throw new OpenAIError(`expected content to be 'output_text', got ${content.type}`); + maybeEmit("response.output_text.delta", { + ...structuredClone(wireSnapshot), + snapshot: content.text + }); + } + break; + } + case "response.function_call_arguments.delta": { + const output = response.output[outputPosition ?? wireSnapshot.output_index]; + if (!output) throw new OpenAIError(`missing output at index ${wireSnapshot.output_index}`); + if (output.type === "function_call") maybeEmit("response.function_call_arguments.delta", { + ...structuredClone(wireSnapshot), + snapshot: output.arguments + }); + break; + } + default: maybeEmit(wireSnapshot.type, eventSnapshot); + } + }, _ResponseStream_endRequest = function _ResponseStream_endRequest() { + if (this.ended) throw new OpenAIError(`stream has ended, this shouldn't happen`); + const snapshot = __classPrivateFieldGet(this, _ResponseStream_currentResponseSnapshot, "f"); + if (!snapshot) throw new OpenAIError(`request ended without sending any events`); + __classPrivateFieldGet(this, _ResponseStream_instances, "m", _ResponseStream_reorderInterimOutput).call(this, snapshot); + __classPrivateFieldSet(this, _ResponseStream_currentResponseSnapshot, void 0, "f"); + __classPrivateFieldSet(this, _ResponseStream_accumulatorContext, createResponseContext(), "f"); + __classPrivateFieldGet(this, _ResponseStream_outputPositions, "f").clear(); + __classPrivateFieldGet(this, _ResponseStream_wireByIdentity, "f").clear(); + __classPrivateFieldSet(this, _ResponseStream_interimOrderDirty, false, "f"); + __classPrivateFieldGet(this, _ResponseStream_completedOutput, "f").clear(); + __classPrivateFieldGet(this, _ResponseStream_unfinishedOutput, "f").clear(); + const parsedResponse = finalizeResponse(snapshot, __classPrivateFieldGet(this, _ResponseStream_params, "f")); + __classPrivateFieldSet(this, _ResponseStream_finalResponse, parsedResponse, "f"); + return parsedResponse; + }, Symbol.asyncIterator)]() { + return this._createIterator((push) => { + const onEvent = (event) => push(event); + this.on("event", onEvent); + return () => this.off("event", onEvent); + }, { onReturn: () => this.abort() }); + } + /** + * Waits for the stream to end and returns its latest accumulated response. + * + * A clean end after at least one response event resolves even when the response is + * incomplete. Network errors, cancellation, and streams without a response reject. + */ + async finalResponse() { + await this.done(); + const response = __classPrivateFieldGet(this, _ResponseStream_finalResponse, "f"); + if (!response) throw new OpenAIError("stream ended without producing a Response"); + return response; + } +}; +function outputIdentity(item) { + return JSON.stringify([ + item.type, + !hasRoutedOutputCallIdentity(item) && hasOwn(item, "id") ? item.id : null, + hasOwn(item, "call_id") && "call_id" in item ? item.call_id : null + ]); +} +function finalizeResponse(snapshot, params) { + return maybeParseResponse(snapshot, params); +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/responses/input-items.mjs +function resolveResourceRequestOptions$16(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$7 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$7(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$7.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$7.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +/** +* Create and manage model responses. +*/ +var InputItems = class extends APIResource { + list(responseID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$7(query, [ + "after", + "include", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/responses/${responseID}/input_items`, CursorPage, resolveResourceRequestOptions$16(options, (options) => ({ + query, + ...options, + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/responses/input-tokens.mjs +function resolveResourceRequestOptions$15(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +/** +* Create and manage model responses. +*/ +var InputTokens = class extends APIResource { + /** + * Returns input token counts of the request. + * + * Returns an object with `object` set to `response.input_tokens` and an + * `input_tokens` count. + * + * @example + * ```ts + * const response = await client.responses.inputTokens.count(); + * ``` + */ + count(body = {}, options) { + return this._client.post("/responses/input_tokens", resolveResourceRequestOptions$15(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/responses/responses.mjs +function resolveResourceRequestOptions$14(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$6 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$6(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$6.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$6.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +/** +* Create and manage model responses. +*/ +var Responses = class extends APIResource { + constructor() { + super(...arguments); + this.inputItems = new InputItems(this._client); + this.inputTokens = new InputTokens(this._client); + } + create(body, options) { + return this._client.post("/responses", resolveResourceRequestOptions$14(options, (options) => ({ + body, + ...options, + stream: body.stream ?? false, + __security: { bearerAuth: true } + })))._thenUnwrap((rsp) => { + if ("object" in rsp && rsp.object === "response") addOutputText(rsp); + return rsp; + }); + } + retrieve(responseID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$6(query, [ + "include", + "include_obfuscation", + "starting_after", + "stream" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.get(path`/responses/${responseID}`, resolveResourceRequestOptions$14(options, (options) => ({ + query, + ...options, + stream: query?.stream ?? false, + __security: { bearerAuth: true } + })))._thenUnwrap((rsp) => { + if ("object" in rsp && rsp.object === "response") addOutputText(rsp); + return rsp; + }); + } + /** + * Deletes a model response with the given ID. + * + * @example + * ```ts + * await client.responses.delete( + * 'resp_677efb5139a88190b512bc3fef8e535d', + * ); + * ``` + */ + delete(responseID, options) { + return this._client.delete(path`/responses/${responseID}`, resolveResourceRequestOptions$14(options, (options) => ({ + ...options, + headers: buildHeaders([{ Accept: "*/*" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + parse(body, options) { + return this._client.responses.create(body, options)._thenUnwrap((response) => parseResponse(response, body)); + } + /** + * Creates a model response stream + */ + stream(body, options) { + return ResponseStream.createResponse(this._client, body, options); + } + /** + * Cancels a model response with the given ID. Only responses created with the + * `background` parameter set to `true` can be cancelled. + * [Learn more](https://developers.openai.com/api/docs/guides/background). + * + * @example + * ```ts + * const response = await client.responses.cancel( + * 'resp_677efb5139a88190b512bc3fef8e535d', + * ); + * ``` + */ + cancel(responseID, options) { + return this._client.post(path`/responses/${responseID}/cancel`, resolveResourceRequestOptions$14(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Compact a conversation. Returns a compacted response object. + * + * Learn when and how to compact long-running conversations in the + * [conversation state guide](https://developers.openai.com/api/docs/guides/conversation-state#managing-the-context-window). + * For ZDR-compatible compaction details, see + * [Compaction (advanced)](https://developers.openai.com/api/docs/guides/conversation-state#compaction-advanced). + * + * @example + * ```ts + * const compactedResponse = await client.responses.compact({ + * model: 'gpt-6-astra', + * }); + * ``` + */ + compact(body, options) { + return this._client.post("/responses/compact", resolveResourceRequestOptions$14(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } +}; +Responses.InputItems = InputItems; +Responses.InputTokens = InputTokens; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/safety/alerts.mjs +function resolveResourceRequestOptions$13(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var Alerts = class extends APIResource { + /** + * Get a safety alert belonging to the authenticated API project. + */ + retrieve(id, options) { + return this._client.get(path`/safety/alerts/${id}`, resolveResourceRequestOptions$13(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/safety/cases.mjs +function resolveResourceRequestOptions$12(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var Cases = class extends APIResource { + /** + * Get a safety case by ID. + */ + retrieve(id, options) { + return this._client.get(path`/safety/cases/${id}`, resolveResourceRequestOptions$12(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/safety/safety.mjs +var Safety = class extends APIResource { + constructor() { + super(...arguments); + this.cases = new Cases(this._client); + this.alerts = new Alerts(this._client); + } +}; +Safety.Cases = Cases; +Safety.Alerts = Alerts; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/skills/content.mjs +function resolveResourceRequestOptions$11(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var Content$1 = class extends APIResource { + /** + * Download a skill zip bundle by its ID. + */ + retrieve(skillID, options) { + return this._client.get(path`/skills/${skillID}/content`, resolveResourceRequestOptions$11(options, (options) => ({ + ...options, + headers: buildHeaders([{ Accept: "application/binary" }, options?.headers]), + __security: { bearerAuth: true }, + __binaryResponse: true + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/skills/versions/content.mjs +function resolveResourceRequestOptions$10(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var Content = class extends APIResource { + /** + * Download a skill version zip bundle. + */ + retrieve(version, params, options) { + const { skill_id } = params; + return this._client.get(path`/skills/${skill_id}/versions/${version}/content`, resolveResourceRequestOptions$10(options, (options) => ({ + ...options, + headers: buildHeaders([{ Accept: "application/binary" }, options?.headers]), + __security: { bearerAuth: true }, + __binaryResponse: true + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/skills/versions/versions.mjs +function resolveResourceRequestOptions$9(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$5 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$5(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$5.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$5.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Versions = class extends APIResource { + constructor() { + super(...arguments); + this.content = new Content(this._client); + } + /** + * Create a new immutable skill version. + */ + create(skillID, body = {}, options) { + return this._client.post(path`/skills/${skillID}/versions`, maybeMultipartFormRequestOptions({ + body, + ...options, + __security: { bearerAuth: true } + }, this._client, { stripFilenames: false })); + } + /** + * Get a specific skill version. + */ + retrieve(version, params, options) { + const { skill_id } = params; + return this._client.get(path`/skills/${skill_id}/versions/${version}`, resolveResourceRequestOptions$9(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + list(skillID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$5(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/skills/${skillID}/versions`, CursorPage, resolveResourceRequestOptions$9(options, (options) => ({ + query, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Delete a skill version. + */ + delete(version, params, options) { + const { skill_id } = params; + return this._client.delete(path`/skills/${skill_id}/versions/${version}`, resolveResourceRequestOptions$9(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } +}; +Versions.Content = Content; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/skills/skills.mjs +function resolveResourceRequestOptions$8(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$4 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$4(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$4.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$4.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Skills = class extends APIResource { + constructor() { + super(...arguments); + this.content = new Content$1(this._client); + this.versions = new Versions(this._client); + } + /** + * Create a new skill. + */ + create(body = {}, options) { + return this._client.post("/skills", maybeMultipartFormRequestOptions({ + body, + ...options, + __security: { bearerAuth: true } + }, this._client, { stripFilenames: false })); + } + /** + * Get a skill by its ID. + */ + retrieve(skillID, options) { + return this._client.get(path`/skills/${skillID}`, resolveResourceRequestOptions$8(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Update the default version pointer for a skill. + */ + update(skillID, body, options) { + return this._client.post(path`/skills/${skillID}`, resolveResourceRequestOptions$8(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$4(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/skills", CursorPage, resolveResourceRequestOptions$8(options, (options) => ({ + query, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Delete a skill by its ID. + */ + delete(skillID, options) { + return this._client.delete(path`/skills/${skillID}`, resolveResourceRequestOptions$8(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } +}; +Skills.Content = Content$1; +Skills.Versions = Versions; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/uploads/parts.mjs +function resolveResourceRequestOptions$7(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +/** +* Use Uploads to upload large files in multiple parts. +*/ +var Parts = class extends APIResource { + /** + * Adds a + * [Part](https://developers.openai.com/api/reference/resources/uploads/subresources/parts) + * to an [Upload](https://developers.openai.com/api/reference/resources/uploads) + * object. A Part represents a chunk of bytes from the file you are trying to + * upload. + * + * Each Part can be at most 64 MB, and you can add Parts until you hit the Upload + * maximum of 8 GB. + * + * It is possible to add multiple Parts in parallel. You can decide the intended + * order of the Parts when you + * [complete the Upload](https://developers.openai.com/api/reference/resources/uploads/methods/complete). + */ + create(uploadID, body, options) { + return this._client.post(path`/uploads/${uploadID}/parts`, resolveResourceRequestOptions$7(options, (options) => multipartFormRequestOptions({ + body, + ...options, + __security: { bearerAuth: true } + }, this._client))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/uploads/uploads.mjs +function resolveResourceRequestOptions$6(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +/** +* Use Uploads to upload large files in multiple parts. +*/ +var Uploads = class extends APIResource { + constructor() { + super(...arguments); + this.parts = new Parts(this._client); + } + /** + * Creates an intermediate + * [Upload](https://developers.openai.com/api/reference/resources/uploads) object + * that you can add + * [Parts](https://developers.openai.com/api/reference/resources/uploads/subresources/parts) + * to. Currently, an Upload can accept at most 8 GB in total and expires after an + * hour after you create it. + * + * Once you complete the Upload, we will create a + * [File](https://developers.openai.com/api/reference/resources/files) object that + * contains all the parts you uploaded. This File is usable in the rest of our + * platform as a regular File object. + * + * For certain `purpose` values, the correct `mime_type` must be specified. Please + * refer to documentation for the + * [supported MIME types for your use case](https://developers.openai.com/api/docs/guides/tools-file-search#supported-files). + * + * For guidance on the proper filename extensions for each purpose, please follow + * the documentation on + * [creating a File](https://developers.openai.com/api/reference/resources/files/methods/create). + * + * Returns the Upload object with status `pending`. + */ + create(body, options) { + return this._client.post("/uploads", resolveResourceRequestOptions$6(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Cancels the Upload. No Parts may be added after an Upload is cancelled. + * + * Returns the Upload object with status `cancelled`. + */ + cancel(uploadID, options) { + return this._client.post(path`/uploads/${uploadID}/cancel`, resolveResourceRequestOptions$6(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Completes the + * [Upload](https://developers.openai.com/api/reference/resources/uploads). + * + * Within the returned Upload object, there is a nested + * [File](https://developers.openai.com/api/reference/resources/files) object that + * is ready to use in the rest of the platform. + * + * You can specify the order of the Parts by passing in an ordered list of the Part + * IDs. + * + * The number of bytes uploaded upon completion must match the number of bytes + * initially specified when creating the Upload object. No Parts may be added after + * an Upload is completed. Returns the Upload object with status `completed`, + * including an additional `file` property containing the created usable File + * object. + */ + complete(uploadID, body, options) { + return this._client.post(path`/uploads/${uploadID}/complete`, resolveResourceRequestOptions$6(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } +}; +Uploads.Parts = Parts; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/vector-store-polling.mjs +/** +* Polls an attached file through the resource's retrieve method until it completes, +* fails, or is cancelled. Retrieval errors are propagated unchanged. +* +* @internal +*/ +function pollVectorStoreFile(resource, vectorStoreID, fileID, options) { + return pollWithResponse((headers) => resource.retrieve(fileID, { vector_store_id: vectorStoreID }, { + ...options, + headers + }), ["in_progress"], [ + "failed", + "cancelled", + "completed" + ], options); +} +/** +* Polls a file batch through the resource's retrieve method until it completes, +* fails, or is cancelled. Retrieval errors are propagated unchanged. +* +* @internal +*/ +function pollVectorStoreFileBatch(resource, vectorStoreID, batchID, options) { + return pollWithResponse((headers) => resource.retrieve(batchID, { vector_store_id: vectorStoreID }, { + ...options, + headers + }), ["in_progress"], [ + "failed", + "cancelled", + "completed" + ], options); +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/Util.mjs +/** +* Like `Promise.allSettled()` but throws an error if any promises are rejected. +* Rejection reasons remain available on the thrown error's non-enumerable `rejections` +* property without being written to the global console. +*/ +const allSettledWithThrow = async (promises) => { + const results = await Promise.allSettled(promises); + const rejected = results.filter((result) => result.status === "rejected"); + if (rejected.length) throw Object.defineProperty(/* @__PURE__ */ new Error(`${rejected.length} promise(s) failed`), "rejections", { + configurable: true, + value: rejected.map(({ reason }) => reason), + writable: true + }); + const values = []; + for (const result of results) if (result.status === "fulfilled") values.push(result.value); + return values; +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/vector-store-upload.mjs +/** +* Uploads files with a shared iterator, then creates and polls the batch. Every +* worker settles before upload failures are propagated. Zero concurrency is +* rejected before any upload or batch-creation request. +* +* @internal +*/ +async function uploadAndPollVectorStoreFileBatch(resource, client, vectorStoreId, files, fileIds, options) { + if (files === null || files === void 0 || files.length === 0) throw new Error("No `files` provided to process. If you've already uploaded files you should use `.createAndPoll()` instead"); + const configuredConcurrency = options?.maxConcurrency ?? 5; + const concurrencyLimit = Math.min(configuredConcurrency, files.length); + if (concurrencyLimit === 0) throw new RangeError("maxConcurrency must be greater than 0"); + const fileIterator = files.values(); + const allFileIds = [...fileIds]; + async function processFiles(iterator) { + for (const item of iterator) { + const fileObj = await client.files.create({ + file: item, + purpose: "assistants" + }, options); + allFileIds.push(fileObj.id); + } + } + const workers = []; + workers.length = concurrencyLimit; + for (let index = 0; index < workers.length; index += 1) workers[index] = processFiles(fileIterator); + await allSettledWithThrow(workers); + return await resource.createAndPoll(vectorStoreId, { file_ids: allFileIds }, options); +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/vector-stores/file-batches.mjs +function resolveResourceRequestOptions$5(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var FileBatches = class extends APIResource { + /** + * Create a vector store file batch. + */ + create(vectorStoreID, body, options) { + return this._client.post(path`/vector_stores/${vectorStoreID}/file_batches`, resolveResourceRequestOptions$5(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Retrieves a vector store file batch. + */ + retrieve(batchID, params, options) { + const { vector_store_id } = params; + return this._client.get(path`/vector_stores/${vector_store_id}/file_batches/${batchID}`, resolveResourceRequestOptions$5(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Cancel a vector store file batch. This attempts to cancel the processing of + * files in this batch as soon as possible. + */ + cancel(batchID, params, options) { + const { vector_store_id } = params; + return this._client.post(path`/vector_stores/${vector_store_id}/file_batches/${batchID}/cancel`, resolveResourceRequestOptions$5(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Create a vector store batch and poll until all files have been processed. + */ + async createAndPoll(vectorStoreId, body, options) { + const batch = await this.create(vectorStoreId, body, options); + return await this.poll(vectorStoreId, batch.id, options); + } + /** + * Returns a list of vector store files in a batch. + */ + listFiles(batchID, params, options) { + const { vector_store_id, ...query } = params; + return this._client.getAPIList(path`/vector_stores/${vector_store_id}/file_batches/${batchID}/files`, CursorPage, resolveResourceRequestOptions$5(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Wait for the given file batch to be processed. + * + * Note: this will return even if one of the files failed to process, you need to + * check batch.file_counts.failed_count to handle this case. + */ + async poll(vectorStoreID, batchID, options) { + return await pollVectorStoreFileBatch(this, vectorStoreID, batchID, options); + } + /** + * Uploads the given files concurrently and then creates a vector store file batch. + * + * The concurrency limit is configurable using the `maxConcurrency` parameter. + */ + async uploadAndPoll(vectorStoreId, { files, fileIds = [] }, options) { + return await uploadAndPollVectorStoreFileBatch(this, this._client, vectorStoreId, files, fileIds, options); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/vector-stores/files.mjs +function resolveResourceRequestOptions$4(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$3 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$3(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$3.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$3.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Files = class extends APIResource { + /** + * Create a vector store file by attaching a + * [File](https://developers.openai.com/api/reference/resources/files) to a + * [vector store](https://developers.openai.com/api/reference/resources/vector_stores). + */ + create(vectorStoreID, body, options) { + return this._client.post(path`/vector_stores/${vectorStoreID}/files`, resolveResourceRequestOptions$4(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Retrieves a vector store file. + */ + retrieve(fileID, params, options) { + const { vector_store_id } = params; + return this._client.get(path`/vector_stores/${vector_store_id}/files/${fileID}`, resolveResourceRequestOptions$4(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Update attributes on a vector store file. + */ + update(fileID, params, options) { + const { vector_store_id, ...body } = params; + return this._client.post(path`/vector_stores/${vector_store_id}/files/${fileID}`, resolveResourceRequestOptions$4(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + list(vectorStoreID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$3(query, [ + "after", + "before", + "filter", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList(path`/vector_stores/${vectorStoreID}/files`, CursorPage, resolveResourceRequestOptions$4(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Delete a vector store file. This will remove the file from the vector store but + * the file itself will not be deleted. To delete the file, use the + * [delete file](https://developers.openai.com/api/reference/resources/files/methods/delete) + * endpoint. + */ + delete(fileID, params, options) { + const { vector_store_id } = params; + return this._client.delete(path`/vector_stores/${vector_store_id}/files/${fileID}`, resolveResourceRequestOptions$4(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Attach a file to the given vector store and wait for it to be processed. + */ + async createAndPoll(vectorStoreId, body, options) { + const file = await this.create(vectorStoreId, body, options); + return await this.poll(vectorStoreId, file.id, options); + } + /** + * Wait for the vector store file to finish processing. + * + * Note: this will return even if the file failed to process, you need to check + * file.last_error and file.status to handle these cases + */ + async poll(vectorStoreID, fileID, options) { + return await pollVectorStoreFile(this, vectorStoreID, fileID, options); + } + /** + * Upload a file to the `files` API and then attach it to the given vector store. + * + * Note the file will be asynchronously processed (you can use the alternative + * polling helper method to wait for processing to complete). + */ + async upload(vectorStoreId, file, options) { + const fileInfo = await this._client.files.create({ + file, + purpose: "assistants" + }, options); + return this.create(vectorStoreId, { file_id: fileInfo.id }, options); + } + /** + * Add a file to a vector store and poll until processing is complete. + */ + async uploadAndPoll(vectorStoreId, file, options) { + const fileInfo = await this.upload(vectorStoreId, file, options); + return await this.poll(vectorStoreId, fileInfo.id, options); + } + /** + * Retrieve the parsed contents of a vector store file. + */ + content(fileID, params, options) { + const { vector_store_id } = params; + return this._client.getAPIList(path`/vector_stores/${vector_store_id}/files/${fileID}/content`, Page, resolveResourceRequestOptions$4(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/vector-stores/vector-stores.mjs +function resolveResourceRequestOptions$3(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$2 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$2(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$2.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$2.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var VectorStores = class extends APIResource { + constructor() { + super(...arguments); + this.files = new Files(this._client); + this.fileBatches = new FileBatches(this._client); + } + /** + * Create a vector store. + */ + create(body, options) { + return this._client.post("/vector_stores", resolveResourceRequestOptions$3(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Retrieves a vector store. + */ + retrieve(vectorStoreID, options) { + return this._client.get(path`/vector_stores/${vectorStoreID}`, resolveResourceRequestOptions$3(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Modifies a vector store. + */ + update(vectorStoreID, body, options) { + return this._client.post(path`/vector_stores/${vectorStoreID}`, resolveResourceRequestOptions$3(options, (options) => ({ + body, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$2(query, [ + "after", + "before", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/vector_stores", CursorPage, resolveResourceRequestOptions$3(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Delete a vector store. + */ + delete(vectorStoreID, options) { + return this._client.delete(path`/vector_stores/${vectorStoreID}`, resolveResourceRequestOptions$3(options, (options) => ({ + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } + /** + * Search a vector store for relevant chunks based on a query and file attributes + * filter. + */ + search(vectorStoreID, body, options) { + return this._client.getAPIList(path`/vector_stores/${vectorStoreID}/search`, Page, resolveResourceRequestOptions$3(options, (options) => ({ + body, + method: "post", + ...options, + headers: buildHeaders([{ "OpenAI-Beta": "assistants=v2" }, options?.headers]), + __security: { bearerAuth: true } + }))); + } +}; +VectorStores.Files = Files; +VectorStores.FileBatches = FileBatches; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/videos.mjs +function resolveResourceRequestOptions$2(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys$1 = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery$1(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys$1.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys$1.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +/** +* @deprecated The Sora API is scheduled to permanently shut down on September 24, 2026. +*/ +var Videos = class extends APIResource { + /** + * Create a new video generation job from a prompt and optional reference assets. + * + * @deprecated The Sora API is scheduled to permanently shut down on September 24, 2026. + */ + create(body, options) { + return this._client.post("/videos", resolveResourceRequestOptions$2(options, (options) => multipartFormRequestOptions({ + body, + ...options, + __security: { bearerAuth: true } + }, this._client))); + } + /** + * Fetch the latest metadata for a generated video. + * + * @deprecated The Sora API is scheduled to permanently shut down on September 24, 2026. + */ + retrieve(videoID, options) { + return this._client.get(path`/videos/${videoID}`, resolveResourceRequestOptions$2(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$1(query, [ + "after", + "limit", + "order" + ], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/videos", ConversationCursorPage, resolveResourceRequestOptions$2(options, (options) => ({ + query, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Permanently delete a completed or failed video and its stored assets. + * + * @deprecated The Sora API is scheduled to permanently shut down on September 24, 2026. + */ + delete(videoID, options) { + return this._client.delete(path`/videos/${videoID}`, resolveResourceRequestOptions$2(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Create a character from an uploaded video. + * + * @deprecated The Sora API is scheduled to permanently shut down on September 24, 2026. + */ + createCharacter(body, options) { + return this._client.post("/videos/characters", resolveResourceRequestOptions$2(options, (options) => multipartFormRequestOptions({ + body, + ...options, + __security: { bearerAuth: true } + }, this._client))); + } + downloadContent(videoID, query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery$1(query, ["variant"], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.get(path`/videos/${videoID}/content`, resolveResourceRequestOptions$2(options, (options) => ({ + query, + ...options, + headers: buildHeaders([{ Accept: "application/binary" }, options?.headers]), + __security: { bearerAuth: true }, + __binaryResponse: true + }))); + } + /** + * Create a new video generation job by editing a source video or existing + * generated video. + * + * @deprecated The Sora API is scheduled to permanently shut down on September 24, 2026. + */ + edit(body, options) { + return this._client.post("/videos/edits", resolveResourceRequestOptions$2(options, (options) => multipartFormRequestOptions({ + body, + ...options, + __security: { bearerAuth: true } + }, this._client))); + } + /** + * Create an extension of a completed video. + * + * @deprecated The Sora API is scheduled to permanently shut down on September 24, 2026. + */ + extend(body, options) { + return this._client.post("/videos/extensions", resolveResourceRequestOptions$2(options, (options) => multipartFormRequestOptions({ + body, + ...options, + __security: { bearerAuth: true } + }, this._client))); + } + /** + * Fetch a character. + * + * @deprecated The Sora API is scheduled to permanently shut down on September 24, 2026. + */ + getCharacter(characterID, options) { + return this._client.get(path`/videos/characters/${characterID}`, resolveResourceRequestOptions$2(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Create a remix of a completed video using a refreshed prompt. + * + * @deprecated The Sora API is scheduled to permanently shut down on September 24, 2026. + */ + remix(videoID, body, options) { + return this._client.post(path`/videos/${videoID}/remix`, resolveResourceRequestOptions$2(options, (options) => maybeMultipartFormRequestOptions({ + body, + ...options, + __security: { bearerAuth: true } + }, this._client))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/lib/webhook-signature.mjs +const MAX_DIRECT_WEBHOOK_VERIFICATIONS = 32; +const SHA256_SIGNATURE_LENGTH = 32; +/** +* Checks whether a webhook header requires constant-work HMAC signing without +* retaining an unbounded number of signature candidates. +* +* @internal +*/ +function webhookSignatureRequiresSigning(signatureHeader) { + return signatureHeader.split(" ", 33).length > MAX_DIRECT_WEBHOOK_VERIFICATIONS; +} +function* signatureCandidates(signatureHeader) { + let start = 0; + while (start <= signatureHeader.length) { + const separator = signatureHeader.indexOf(" ", start); + const candidate = signatureHeader.slice(start, separator === -1 ? void 0 : separator); + yield candidate.startsWith("v1,") ? candidate.slice(3) : candidate; + if (separator === -1) break; + start = separator + 1; + } +} +function decodeSignature(signature) { + try { + const signatureBytes = fromBase64(signature); + return signatureBytes.byteLength === SHA256_SIGNATURE_LENGTH ? signatureBytes : void 0; + } catch { + return; + } +} +function firstValidLengthSignature(signatureHeader) { + for (const signature of signatureCandidates(signatureHeader)) { + const signatureBytes = decodeSignature(signature); + if (signatureBytes) return signatureBytes; + } +} +function selectMatchingSignature(signatureHeader, expectedSignature, firstSignature) { + let matchingSignature = firstSignature; + for (const signature of signatureCandidates(signatureHeader)) { + const signatureBytes = decodeSignature(signature); + if (!signatureBytes) continue; + let difference = 0; + for (const [index, byte] of signatureBytes.entries()) difference |= byte ^ (expectedSignature[index] ?? 0); + if (difference === 0) matchingSignature = signatureBytes; + } + return matchingSignature; +} +/** +* Checks the timestamp and HMAC signatures after the resource has validated its +* crypto capabilities, secret, and required headers. +* +* @internal +*/ +async function verifyWebhookSignature(payload, signatureHeader, timestamp, webhookId, secret, tolerance) { + const timestampSeconds = Number.parseInt(timestamp, 10); + if (Number.isNaN(timestampSeconds)) throw new InvalidWebhookSignatureError("Invalid webhook timestamp format"); + const nowSeconds = Math.floor(Date.now() / 1e3); + if (nowSeconds - timestampSeconds > tolerance) throw new InvalidWebhookSignatureError("Webhook timestamp is too old"); + if (timestampSeconds > nowSeconds + tolerance) throw new InvalidWebhookSignatureError("Webhook timestamp is too new"); + const useBoundedVerification = webhookSignatureRequiresSigning(signatureHeader); + const firstSignature = useBoundedVerification ? firstValidLengthSignature(signatureHeader) : void 0; + if (useBoundedVerification && !firstSignature) throw new InvalidWebhookSignatureError("The given webhook signature does not match the expected signature"); + const decodedSecret = Uint8Array.from(secret.startsWith("whsec_") ? fromBase64(secret.slice(6)) : encodeUTF8(secret)); + const signedPayload = webhookId ? `${webhookId}.${timestamp}.${payload}` : `${timestamp}.${payload}`; + const signedPayloadBytes = Uint8Array.from(encodeUTF8(signedPayload)); + const key = await crypto.subtle.importKey("raw", decodedSecret, { + name: "HMAC", + hash: "SHA-256" + }, false, useBoundedVerification ? ["sign", "verify"] : ["verify"]); + if (useBoundedVerification && firstSignature) { + const signatureToVerify = selectMatchingSignature(signatureHeader, new Uint8Array(await crypto.subtle.sign("HMAC", key, signedPayloadBytes)), firstSignature); + try { + if (await crypto.subtle.verify("HMAC", key, Uint8Array.from(signatureToVerify), signedPayloadBytes)) return; + } catch {} + throw new InvalidWebhookSignatureError("The given webhook signature does not match the expected signature"); + } + for (const signature of signatureCandidates(signatureHeader)) try { + const signatureBytes = Uint8Array.from(fromBase64(signature)); + if (await crypto.subtle.verify("HMAC", key, signatureBytes, signedPayloadBytes)) return; + } catch {} + throw new InvalidWebhookSignatureError("The given webhook signature does not match the expected signature"); +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/webhooks/event-types.mjs +function resolveResourceRequestOptions$1(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +var EventTypes = class extends APIResource { + /** + * Returns webhook event types visible to the authenticated project. + * + * @example + * ```ts + * const webhookEventTypeList = + * await client.webhooks.eventTypes.list(); + * ``` + */ + list(options) { + return this._client.get("/webhook_event_types", resolveResourceRequestOptions$1(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } +}; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/resources/webhooks/webhooks.mjs +var _Webhooks_instances; +var _Webhooks_validateSecret; +var _Webhooks_getRequiredHeader; +function resolveResourceRequestOptions(options, buildOptions) { + return Promise.resolve(options).then(buildOptions); +} +const normalizeRequestOptionsForQueryKeys = /* @__PURE__ */ new Set([ + "method", + "path", + "query", + "body", + "headers", + "maxRetries", + "stream", + "timeout", + "httpAgent", + "fetchOptions", + "signal", + "idempotencyKey", + "defaultBaseURL", + "__metadata", + "__binaryRequest", + "__binaryResponse", + "__streamClass", + "__security", + "__synthesizeEventData" +]); +function normalizeRequestOptionsForQuery(value, queryKeys, options) { + if (typeof value !== "object" || value === null) return void 0; + const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => descriptor.enumerable && (!("value" in descriptor) || descriptor.value !== void 0)); + const keys = entries.map(([key]) => key); + if (!keys.some((key) => normalizeRequestOptionsForQueryKeys.has(key) && !queryKeys.includes(key))) return void 0; + if (options !== void 0 || keys.some((key) => !normalizeRequestOptionsForQueryKeys.has(key) || queryKeys.includes(key))) throw new TypeError("Query parameters and request options must be passed as separate arguments."); + if (keys.some((key) => ![ + "headers", + "maxRetries", + "timeout", + "signal", + "idempotencyKey", + "query" + ].includes(key))) throw new TypeError("Pass transport overrides in the explicit request options argument."); + return Object.fromEntries(entries.map(([key, descriptor]) => { + if ("value" in descriptor) return [key, descriptor.value]; + return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : void 0]; + })); +} +var Webhooks = class extends APIResource { + constructor() { + super(...arguments); + _Webhooks_instances.add(this); + this.eventTypes = new EventTypes(this._client); + } + /** + * Creates a webhook endpoint for the authenticated project. + * + * @example + * ```ts + * const webhookEndpointWithSecret = + * await client.webhooks.create({ + * event_types: ['batch.completed'], + * name: 'x', + * url: 'https://', + * }); + * ``` + */ + create(body, options) { + return this._client.post("/webhook_endpoints", resolveResourceRequestOptions(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Retrieves a webhook endpoint for the authenticated project. + * + * @example + * ```ts + * const webhookEndpoint = await client.webhooks.retrieve( + * 'whe_123', + * ); + * ``` + */ + retrieve(webhookEndpointID, options) { + return this._client.get(path`/webhook_endpoints/${webhookEndpointID}`, resolveResourceRequestOptions(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Updates a webhook endpoint for the authenticated project. + * + * @example + * ```ts + * const webhookEndpoint = await client.webhooks.update('whe_123'); + * ``` + */ + update(webhookEndpointID, body = {}, options) { + return this._client.post(path`/webhook_endpoints/${webhookEndpointID}`, resolveResourceRequestOptions(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } + list(query = {}, options) { + const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery(query, ["after", "limit"], options); + if (normalizeRequestOptionsForQueryOptions !== void 0) { + options = normalizeRequestOptionsForQueryOptions; + query = {}; + } + query = query; + return this._client.getAPIList("/webhook_endpoints", CursorPage, resolveResourceRequestOptions(options, (options) => ({ + query, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Deletes a webhook endpoint for the authenticated project. + * + * @example + * ```ts + * const deletedWebhookEndpoint = await client.webhooks.delete( + * 'whe_123', + * ); + * ``` + */ + delete(webhookEndpointID, options) { + return this._client.delete(path`/webhook_endpoints/${webhookEndpointID}`, resolveResourceRequestOptions(options, (options) => ({ + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Rotates the signing secret for a webhook endpoint in the authenticated project. + * + * @example + * ```ts + * const webhookEndpointWithSecret = + * await client.webhooks.rotateSecret('whe_123'); + * ``` + */ + rotateSecret(webhookEndpointID, body = {}, options) { + return this._client.post(path`/webhook_endpoints/${webhookEndpointID}/rotate_secret`, resolveResourceRequestOptions(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Sends a sample event to a webhook endpoint for the authenticated project. + * + * @example + * ```ts + * const webhookEndpointTestResult = + * await client.webhooks.test('whe_123', { + * event_type: 'batch.completed', + * }); + * ``` + */ + test(webhookEndpointID, body, options) { + return this._client.post(path`/webhook_endpoints/${webhookEndpointID}/test`, resolveResourceRequestOptions(options, (options) => ({ + body, + ...options, + __security: { bearerAuth: true } + }))); + } + /** + * Validates that the given payload was sent by OpenAI and parses the payload. + */ + async unwrap(payload, headers, secret = this._client.webhookSecret, tolerance = 300) { + await this.verifySignature(payload, headers, secret, tolerance); + return JSON.parse(payload); + } + /** + * Validates whether or not the webhook payload was sent by OpenAI. + * + * An error will be raised if the webhook payload was not sent by OpenAI. + * + * @param payload - The webhook payload + * @param headers - The webhook headers + * @param secret - The webhook secret (optional, will use client secret if not provided) + * @param tolerance - Maximum age of the webhook in seconds (default: 300 = 5 minutes) + */ + async verifySignature(payload, headers, secret = this._client.webhookSecret, tolerance = 300) { + if (typeof crypto === "undefined" || typeof crypto.subtle?.importKey !== "function" || typeof crypto.subtle.verify !== "function") throw new Error("Webhook signature verification is only supported when the `crypto` global is defined"); + __classPrivateFieldGet(this, _Webhooks_instances, "m", _Webhooks_validateSecret).call(this, secret); + const headersObj = buildHeaders([headers]).values; + const signatureHeader = __classPrivateFieldGet(this, _Webhooks_instances, "m", _Webhooks_getRequiredHeader).call(this, headersObj, "webhook-signature"); + const timestamp = __classPrivateFieldGet(this, _Webhooks_instances, "m", _Webhooks_getRequiredHeader).call(this, headersObj, "webhook-timestamp"); + const webhookId = __classPrivateFieldGet(this, _Webhooks_instances, "m", _Webhooks_getRequiredHeader).call(this, headersObj, "webhook-id"); + if (webhookSignatureRequiresSigning(signatureHeader) && typeof crypto.subtle.sign !== "function") throw new Error("Webhook signature verification is only supported when the `crypto` global is defined"); + return await verifyWebhookSignature(payload, signatureHeader, timestamp, webhookId, secret, tolerance); + } +}; +_Webhooks_instances = /* @__PURE__ */ new WeakSet(), _Webhooks_validateSecret = function _Webhooks_validateSecret(secret) { + if (typeof secret !== "string" || secret.length === 0) throw new Error(`The webhook secret must either be set using the env var, OPENAI_WEBHOOK_SECRET, on the client class, OpenAI({ webhookSecret: '123' }), or passed to this function`); +}, _Webhooks_getRequiredHeader = function _Webhooks_getRequiredHeader(headers, name) { + if (!headers) throw new Error(`Headers are required`); + const value = headers.get(name); + if (value === null || value === void 0) throw new Error(`Missing required header: ${name}`); + return value; +}; +Webhooks.EventTypes = EventTypes; +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/bedrock.mjs +/** Identifies legacy Bedrock clients without importing the client class into WebSocket modules. */ +const brand_privateBedrockClient = Symbol.for("openai.privateBedrockClient"); +/** Rejects non-HTTP field bytes without retaining or exposing a bearer credential. */ +function assertValidBedrockBearerCredential(credential) { + if (/^[\t ]|[\t ]$/.test(credential)) throw new TypeError("Bedrock bearer credential contains an invalid HTTP header value."); + for (const character of credential) { + const value = character.codePointAt(0) ?? 0; + if (value < 32 && value !== 9 || value === 127 || value > 255) throw new TypeError("Bedrock bearer credential contains an invalid HTTP header value."); + } +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/realtime-credentials.mjs +const realtimeCacheContext = Symbol.for("openai.realtimeAPIKeyCacheContext"); +let cacheContext; +/** Reserves a deferred commit when the base hook is entered for this invocation. @internal */ +function getDeferredRealtimeAPIKeyCache(client) { + const deferred = client[realtimeCacheContext]?.getStore(); + return deferred?.client === client ? deferred : void 0; +} +/** Applies the Bedrock getter's validation when a captured credential does not enter the cache. @internal */ +function validateCapturedAPIKey(client, credential) { + if (credential !== null && brand_privateBedrockClient in client) assertValidBedrockBearerCredential(credential); + return credential; +} +/** +* Captures the key belonging to this request or factory invocation while retaining the +* existing boolean credential-hook contract. Legacy overrides that do not +* capture a key keep their shared-property behavior and remain responsible for +* synchronizing concurrent credential updates. +* @internal +*/ +async function resolveRealtimeAPIKey(client, deferCache = false) { + let apiKey; + const current = { + client, + commit: () => apiKey === void 0 ? client.apiKey : apiKey + }; + const capture = (resolved) => { + apiKey = resolved; + }; + const invoke = () => client._callApiKey(capture); + const context = client[realtimeCacheContext] ?? cacheContext; + if (deferCache && context && !client[realtimeCacheContext]) Object.defineProperty(client, realtimeCacheContext, { value: context }); + const isProvider = await (context ? context.run(deferCache ? current : void 0, invoke) : invoke()); + return { + apiKey: apiKey === void 0 ? client.apiKey : apiKey, + isProvider, + commit: () => { + const hookKey = current.providerKey !== void 0 && apiKey !== void 0 && apiKey !== current.providerKey ? validateCapturedAPIKey(client, apiKey) : void 0; + const cached = current.commit(); + return hookKey === void 0 ? validateCapturedAPIKey(client, cached) : hookKey; + } + }; +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/ws.mjs +/** Merge transport authentication before explicit caller overrides and header removals. */ +function mergeWebSocketAuthHeaders(options, authHeaders, removedHeaders) { + const headers = new Map(Object.entries(authHeaders).map(([name, value]) => [name.toLowerCase(), value])); + for (const name of removedHeaders) headers.delete(name); + for (const [name, value] of Object.entries(options.headers ?? {})) headers.set(name, value); + return { + ...options, + headers: Object.fromEntries(headers) + }; +} +/** Removal sink for one synchronous header-hook call, including legacy one-argument overrides. */ +const webSocketHeaderRemovals = /* @__PURE__ */ new WeakMap(); +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/internal/provider.mjs +/** +* A provider factory such as `bedrock(options)` captures configuration in a +* definition, while every OpenAI client receives a fresh runtime from +* `definition.configure()`. Keeping definitions out of the provider object +* makes providers opaque and prevents arbitrary objects from imitating one. +* It also leaves provider-specific dependencies outside the core SDK. +* +* The registry lives on `globalThis` under a global symbol so a provider made +* by one copy of the package still works with another copy, including mixed +* CommonJS and ESM installations. The WeakMap avoids retaining discarded +* provider configurations. +*/ +const providerDefinitionsKey = Symbol.for("openai.node.providerDefinitions.v1"); +const providerGlobal = globalThis; +const existingProviderDefinitions = providerGlobal[providerDefinitionsKey]; +const providerDefinitions = existingProviderDefinitions ?? /* @__PURE__ */ new WeakMap(); +if (!existingProviderDefinitions) Object.defineProperty(providerGlobal, providerDefinitionsKey, { value: providerDefinitions }); +/** +* Creates a new client-specific runtime from a previously registered provider. +* +* @throws {Error} If the value was not created with {@link createProvider}. +*/ +function configureProvider(provider) { + const definition = providerDefinitions.get(provider); + if (!definition) throw new Error("Invalid provider. Providers must be created with createProvider()."); + return definition.configure(); +} +//#endregion +//#region ../../node_modules/.pnpm/openai@7.34.0_undici@6.23.0/node_modules/openai/client.mjs +var _OpenAI_instances; +var _a$1; +var _OpenAI_encoder; +var _OpenAI_x509Authentication; +var _OpenAI_x509Credential; +var _OpenAI_x509Fetch; +var _OpenAI_explicitDataResidency; +var _OpenAI_responseAttempts; +var _OpenAI_sanitizedLoggers; +var _OpenAI_baseURLOverridden; +var _OpenAI_normalizeRetries; +var _OpenAI_isSensitiveLogKey; +var _OpenAI_sanitizeLogValue; +var _OpenAI_sanitizeLogger; +function isRunningInBrowserOrBrowserWorker() { + if (isRunningInBrowser()) return true; + const scope = globalThis; + return typeof scope.WorkerGlobalScope === "function" && scope instanceof scope.WorkerGlobalScope && typeof scope.WorkerNavigator === "function" && scope.navigator instanceof scope.WorkerNavigator && typeof scope.navigator?.userAgent === "string" && scope.navigator.userAgent !== "Cloudflare-Workers" && scope.process?.versions?.node === void 0 && scope.Deno === void 0 && scope.Bun === void 0 && scope.EdgeRuntime === void 0 && scope.WebSocketPair === void 0; +} +const WORKLOAD_IDENTITY_API_KEY_PLACEHOLDER = "workload-identity-auth"; +const inheritedDataResidencySelection = Symbol("inheritedDataResidencySelection"); +/** +* 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 {Provider} [opts.provider] - Configure a third-party API provider. Mutually exclusive with top-level authentication and base URL options. + * @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} 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(clientOptions = {}) { + _OpenAI_instances.add(this); + _OpenAI_encoder.set(this, void 0); + _OpenAI_x509Authentication.set(this, void 0); + _OpenAI_x509Credential.set(this, void 0); + _OpenAI_x509Fetch.set(this, void 0); + _OpenAI_explicitDataResidency.set(this, false); + _OpenAI_responseAttempts.set(this, /* @__PURE__ */ new WeakMap()); + this._apiKeyInvocation = 0; + this._lastCachedAPIKeyInvocation = 0; + this.decisions = new Decisions(this); + /** + * 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$1(this); + /** + * Given a prompt and/or an input image, the model will generate a new image. + */ + this.images = new Images(this); + this.contentProvenanceChecks = new ContentProvenanceChecks(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.safety = new Safety(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); + /** + * Create and manage model responses. + */ + this.responses = new Responses(this); + this.live = new Live(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); + /** + * @deprecated The Sora API is scheduled to permanently shut down on September 24, 2026. + */ + this.videos = new Videos(this); + const { credential, options: normalizedOptions } = normalizeX509CredentialOptions(clientOptions); + clientOptions = normalizedOptions; + const residencyBaseURL = resolveDataResidency(clientOptions); + const provider = clientOptions.provider; + const { baseURL = provider ? null : readEnv("OPENAI_BASE_URL"), dataResidency: _dataResidency, [inheritedDataResidencySelection]: inheritedResidencySelection = false, apiKey = provider ? null : readEnv("OPENAI_API_KEY") ?? null, adminAPIKey = provider ? null : readEnv("OPENAI_ADMIN_KEY") ?? null, organization = provider ? null : readEnv("OPENAI_ORG_ID") ?? null, project = provider ? null : readEnv("OPENAI_PROJECT_ID") ?? null, webhookSecret = readEnv("OPENAI_WEBHOOK_SECRET") ?? null, workloadIdentity, x509Transport, credential: _credential, ...opts } = clientOptions; + if (provider) { + const conflictingOptions = [ + "apiKey", + "adminAPIKey", + "workloadIdentity", + "x509Transport", + "baseURL", + "dataResidency" + ].filter((key) => (key === "workloadIdentity" ? workloadIdentity : clientOptions[key]) != null); + if (conflictingOptions.length) throw new OpenAIError(`The \`provider\` option cannot be used with ${conflictingOptions.map((key) => `\`${key}\``).join(", ")}. Configure authentication and the base URL through the provider instead.`); + } + const identity = isX509WorkloadIdentity(workloadIdentity) ? { + x509: workloadIdentity, + legacy: void 0 + } : { + x509: void 0, + legacy: workloadIdentity + }; + const x509Identity = identity.x509; + const usesX509Identity = x509Identity !== void 0; + const providerRuntime = provider ? configureProvider(provider) : void 0; + const options = { + apiKey, + adminAPIKey, + organization, + project, + webhookSecret, + workloadIdentity, + x509Transport, + provider, + ...opts, + baseURL: providerRuntime?.baseURL ?? residencyBaseURL ?? (baseURL || (usesX509Identity ? "https://mtls.api.openai.com/v1" : `https://api.openai.com/v1`)) + }; + if (x509Transport && !usesX509Identity) throw new OpenAIError("An X.509 transport requires an X.509 workload identity."); + if (usesX509Identity) { + if (residencyBaseURL !== void 0 || inheritedResidencySelection) throw new OpenAIError("X.509 workload identity does not support data residency selection."); + if (clientOptions.fetch !== void 0) throw new OpenAIError("X.509 workload identity does not support a custom fetch implementation."); + assertX509APIOrigin(options.baseURL); + assertX509RequestOptions(options.fetchOptions); + if (this.fetchWithAuth !== _a$1.prototype.fetchWithAuth || this.fetchWithTimeout !== _a$1.prototype.fetchWithTimeout) throw new OpenAIError("X.509 workload identity does not support overridden fetch dispatch hooks."); + } + if (apiKey && workloadIdentity) throw new OpenAIError("The `apiKey` and `workloadIdentity` options are mutually exclusive"); + if (!providerRuntime && !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 && isRunningInBrowserOrBrowserWorker()) 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; + __classPrivateFieldSet(this, _OpenAI_explicitDataResidency, residencyBaseURL !== void 0 || inheritedResidencySelection, "f"); + this.timeout = options.timeout ?? _a$1.DEFAULT_TIMEOUT; + this.logger = __classPrivateFieldGet(this, _OpenAI_instances, "m", _OpenAI_sanitizeLogger).call(this, 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 = __classPrivateFieldGet(this, _OpenAI_instances, "m", _OpenAI_normalizeRetries).call(this, options.maxRetries); + this.fetch = options.fetch ?? getDefaultFetch(); + __classPrivateFieldSet(this, _OpenAI_encoder, FallbackEncoder, "f"); + const customHeadersEnv = provider || credential ? void 0 : 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; + this._provider = providerRuntime; + if (x509Identity) { + const authentication = new X509WorkloadIdentityAuth(x509Identity, x509Transport, organization, project); + this._workloadIdentityAuth = authentication; + __classPrivateFieldSet(this, _OpenAI_x509Authentication, authentication, "f"); + __classPrivateFieldSet(this, _OpenAI_x509Credential, credential, "f"); + __classPrivateFieldSet(this, _OpenAI_x509Fetch, authentication.fetch(), "f"); + this.fetch = __classPrivateFieldGet(this, _OpenAI_x509Fetch, "f"); + markApprovedX509Client(this); + } else if (identity.legacy) this._workloadIdentityAuth = new WorkloadIdentityAuth(identity.legacy, 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) { + const residencyBaseURL = resolveDataResidency(options); + const x509Authentication = __classPrivateFieldGet(this, _OpenAI_x509Authentication, "f"); + const inheritedOptions = { + ...this._options, + baseURL: this.baseURL, + maxRetries: this.maxRetries, + timeout: this.timeout, + logger: this.logger, + logLevel: this.logLevel, + fetch: __classPrivateFieldGet(this, _OpenAI_x509Authentication, "f") ? void 0 : this.fetch, + fetchOptions: this.fetchOptions, + apiKey: this._options.apiKey, + adminAPIKey: this.adminAPIKey, + workloadIdentity: x509Authentication?.identitySnapshot() ?? this._options.workloadIdentity, + x509Transport: this._options.x509Transport, + organization: this.organization, + project: this.project, + webhookSecret: this.webhookSecret + }; + const { credential, provider } = prepareX509ClientClone(inheritedOptions, options, __classPrivateFieldGet(this, _OpenAI_x509Credential, "f"), x509Authentication !== void 0); + if (residencyBaseURL !== void 0) delete inheritedOptions.baseURL; + const clientOptions = { + ...inheritedOptions, + ...options, + credential, + provider, + [inheritedDataResidencySelection]: __classPrivateFieldGet(this, _OpenAI_explicitDataResidency, "f") && residencyBaseURL === void 0 && !hasOwn(options, "baseURL") && options.credential === void 0 && !provider + }; + const client = new this.constructor(clientOptions); + if (provider && new URL(client.baseURL).origin !== new URL(this.baseURL).origin) { + Object.assign(client._options, { + defaultHeaders: options.defaultHeaders, + defaultQuery: options.defaultQuery, + fetchOptions: options.fetchOptions, + fetch: options.fetch + }); + client.fetchOptions = options.fetchOptions; + client.fetch = options.fetch ?? getDefaultFetch(); + client.organization = options.organization ?? null; + client.project = options.project ?? null; + } + if (__classPrivateFieldGet(this, _OpenAI_x509Authentication, "f") && __classPrivateFieldGet(client, _OpenAI_x509Authentication, "f") && this.baseURL === client.baseURL && __classPrivateFieldGet(this, _OpenAI_x509Authentication, "f").matches(__classPrivateFieldGet(client, _OpenAI_x509Authentication, "f"))) { + client._workloadIdentityAuth = __classPrivateFieldGet(this, _OpenAI_x509Authentication, "f"); + __classPrivateFieldSet(client, _OpenAI_x509Authentication, __classPrivateFieldGet(this, _OpenAI_x509Authentication, "f"), "f"); + __classPrivateFieldSet(client, _OpenAI_x509Fetch, __classPrivateFieldGet(this, _OpenAI_x509Fetch, "f"), "f"); + } + return client; + } + defaultQuery() { + return this._options.defaultQuery; + } + /** @internal Client request headers for each new WebSocket handshake. */ + _buildWebSocketHeaders(authHeaders, removedHeaders) { + const context = webSocketHeaderRemovals.get(this); + if (context?.baseHeaders) return mergeWebSocketAuthHeaders({ headers: context.baseHeaders }, authHeaders, context.removedHeaders ?? /* @__PURE__ */ new Set()).headers; + const headers = buildHeaders([ + { + "User-Agent": this.getUserAgent(), + "OpenAI-Organization": this.organization, + "OpenAI-Project": this.project + }, + authHeaders, + this._options.defaultHeaders + ]); + headers.nulls.forEach((name) => (removedHeaders ?? context?.removedHeaders)?.add(name)); + const result = Object.fromEntries(headers.values); + if (context) context.baseHeaders = { ...result }; + return result; + } + 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 + }) { + if ((__classPrivateFieldGet(this, _OpenAI_x509Authentication, "f") ?? this._workloadIdentityAuth) instanceof X509WorkloadIdentityAuth && schemes.adminAPIKeyAuth && this.adminAPIKey !== null) return await this.adminAPIKeyAuth(opts); + return buildHeaders([schemes.bearerAuth ? await this.bearerAuth(opts) : null, schemes.adminAPIKeyAuth ? await this.adminAPIKeyAuth(opts) : null]); + } + async bearerAuth(opts) { + const authentication = __classPrivateFieldGet(this, _OpenAI_x509Authentication, "f") ?? this._workloadIdentityAuth; + if (authentication) { + if (authentication instanceof X509WorkloadIdentityAuth) { + if (authentication === this._workloadIdentityAuth && (this.fetchWithAuth !== _a$1.prototype.fetchWithAuth || this.fetchWithTimeout !== _a$1.prototype.fetchWithTimeout)) throw new OpenAIError("X.509 workload identity does not support overridden fetch dispatch hooks."); + const snapshots = authentication.headerSnapshots(); + if (!X509WorkloadIdentityAuth.shouldAuthenticate(opts, snapshots.defaultHeaders, snapshots.requestHeaders)) return; + } + const token = authentication instanceof X509WorkloadIdentityAuth ? await authentication.getToken(opts, { + apiURL: authentication.requestAPIURL(), + ...authentication.headerSnapshots(), + ...authentication.requestSnapshot(), + signal: authentication.effectiveSignal(), + ...authentication.tenantSnapshot() + }) : await authentication.getToken(); + return buildHeaders([{ Authorization: `Bearer ${token}` }]); + } + const { apiKey } = await resolveRealtimeAPIKey(this); + if (apiKey == null) return; + return buildHeaders([{ Authorization: `Bearer ${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) { + const normalizedError = error && typeof error === "object" && error.error == null ? { error } : error; + return APIError.generate(status, normalizedError, message, headers); + } + _hasApiKeyProvider() { + return typeof this._options.apiKey === "function"; + } + /** + * Resolves and retains a provider key, returning whether a provider was invoked. + * Overrides should forward `capture` (or call it with their resolved key) for local credentials. + * @internal + */ + async _callApiKey(capture) { + if (this._provider) { + capture?.(this.apiKey); + return false; + } + const apiKey = this._options.apiKey; + if (typeof apiKey !== "function") { + capture?.(this.apiKey); + return false; + } + const deferredCache = getDeferredRealtimeAPIKeyCache(this); + const invocation = ++this._apiKeyInvocation; + 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}`); + const resolvedToken = token; + const commit = () => { + if (capture) validateCapturedAPIKey(this, resolvedToken); + if (invocation < this._lastCachedAPIKeyInvocation) return resolvedToken; + this.apiKey = resolvedToken; + const cached = capture ? this.apiKey : resolvedToken; + this._lastCachedAPIKeyInvocation = invocation; + return cached; + }; + if (deferredCache) { + deferredCache.providerKey = resolvedToken; + deferredCache.commit = commit; + } + const cached = deferredCache ? validateCapturedAPIKey(this, resolvedToken) : commit(); + capture?.(cached); + return true; + } + buildURL(path, query, defaultBaseURL) { + const baseURL = !__classPrivateFieldGet(this, _OpenAI_instances, "m", _OpenAI_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL; + let url; + let baseQuery = {}; + let baseParams; + if (isAbsoluteURL(path)) url = new URL(path); + else if (baseURL.includes("?")) { + const base = new URL(baseURL); + baseParams = new URLSearchParams(base.search); + baseQuery = Object.fromEntries(baseParams); + base.search = ""; + base.hash = ""; + url = new URL(base.toString() + (base.pathname.endsWith("/") && path.startsWith("/") ? path.slice(1) : path)); + } else url = new URL(baseURL + (baseURL.endsWith("/") && path.startsWith("/") ? path.slice(1) : path)); + const defaultQuery = this.defaultQuery(); + const pathQuery = Object.fromEntries(url.searchParams); + let overridingQuery; + if (!isEmptyObj(baseQuery) || !isEmptyObj(defaultQuery) || !isEmptyObj(pathQuery)) { + overridingQuery = { + ...pathQuery, + ...defaultQuery, + ...query + }; + query = { + ...baseQuery, + ...overridingQuery + }; + } + if (typeof query === "object" && query && !Array.isArray(query)) { + url.search = this.stringifyQuery(query); + if (baseParams && overridingQuery) { + const seen = /* @__PURE__ */ new Set(); + const repeated = /* @__PURE__ */ new Set(); + for (const key of baseParams.keys()) { + if (seen.has(key) && !hasOwn(overridingQuery, key)) repeated.add(key); + seen.add(key); + } + if (repeated.size) { + const merged = new URLSearchParams(); + for (const [key, value] of url.searchParams) if (!repeated.has(key)) merged.append(key, value); + for (const [key, value] of baseParams) if (repeated.has(key)) merged.append(key, value); + url.search = merged.toString(); + } + } + } + return url.toString(); + } + /** + * Used as a callback for mutating the given `FinalRequestOptions` object. + * Function-based credentials are resolved later, when building authentication + * headers, including for direct `buildRequest()` calls. Overriding this hook + * does not bypass that resolution. + */ + async prepareOptions(options) {} + /** + * 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) { + const authentication = __classPrivateFieldGet(this, _OpenAI_x509Authentication, "f") ?? this._workloadIdentityAuth; + const request = authentication instanceof X509WorkloadIdentityAuth ? Promise.resolve(options).then((resolved) => authentication.runRequest(() => this.makeRequest(resolved, remainingRetries, void 0), this)) : this.makeRequest(options, remainingRetries, void 0); + return this.responsePromise(request); + } + responsePromise(request, parse = (client, props) => this.parseResponseWithTimeout(client, props)) { + const promise = new APIPromise(this, request, (client, props) => { + const resume = __classPrivateFieldGet(this, _OpenAI_responseAttempts, "f").get(props.controller)?.continueRequest; + return resume ? resume(() => parse(client, props)) : parse(client, props); + }); + promise.withResponse = async () => { + const data = await promise; + const { response } = await request; + return { + data, + response, + request_id: response.headers.get("x-request-id") + }; + }; + promise._thenUnwrap = (transform) => this.responsePromise(request, async (client, props) => addRequestID(transform(await parse(client, props), props), props.response)); + return promise; + } + async parseResponseWithTimeout(client, props) { + if (props.options.stream || props.options.__binaryResponse || props.response.status === 204 || props.response.headers.get("content-length") === "0") return defaultParseResponse(client, props); + while (true) { + const attempt = __classPrivateFieldGet(this, _OpenAI_responseAttempts, "f").get(props.controller); + const timeout = attempt?.timeout ?? props.options.timeout ?? this.timeout; + const x509Authentication = attempt?.authentication; + const callerSignal = x509Authentication ? props.controller.signal : props.options.signal; + const abortError = () => x509Authentication && callerSignal ? this._makeUserAbortError(callerSignal) : new APIUserAbortError(); + let remaining; + try { + remaining = x509Authentication?.remainingTimeout(props.options, timeout) ?? Math.max(0, props.startTime + timeout - Date.now()); + } catch (error) { + const cancellation = callerSignal?.aborted ? abortError() : void 0; + props.controller.abort(); + CancelReadableStream(props.response.body).catch(() => void 0); + throw cancellation ?? error; + } + let timer; + let abortListener; + let timedOut = false; + try { + if (callerSignal?.aborted && attempt?.helperMethod !== "runTools") throw abortError(); + const timeoutPromise = new Promise((_, reject) => { + timer = setTimeout(() => { + timedOut = true; + props.controller.abort(); + reject(new APIConnectionTimeoutError()); + }, remaining); + if (callerSignal) { + abortListener = () => { + if (!timedOut) reject(abortError()); + }; + callerSignal.addEventListener("abort", abortListener, { once: true }); + } + }); + return await Promise.race([defaultParseResponse(client, props), timeoutPromise]); + } catch (error) { + if (callerSignal?.aborted && !timedOut) throw abortError(); + if (!timedOut) { + if (x509Authentication && error instanceof SyntaxError) throw new SyntaxError("X.509 workload identity API response contains invalid JSON."); + if (x509Authentication && !(error instanceof OpenAIError)) throw new APIConnectionError({ message: "X.509 workload identity API response body could not be read." }); + throw error; + } + const retriesRemaining = attempt?.retriesRemaining ?? 0; + if (!retriesRemaining || attempt?.hasStreamingBody || props.options.__metadata?.["hasStreamingBody"] || globalThis.ReadableStream && props.options.body instanceof globalThis.ReadableStream || typeof props.options.body === "object" && props.options.body !== null && (Symbol.asyncIterator in props.options.body || Symbol.iterator in props.options.body && "next" in props.options.body && typeof props.options.body.next === "function")) throw new APIConnectionTimeoutError(); + if (timer !== void 0) clearTimeout(timer); + if (abortListener) callerSignal?.removeEventListener("abort", abortListener); + abortListener = void 0; + const next = await this.retryRequest(props.options, retriesRemaining, props.retryOfRequestLogID ?? props.requestLogID, void 0, props.requestSignal); + Object.assign(props, next); + } finally { + if (timer !== void 0) clearTimeout(timer); + if (abortListener) callerSignal?.removeEventListener("abort", abortListener); + } + } + } + /** Keeps terminal X.509 error-body consumption inside the original logical request deadline. */ + async readX509ResponseError(response, options, timeout, controller, authentication) { + const deadline = new AbortController(); + const callerSignal = controller.signal; + let timedOut = false; + const cancel = () => deadline.abort(callerSignal.reason); + callerSignal.addEventListener("abort", cancel, { once: true }); + if (callerSignal.aborted) cancel(); + try { + const remaining = authentication.remainingTimeout(options, timeout); + const expiration = authentication.waitForRetry(remaining, deadline.signal).then(() => { + throw new APIConnectionTimeoutError(); + }); + const body = await Promise.race([response.text().catch(() => "X.509 workload identity API response body could not be read."), expiration]); + if (callerSignal.aborted) throw this._makeUserAbortError(callerSignal); + return body; + } catch (error) { + if (error instanceof APIConnectionTimeoutError) { + timedOut = !callerSignal.aborted; + controller.abort(); + CancelReadableStream(response.body).catch(() => void 0); + } + if (callerSignal.aborted && !timedOut) throw this._makeUserAbortError(callerSignal); + throw error; + } finally { + callerSignal.removeEventListener("abort", cancel); + deadline.abort(); + } + } + async makeRequest(optionsInput, retriesRemaining, retryOfRequestLogID) { + const options = await optionsInput; + const maxRetries = __classPrivateFieldGet(this, _OpenAI_instances, "m", _OpenAI_normalizeRetries).call(this, options.maxRetries ?? this.maxRetries); + if (retriesRemaining == null) retriesRemaining = maxRetries; + else retriesRemaining = Math.min(__classPrivateFieldGet(this, _OpenAI_instances, "m", _OpenAI_normalizeRetries).call(this, retriesRemaining), maxRetries); + const x509Authentication = __classPrivateFieldGet(this, _OpenAI_x509Authentication, "f"); + x509Authentication?.beginRequestPreparation(); + await this.prepareOptions(options); + x509Authentication?.beginRequestPlanning(); + let built; + try { + const candidate = await this.buildRequest(options, { retryCount: maxRetries - retriesRemaining }); + built = { + req: candidate.req, + url: candidate.url, + timeout: candidate.timeout + }; + if (x509Authentication) { + validatePositiveInteger("timeout", built.timeout); + x509Authentication.authorizePlannedRequest(built.url, built.req, built.timeout); + if (X509WorkloadIdentityAuth.isStreamingRequestBody(built.req.body)) options.__metadata = { + ...options.__metadata, + hasStreamingBody: true + }; + await this.prepareRequest(built.req, { + url: built.url, + options + }); + await this._provider?.prepareRequest?.(built.req, { + url: built.url, + options + }); + x509Authentication.beginRequestPlanning(); + x509Authentication.authorizePlannedRequest(built.url, built.req, built.timeout, true); + if (X509WorkloadIdentityAuth.isStreamingRequestBody(built.req.body)) options.__metadata = { + ...options.__metadata, + hasStreamingBody: true + }; + const callerSignal = x509Authentication.requestSnapshot().signal; + if (callerSignal?.aborted || built.req.signal?.aborted) throw this._makeUserAbortError(callerSignal?.aborted ? callerSignal : built.req.signal); + x509Authentication.setEffectiveSignal(built.req.signal || callerSignal ? createRequestController(built.req.signal ?? callerSignal, callerSignal).signal : void 0); + x509Authentication.beginRequestNetwork(); + const security = options.__security ?? { bearerAuth: true }; + const authenticationHeaders = await this.authHeaders(options, security); + const suppliedHeaders = x509Authentication.headerSnapshots(); + const supplied = buildHeaders([suppliedHeaders.defaultHeaders, suppliedHeaders.requestHeaders]); + for (const [name, value] of authenticationHeaders?.values ?? []) if (!supplied.nulls.has(name) && !built.req.headers.has(name)) built.req.headers.set(name, value); + this.validateHeaders(buildHeaders([supplied, built.req.headers]), security); + } + } catch (error) { + x509Authentication?.retireRequestBody(); + if (x509Authentication && retriesRemaining && !options.__metadata?.["hasStreamingBody"] && X509WorkloadIdentityAuth.isRetryableFailure(error)) return await this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? "x509-token-exchange", X509WorkloadIdentityAuth.retryHeaders(error)); + throw error; + } + const { req, url } = built; + const timeout = x509Authentication ? Math.min(built.timeout, x509Authentication.requestSnapshot().timeout) : built.timeout; + x509Authentication?.bindRequest(options, req, this.adminAPIKey); + let hasStreamingBody = options.__metadata?.["hasStreamingBody"] === true; + if (!x509Authentication) { + await this.prepareRequest(req, { + url, + options + }); + await this._provider?.prepareRequest?.(req, { + url, + options + }); + } + x509Authentication?.adoptRequestHeaders(req); + if (x509Authentication && X509WorkloadIdentityAuth.isStreamingRequestBody(req.body)) hasStreamingBody = true; + /** 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 = x509Authentication?.requestStartedAt(options) ?? Date.now(); + if (this.logLevel === "debug") { + const body = typeof req.body === "string" ? { + type: "string", + length: req.body.length + } : req.body; + loggerFor(this).debug(`[${requestLogID}] sending request`, formatRequestDetails({ + retryOfRequestLogID, + method: options.method, + url, + options: x509Authentication ? { + body, + ...x509Authentication.requestSnapshot() + } : { + ...options, + body + }, + headers: req.headers + })); + } + const callerSignal = x509Authentication ? x509Authentication.requestSnapshot().signal : options.signal; + if (callerSignal?.aborted || req.signal?.aborted) throw this._makeUserAbortError(callerSignal?.aborted ? callerSignal : req.signal); + const security = options.__security ?? { bearerAuth: true }; + const controller = x509Authentication || this.fetchWithTimeout === _a$1.prototype.fetchWithTimeout ? createRequestController(req.signal ?? (x509Authentication ? callerSignal : void 0), x509Authentication ? callerSignal : void 0) : new AbortController(); + const remainingTimeout = x509Authentication?.remainingTimeout(options, timeout) ?? timeout; + const fetchWithAuth = x509Authentication ? _a$1.prototype.fetchWithAuth : this.fetchWithAuth; + x509Authentication?.releaseRequestBody(req.body); + const response = await fetchWithAuth.call(this, url, req, remainingTimeout, controller, security).catch(castToError); + const headersTime = Date.now(); + if (response instanceof globalThis.Error) { + const retryMessage = `retrying, ${retriesRemaining} attempts remaining`; + if (callerSignal?.aborted || req.signal?.aborted) throw this._makeUserAbortError(callerSignal?.aborted ? callerSignal : req.signal); + const isTimeout = isAbortError(response) || /timed? ?out/i.test(String(response) + ("cause" in response ? String(response.cause) : "")); + if (retriesRemaining && !hasStreamingBody && (!x509Authentication || isTransientX509ConnectionError(response))) { + 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: x509Authentication ? "X.509 workload identity API connection failed." : response.message + })); + return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID, void 0, req.signal); + } + const terminalMessage = hasStreamingBody ? "error; streaming body cannot be retried" : "error; no more retries left"; + loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - ${terminalMessage}`); + loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (${terminalMessage})`, formatRequestDetails({ + retryOfRequestLogID, + url, + durationMs: headersTime - startTime, + message: x509Authentication ? "X.509 workload identity API connection failed." : response.message + })); + if (response instanceof OAuthError || response instanceof SubjectTokenProviderError) throw response; + if (isTimeout) { + const transportCause = "cause" in response ? response.cause : void 0; + const timeoutError = typeof transportCause === "object" && transportCause !== null && "code" in transportCause && transportCause.code === "UND_ERR_HEADERS_TIMEOUT" ? new APIConnectionTimeoutError({ message: "Request timed out. Node.js fetch timed out waiting for response headers; configure a matching undici fetch and fetchOptions.dispatcher with an Agent whose headersTimeout is at least the SDK timeout." }) : new APIConnectionTimeoutError(); + if (x509Authentication) throw new APIConnectionTimeoutError(); + throw Object.assign(timeoutError, { cause: response }); + } + if (x509Authentication) throw new APIConnectionError({ message: "X.509 workload identity API connection failed." }); + 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} ${redactURL(url)} ${response.ok ? "succeeded" : "failed"} with status ${response.status} in ${headersTime - startTime}ms`; + if (!response.ok) { + const rejectedX509Credential = response.status === 401 && x509Authentication && security.bearerAuth && x509Authentication.usedWorkloadToken(options); + if (rejectedX509Credential) x509Authentication.invalidateToken(); + if (response.status === 401 && (x509Authentication || this._workloadIdentityAuth) && security.bearerAuth && (!x509Authentication || x509Authentication.usedWorkloadToken(options)) && (!x509Authentication || retriesRemaining > 0) && !hasStreamingBody && !options.__metadata?.["workloadIdentityTokenRefreshed"]) { + if (x509Authentication) CancelReadableStream(response.body).catch(() => void 0); + else { + await CancelReadableStream(response.body); + this._workloadIdentityAuth?.invalidateToken(); + } + const replayOptions = { + ...options, + __metadata: { + ...options.__metadata, + workloadIdentityTokenRefreshed: true + } + }; + return this.makeRequest(replayOptions, x509Authentication ? retriesRemaining - 1 : retriesRemaining, retryOfRequestLogID ?? requestLogID); + } + const shouldRetry = rejectedX509Credential && options.__metadata?.["workloadIdentityTokenRefreshed"] ? false : await this.shouldRetry(response); + if (retriesRemaining && shouldRetry && !hasStreamingBody) { + const retryMessage = `retrying, ${retriesRemaining} attempts remaining`; + if (x509Authentication) CancelReadableStream(response.body).catch(() => void 0); + else 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, req.signal); + } + const retryMessage = shouldRetry ? hasStreamingBody ? `error; streaming body cannot be retried` : `error; no more retries left` : `error; not retryable`; + loggerFor(this).info(`${responseInfo} - ${retryMessage}`); + const errText = x509Authentication ? await this.readX509ResponseError(response, options, timeout, controller, x509Authentication) : 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 + })); + const continueRequest = x509Authentication?.continuation(); + x509Authentication?.releaseRequestCredentials(); + __classPrivateFieldGet(this, _OpenAI_responseAttempts, "f").set(controller, { + timeout, + retriesRemaining, + hasStreamingBody, + ...x509Authentication ? { authentication: x509Authentication } : {}, + helperMethod: options.__metadata?.["helperMethod"], + ...continueRequest ? { continueRequest } : {} + }); + return { + response, + options, + controller, + requestSignal: req.signal, + 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 authentication = __classPrivateFieldGet(this, _OpenAI_x509Authentication, "f") ?? this._workloadIdentityAuth; + const request = authentication instanceof X509WorkloadIdentityAuth ? Promise.resolve(options).then((resolved) => authentication.runRequest(() => this.makeRequest(resolved, null, void 0), this)) : this.makeRequest(options, null, void 0); + const page = new PagePromise(this, request, Page); + const guarded = this.responsePromise(request, async (client, props) => { + const body = await this.parseResponseWithTimeout(client, props); + return new Page(client, props.response, body, props.options); + }); + page.then = guarded.then.bind(guarded); + page.catch = guarded.catch.bind(guarded); + page.finally = guarded.finally.bind(guarded); + page.withResponse = guarded.withResponse.bind(guarded); + page._thenUnwrap = guarded._thenUnwrap.bind(guarded); + return page; + } + async fetchWithAuth(url, init, timeout, controller, schemes = { + bearerAuth: true, + adminAPIKeyAuth: true + }) { + if (this._workloadIdentityAuth && !__classPrivateFieldGet(this, _OpenAI_x509Fetch, "f") && schemes.bearerAuth) { + const headers = init.headers; + if (headers.get("Authorization") === `Bearer ${WORKLOAD_IDENTITY_API_KEY_PLACEHOLDER}`) { + const token = await this._workloadIdentityAuth.getToken(); + headers.set("Authorization", `Bearer ${token}`); + } + } + return await (__classPrivateFieldGet(this, _OpenAI_x509Fetch, "f") ? _a$1.prototype.fetchWithTimeout : this.fetchWithTimeout).call(this, url, init, timeout, controller); + } + async fetchWithTimeout(url, init, ms, controller) { + const { signal, method, ...options } = init || {}; + const abort = this._makeAbort(controller); + const composed = !!signal && composedCallerSignals.get(controller) === signal; + const cleanup = signal && !composed ? addRequestAbortListener(signal, abort, controller.signal) : void 0; + 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 { + const response = await (__classPrivateFieldGet(this, _OpenAI_x509Fetch, "f") ?? this.fetch).call(void 0, url, fetchOptions); + if (cleanup) retainRequestAbortCallback(response.body ?? response, abort, controller.signal); + return response; + } catch (err) { + cleanup?.(); + throw err; + } 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, requestSignal = options.signal) { + 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 === void 0) { + const timeoutSeconds = parseFloat(retryAfterHeader); + if (!Number.isNaN(timeoutSeconds)) timeoutMillis = timeoutSeconds * 1e3; + else timeoutMillis = Date.parse(retryAfterHeader) - Date.now(); + } + if (timeoutMillis === void 0 || !Number.isFinite(timeoutMillis) || timeoutMillis < 0 || timeoutMillis > 6e4) { + const maxRetries = __classPrivateFieldGet(this, _OpenAI_instances, "m", _OpenAI_normalizeRetries).call(this, options.maxRetries ?? this.maxRetries); + timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries); + } + const x509Authentication = __classPrivateFieldGet(this, _OpenAI_x509Authentication, "f"); + if (x509Authentication) { + const remaining = x509Authentication.remainingTimeout(options, x509Authentication.requestSnapshot().timeout); + if (timeoutMillis >= remaining) throw new APIConnectionTimeoutError(); + } + if (x509Authentication) await x509Authentication.waitForRetry(timeoutMillis, x509Authentication.effectiveSignal()); + else { + const retrySignals = requestSignal === options.signal ? [requestSignal] : [requestSignal, options.signal]; + try { + await sleep(timeoutMillis, ...retrySignals); + } catch (error) { + const abortedSignal = retrySignals.find((signal) => signal?.aborted); + if (abortedSignal) throw this._makeUserAbortError(abortedSignal); + throw error; + } + } + 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; + } + /** + * Builds a request, resolving callback credentials when constructing authentication + * headers, after any subclass request-option rewrites. Calling this method directly + * also resolves credentials. Complete replacement builders own authentication and + * can call `this.authHeaders()` to resolve headers with request-local credentials. + */ + async buildRequest(inputOptions, { retryCount = 0 } = {}) { + if (__classPrivateFieldGet(this, _OpenAI_x509Authentication, "f") && !__classPrivateFieldGet(this, _OpenAI_x509Authentication, "f").inRequest(this)) { + const authentication = __classPrivateFieldGet(this, _OpenAI_x509Authentication, "f"); + return await authentication.runRequest(async () => { + const built = await _a$1.prototype.buildRequest.call(this, inputOptions, { retryCount }); + authentication.releaseRequestBody(built.req.body); + return built; + }, this); + } + const options = { ...inputOptions }; + const x509Authentication = __classPrivateFieldGet(this, _OpenAI_x509Authentication, "f"); + const x509Tenant = x509Authentication?.snapshotTenant(this.organization, this.project); + const x509Headers = x509Authentication?.snapshotHeaders(this._options.defaultHeaders, options.headers); + if (x509Headers) options.headers = x509Headers.requestHeaders; + const x509ClientFetchOptions = x509Authentication ? snapshotX509RequestOptions(this.fetchOptions) : void 0; + const x509RequestFetchOptions = x509Authentication ? snapshotX509RequestOptions(options.fetchOptions) : void 0; + const { method, path, query, defaultBaseURL } = options; + const url = this.buildURL(path, query, defaultBaseURL); + x509Authentication?.snapshotAPIURL(url); + const explicitTimeout = "timeout" in options; + if (explicitTimeout) validatePositiveInteger("timeout", options.timeout); + options.timeout = options.timeout ?? this.timeout; + if (x509Authentication && x509RequestFetchOptions) x509Authentication.snapshotRequest(options.signal, options.timeout, x509RequestFetchOptions); + if (x509Authentication) { + const snapshot = x509Authentication.requestSnapshot(); + options.timeout = snapshot.timeout; + if (snapshot.signal === void 0) delete options.signal; + else options.signal = snapshot.signal; + } + const authenticationHeaders = this._provider || x509Authentication ? void 0 : await this.authHeaders(inputOptions, inputOptions.__security ?? { bearerAuth: true }); + const { bodyHeaders, body, isStreamingBody } = this.buildBody({ options }); + if (isStreamingBody) { + inputOptions.__metadata = { + ...inputOptions.__metadata, + hasStreamingBody: true + }; + x509Authentication?.ownRequestBody(body, options.body); + } + return { + req: { + method, + headers: await this.buildHeaders({ + options: inputOptions, + method, + bodyHeaders, + authenticationHeaders, + retryCount, + x509Headers, + x509Timeout: explicitTimeout ? options.timeout : void 0, + x509Tenant + }), + ...options.signal && { signal: options.signal }, + ...globalThis.ReadableStream && body instanceof globalThis.ReadableStream && { duplex: "half" }, + ...body && { body }, + ...(x509Authentication ? x509ClientFetchOptions : this.fetchOptions) ?? {}, + ...(x509Authentication ? x509RequestFetchOptions : options.fetchOptions) ?? {} + }, + url, + timeout: options.timeout + }; + } + async buildHeaders({ options, method, bodyHeaders, authenticationHeaders, retryCount, x509Headers, x509Timeout, x509Tenant }) { + let idempotencyHeaders = {}; + if (this.idempotencyHeader && method !== "get") { + if (!options.idempotencyKey) options.idempotencyKey = this.defaultIdempotencyKey(); + idempotencyHeaders[this.idempotencyHeader] = options.idempotencyKey; + } + const helperMethod = options.__metadata?.["helperMethod"]; + const timeout = x509Headers ? x509Timeout : options.timeout; + const headers = buildHeaders([ + idempotencyHeaders, + { + Accept: "application/json", + ...!isRunningInBrowserOrBrowserWorker() ? { "User-Agent": this.getUserAgent() } : void 0, + "X-Stainless-Retry-Count": String(retryCount), + ...timeout ? { "X-Stainless-Timeout": String(Math.trunc(timeout / 1e3)) } : {}, + ...getPlatformHeaders(), + ...typeof helperMethod === "string" ? { "X-Stainless-Helper-Method": helperMethod } : {}, + "OpenAI-Organization": x509Tenant ? x509Tenant.organization : this.organization, + "OpenAI-Project": x509Tenant ? x509Tenant.project : this.project + }, + __classPrivateFieldGet(this, _OpenAI_x509Authentication, "f") && !__classPrivateFieldGet(this, _OpenAI_x509Authentication, "f").isPlanningRequest() ? await this.authHeaders(options, options.__security ?? { bearerAuth: true }) : authenticationHeaders, + x509Headers?.defaultHeaders ?? this._options.defaultHeaders, + bodyHeaders, + x509Headers?.requestHeaders ?? options.headers + ]); + if (!this._provider && !__classPrivateFieldGet(this, _OpenAI_x509Authentication, "f")?.isPlanningRequest()) this.validateHeaders(headers, options.__security ?? { bearerAuth: true }); + return headers.values; + } + _makeAbort(controller) { + return () => controller.abort(); + } + _makeUserAbortError(signal) { + const error = new APIUserAbortError(); + Object.defineProperty(error, "cause", { + value: signal.reason, + writable: true, + configurable: true + }); + return error; + } + buildBody({ options }) { + const { body, headers: rawHeaders } = options; + if (!body) { + if (body === void 0 && "body" in options) return { + ...__classPrivateFieldGet(this, _OpenAI_encoder, "f").call(this, { + body, + headers: buildHeaders([rawHeaders]) + }), + isStreamingBody: false + }; + 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$1 = OpenAI, _OpenAI_encoder = /* @__PURE__ */ new WeakMap(), _OpenAI_x509Authentication = /* @__PURE__ */ new WeakMap(), _OpenAI_x509Credential = /* @__PURE__ */ new WeakMap(), _OpenAI_x509Fetch = /* @__PURE__ */ new WeakMap(), _OpenAI_explicitDataResidency = /* @__PURE__ */ new WeakMap(), _OpenAI_responseAttempts = /* @__PURE__ */ new WeakMap(), _OpenAI_instances = /* @__PURE__ */ new WeakSet(), _OpenAI_baseURLOverridden = function _OpenAI_baseURLOverridden() { + return __classPrivateFieldGet(this, _OpenAI_explicitDataResidency, "f") || this._provider !== void 0 || this.baseURL !== "https://api.openai.com/v1"; +}, _OpenAI_normalizeRetries = function _OpenAI_normalizeRetries(value) { + return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : 2; +}, _OpenAI_isSensitiveLogKey = function _OpenAI_isSensitiveLogKey(key) { + const normalized = key.replace(/[^a-z0-9]/gi, "").toLowerCase(); + return /authorization|authentication|cookie|session|signature|assertion|connectionstring|devicecode|codeverifier|accountkey|mtlskey|proxyauth|(?:api|access|secret|private|security|refresh|id|bearer|aws|azure|openai|admin|client|proxy|auth)[a-z0-9]*(?:key|token|secret|password|passwd|pwd|credential|auth)|^(?:auth|key|sig|sas|jwt|bearer|pfx|p12)$|(?:sid|token|secret|password|passwd|pwd|credential|passphrase|apikey|accesskey|privatekey|username)s?$/.test(normalized); +}, _OpenAI_sanitizeLogValue = function _OpenAI_sanitizeLogValue(value, seen) { + const maxDepth = 64; + const maxValues = 4096; + const redactString = (entry) => entry.replace(/((?:[a-z][a-z0-9+.-]*:)?\/\/)([^/\s?#]*@)(?=[^/\s?#]+)/gi, "$1[REDACTED]@").replace(/(^|[\s(=])([^/\s]+:[^/\s]*@)(?=[^/\s@]+)/gi, "$1[REDACTED]@").replace(/(^|[\s,;])([a-z][a-z0-9_-]*)(\s*:\s*)([^\r\n,;]+)/gi, (match, prefix, key, separator) => __classPrivateFieldGet(this, _OpenAI_instances, "m", _OpenAI_isSensitiveLogKey).call(this, key) ? `${prefix}${key}${separator}[REDACTED]` : match).replace(/(^|[?&#;])([^=&;\s?#/]+)=([^&;\s#]+)/g, (match, separator, key) => { + let decoded = key; + try { + decoded = globalThis.decodeURIComponent(key); + } catch {} + return __classPrivateFieldGet(this, _OpenAI_instances, "m", _OpenAI_isSensitiveLogKey).call(this, decoded) ? `${separator}${key}=[REDACTED]` : match; + }); + const getLogString = (entry) => { + try { + return globalThis.String.prototype.valueOf.call(entry); + } catch { + return; + } + }; + const isSensitiveLogLabel = (entry) => { + const label = getLogString(entry); + if (label !== void 0) return __classPrivateFieldGet(this, _OpenAI_instances, "m", _OpenAI_isSensitiveLogKey).call(this, label); + try { + return entry instanceof globalThis.String; + } catch { + return true; + } + }; + const pending = []; + const pendingMaps = []; + let sanitizedValue; + const getOwnLogDescriptor = (entry, key) => { + try { + return { + descriptor: globalThis.Object.getOwnPropertyDescriptor(entry, key), + failed: false + }; + } catch { + return { + descriptor: void 0, + failed: true + }; + } + }; + const enqueue = (entry, depth, assign) => { + if (depth > maxDepth || pending.length >= maxValues) { + assign("[REDACTED]"); + return; + } + pending.push({ + value: entry, + depth, + assign + }); + }; + enqueue(value, 0, (entry) => { + sanitizedValue = entry; + }); + for (let cursor = 0; cursor < pending.length; cursor += 1) { + const { value: current, depth, assign } = pending[cursor]; + if (typeof current === "string") { + assign(redactString(current)); + continue; + } + if (typeof current === "function" || typeof current === "symbol") { + assign("[REDACTED]"); + continue; + } + if (typeof current !== "object" || current === null) { + assign(current); + continue; + } + const previous = seen.get(current); + if (previous !== void 0) { + assign(previous); + continue; + } + try { + const boxedString = getLogString(current); + if (boxedString !== void 0) { + const sanitized = new globalThis.String(redactString(boxedString)); + seen.set(current, sanitized); + assign(sanitized); + continue; + } + if (current instanceof globalThis.String) { + seen.set(current, "[REDACTED]"); + assign("[REDACTED]"); + continue; + } + const RuntimeHeaders = globalThis.Headers; + if (typeof RuntimeHeaders === "function" && current instanceof RuntimeHeaders) { + const sanitized = new RuntimeHeaders(); + seen.set(current, sanitized); + assign(sanitized); + RuntimeHeaders.prototype.forEach.call(current, (entry, key) => { + sanitized.set(key, __classPrivateFieldGet(this, _OpenAI_instances, "m", _OpenAI_isSensitiveLogKey).call(this, key) ? "[REDACTED]" : redactString(entry)); + }); + continue; + } + if (current instanceof URL) { + const sanitized = new URL(URL.prototype.toString.call(current)); + seen.set(current, sanitized); + assign(sanitized); + if (sanitized.username) sanitized.username = "[REDACTED]"; + if (sanitized.password) sanitized.password = "[REDACTED]"; + for (const [key] of sanitized.searchParams) if (__classPrivateFieldGet(this, _OpenAI_instances, "m", _OpenAI_isSensitiveLogKey).call(this, key)) sanitized.searchParams.set(key, "[REDACTED]"); + if (sanitized.hash) sanitized.hash = redactString(sanitized.hash); + continue; + } + if (Array.isArray(current)) { + const lengthDescriptor = getOwnLogDescriptor(current, "length"); + if (lengthDescriptor.failed || !lengthDescriptor.descriptor || !("value" in lengthDescriptor.descriptor) || typeof lengthDescriptor.descriptor.value !== "number") { + seen.set(current, "[REDACTED]"); + assign("[REDACTED]"); + continue; + } + const sanitized = []; + seen.set(current, sanitized); + assign(sanitized); + const limit = Math.min(lengthDescriptor.descriptor.value, maxValues); + const firstDescriptor = getOwnLogDescriptor(current, "0"); + const firstKey = !firstDescriptor.failed && firstDescriptor.descriptor && "value" in firstDescriptor.descriptor ? firstDescriptor.descriptor.value : void 0; + for (let index = 0; index < limit; index += 1) { + const property = index === 0 ? firstDescriptor : getOwnLogDescriptor(current, `${index}`); + if (property.failed) { + sanitized[index] = "[REDACTED]"; + continue; + } + const descriptor = property.descriptor; + if (!descriptor?.enumerable) continue; + if (index === 1 && (firstDescriptor.failed || firstDescriptor.descriptor && !("value" in firstDescriptor.descriptor) || isSensitiveLogLabel(firstKey))) { + sanitized[index] = "[REDACTED]"; + continue; + } + if (!("value" in descriptor)) { + sanitized[index] = "[REDACTED]"; + continue; + } + enqueue(descriptor.value, depth + 1, (entry) => { + sanitized[index] = entry; + }); + } + sanitized.length = limit; + if (lengthDescriptor.descriptor.value > limit) sanitized[limit] = "[REDACTED]"; + continue; + } + if (current instanceof globalThis.Map) { + const sanitized = new globalThis.Map(); + const entries = []; + pendingMaps.push({ + map: sanitized, + entries + }); + seen.set(current, sanitized); + assign(sanitized); + globalThis.Map.prototype.forEach.call(current, (entry, key) => { + const pair = ["[REDACTED]", "[REDACTED]"]; + entries.push(pair); + enqueue(key, depth + 1, (safeKey) => { + if (typeof safeKey !== "function" && typeof safeKey !== "symbol" && !(typeof key === "object" && key !== null && safeKey === key)) pair[0] = safeKey; + }); + if (isSensitiveLogLabel(key)) return; + enqueue(entry, depth + 1, (safeEntry) => { + pair[1] = safeEntry; + }); + }); + continue; + } + if (current instanceof globalThis.Set) { + const sanitized = new globalThis.Set(); + seen.set(current, sanitized); + assign(sanitized); + globalThis.Set.prototype.forEach.call(current, (entry) => { + enqueue(entry, depth + 1, (safeEntry) => { + sanitized.add(safeEntry); + }); + }); + continue; + } + if (current instanceof globalThis.Date) { + assign(new globalThis.Date(globalThis.Date.prototype.getTime.call(current))); + continue; + } + const RuntimeReadableStream = globalThis.ReadableStream; + if (typeof RuntimeReadableStream === "function" && current instanceof RuntimeReadableStream || current instanceof globalThis.ArrayBuffer || globalThis.ArrayBuffer.isView(current)) { + seen.set(current, "[REDACTED]"); + assign("[REDACTED]"); + continue; + } + let keys; + try { + keys = globalThis.Reflect.ownKeys(current); + } catch { + seen.set(current, "[REDACTED]"); + assign("[REDACTED]"); + continue; + } + const sanitized = {}; + seen.set(current, sanitized); + assign(sanitized); + for (const key of keys) { + if (typeof key !== "string") continue; + const property = getOwnLogDescriptor(current, key); + if (property.failed) { + sanitized[key] = "[REDACTED]"; + continue; + } + const descriptor = property.descriptor; + if (!descriptor?.enumerable) continue; + if (__classPrivateFieldGet(this, _OpenAI_instances, "m", _OpenAI_isSensitiveLogKey).call(this, key)) { + sanitized[key] = "[REDACTED]"; + continue; + } + if (!("value" in descriptor)) { + sanitized[key] = "[REDACTED]"; + continue; + } + enqueue(descriptor.value, depth + 1, (safeEntry) => { + sanitized[key] = safeEntry; + }); + } + } catch { + seen.set(current, "[REDACTED]"); + assign("[REDACTED]"); + } + } + for (const { map, entries } of pendingMaps) for (const [key, entry] of entries) map.set(key, entry); + return sanitizedValue; +}, _OpenAI_sanitizeLogger = function _OpenAI_sanitizeLogger(logger) { + if (__classPrivateFieldGet(_a$1, _a$1, "f", _OpenAI_sanitizedLoggers).has(logger)) return logger; + const sanitized = new globalThis.Proxy(Object.create(null), { + get: (_facade, property) => { + const value = globalThis.Reflect.get(logger, property, logger); + if (typeof value !== "function") return value; + if (typeof property !== "string" || ![ + "debug", + "info", + "warn", + "error", + "trace", + "log" + ].includes(property)) return value.bind(logger); + return (...args) => { + const seen = /* @__PURE__ */ new WeakMap(); + return globalThis.Reflect.apply(value, logger, args.map((entry) => __classPrivateFieldGet(this, _OpenAI_instances, "m", _OpenAI_sanitizeLogValue).call(this, entry, seen))); + }; + }, + set: (_facade, property, value) => globalThis.Reflect.set(logger, property, value, logger) + }); + __classPrivateFieldGet(_a$1, _a$1, "f", _OpenAI_sanitizedLoggers).add(sanitized); + return sanitized; +}; +_OpenAI_sanitizedLoggers = { value: new globalThis.WeakSet() }; +OpenAI.OpenAI = _a$1; +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.toStreamingFile = toStreamingFile; +OpenAI.Decisions = Decisions; +OpenAI.Completions = Completions; +OpenAI.Chat = Chat; +OpenAI.Embeddings = Embeddings; +OpenAI.Files = Files$1; +OpenAI.Images = Images; +OpenAI.ContentProvenanceChecks = ContentProvenanceChecks; +OpenAI.Audio = Audio; +OpenAI.Moderations = Moderations; +OpenAI.Models = Models; +OpenAI.FineTuning = FineTuning; +OpenAI.Graders = Graders; +OpenAI.VectorStores = VectorStores; +OpenAI.Safety = Safety; +OpenAI.Webhooks = Webhooks; +OpenAI.Beta = Beta; +OpenAI.Batches = Batches; +OpenAI.Uploads = Uploads; +OpenAI.Admin = Admin; +OpenAI.Responses = Responses; +OpenAI.Live = Live; +OpenAI.Realtime = Realtime; +OpenAI.Conversations = Conversations; +OpenAI.Evals = Evals; +OpenAI.Containers = Containers; +OpenAI.Skills = Skills; +OpenAI.Videos = Videos; +OpenAI.ConversationCursorPage = ConversationCursorPage; +OpenAI.CursorPage = CursorPage; +OpenAI.NextCursorPage = NextCursorPage; +OpenAI.Page = Page; +OpenAI.TokenPage = TokenPage; +const composedCallerSignals = /* @__PURE__ */ new WeakMap(); +function createRequestController(callerSignal, originalSignal) { + const controller = new AbortController(); + if (!callerSignal) return controller; + const nativeAbortSignal = globalThis.AbortSignal; + if (typeof nativeAbortSignal?.any !== "function" || !(callerSignal instanceof nativeAbortSignal)) return controller; + try { + const signals = [controller.signal, callerSignal]; + if (originalSignal && originalSignal !== callerSignal) signals.push(originalSignal); + const composed = nativeAbortSignal.any(signals); + Object.defineProperty(controller, "signal", { + value: composed, + configurable: true + }); + composedCallerSignals.set(controller, callerSignal); + } catch {} + return controller; +} +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 +//#region main.ts +const DEFAULT_BASE_URL = "https://tokenhub.tencentmaas.com/v1"; +const DEFAULT_PROMPT_TEMPLATE = "将以下文本翻译为 {targetLang}，注意只需要输出翻译后的结果，不要额外解释：\n{sourceText}"; +function buildPrompt(prompt, targetLang, sourceText) { + const template = prompt && prompt.trim() ? prompt : DEFAULT_PROMPT_TEMPLATE; + const result = template.replaceAll("{targetLang}", targetLang); + return template.includes("{sourceText}") ? result.replaceAll("{sourceText}", sourceText) : `${result}：\n${sourceText}`; +} +function withTitle(title, translatedText) { + const trimmedTitle = title && title.trim() ? title.trim() : ""; + return trimmedTitle ? `# ${trimmedTitle}\n\n${translatedText}` : translatedText; +} +function parseIssueNumber(input) { + if (!input) return void 0; + const issueNumber = Number.parseInt(input, 10); + if (!Number.isInteger(issueNumber) || issueNumber <= 0) throw new Error(`Invalid issue-number "${input}"`); + return issueNumber; +} +async function translate(client, params) { + const { model, prompt } = params; + const translatedText = (await client.create({ + model, + messages: [{ + role: "user", + content: prompt + }] + })).choices[0]?.message?.content?.trim(); + if (!translatedText) throw new Error("Translation result is empty"); + return translatedText; +} +function createClient(options) { + const { apiKey, baseURL = DEFAULT_BASE_URL } = options; + return new OpenAI({ + apiKey, + baseURL + }).chat.completions; +} +async function postComment(issues, options) { + const { body, issueNumber, owner, repo } = options; + const { data } = await issues.createComment({ + body, + issue_number: issueNumber, + owner, + repo + }); + return data.id; +} +async function main() { + const apiKey = getInput("api-key", { required: true }); + const baseURL = getInput("base-url") || "https://tokenhub.tencentmaas.com/v1"; + const model = getInput("model") || "hy-mt2-plus"; + const targetLang = getInput("target-lang", { required: true }); + const sourceText = getInput("source-text", { required: true }); + const prompt = getInput("prompt"); + const title = getInput("title"); + const issueNumber = parseIssueNumber(getInput("issue-number")); + startGroup("ai-translate"); + info(`base-url: ${baseURL}`); + info(`model: ${model}`); + info(`target-lang: ${targetLang}`); + info(`source-text length: ${sourceText.length}`); + if (issueNumber) info(`issue-number: ${issueNumber}`); + endGroup(); + const content = withTitle(title, await translate(createClient({ + apiKey, + baseURL + }), { + model, + prompt: buildPrompt(prompt, targetLang, sourceText) + })); + info("Translation succeeded"); + setOutput("translated-text", content); + if (!issueNumber) return; + const token = getInput("token"); + const owner = getInput("owner") || context.repo.owner; + const repo = getInput("repo") || context.repo.repo; + const commentId = await postComment(getOctokit(token).rest.issues, { + body: content, + issueNumber, + owner, + repo + }); + info(`Comment created: ${commentId}`); + setOutput("comment-id", String(commentId)); +} +//#endregion +//#region index.ts +main().catch((error) => { + setFailed(`ai-translate failed: ${error instanceof Error ? error.message : String(error)}`); +}); +//#endregion +export {}; diff --git a/actions/ai-translate/index.ts b/actions/ai-translate/index.ts new file mode 100644 index 0000000..7dfa9ba --- /dev/null +++ b/actions/ai-translate/index.ts @@ -0,0 +1,6 @@ +import * as core from '@actions/core' +import { main } from './main' + +main().catch((error) => { + core.setFailed(`ai-translate failed: ${error instanceof Error ? error.message : String(error)}`) +}) diff --git a/actions/ai-translate/main.test.ts b/actions/ai-translate/main.test.ts new file mode 100644 index 0000000..0b7a1e7 --- /dev/null +++ b/actions/ai-translate/main.test.ts @@ -0,0 +1,236 @@ +import * as core from '@actions/core' +import * as github from '@actions/github' +import { beforeEach, describe, expect, it, vi } from 'vitest' +import { + buildPrompt, + DEFAULT_BASE_URL, + DEFAULT_MODEL, + DEFAULT_PROMPT_TEMPLATE, + main, + parseIssueNumber, + postComment, + translate, + withTitle, +} from './main' + +vi.mock('@actions/core', () => ({ + endGroup: vi.fn(), + getInput: vi.fn(), + info: vi.fn(), + setFailed: vi.fn(), + setOutput: vi.fn(), + startGroup: vi.fn(), +})) + +vi.mock('@actions/github', () => ({ + context: { + repo: { + owner: 'Tencent', + repo: 'workflows', + }, + }, + getOctokit: vi.fn(), +})) + +vi.mock('openai', () => ({ + default: class MockOpenAI { + constructor(public options: { apiKey: string, baseURL?: string }) {} + + chat = { + completions: { + create: vi.fn().mockResolvedValue({ + choices: [{ message: { content: 'Please make sure all attendees have received the agenda before the meeting starts.' } }], + }), + }, + } + }, +})) + +const TRANSLATED_TEXT = 'Please make sure all attendees have received the agenda before the meeting starts.' + +function createClient() { + return { + create: vi.fn().mockResolvedValue({ + choices: [{ message: { content: 'translated text' } }], + }), + } +} + +function mockInputs(overrides: Record = {}) { + vi.mocked(core.getInput).mockImplementation((name: string) => { + const inputs: Record = { + 'api-key': 'test-api-key', + 'base-url': '', + 'model': '', + 'target-lang': '英语', + 'source-text': '会议开始前请确认所有参会人员都收到了议程。', + 'prompt': '', + 'title': '', + 'issue-number': '', + 'token': 'gh-token', + 'owner': '', + 'repo': '', + ...overrides, + } + return inputs[name] ?? '' + }) +} + +function mockOctokit() { + const createComment = vi.fn().mockResolvedValue({ data: { id: 4242 } }) + vi.mocked(github.getOctokit).mockReturnValue({ + rest: { + issues: { createComment }, + }, + } as unknown as ReturnType) + return createComment +} + +describe('ai-translate', () => { + beforeEach(() => { + vi.clearAllMocks() + vi.mocked(github.getOctokit).mockReset() + mockInputs() + }) + + it('默认模板拼接 prompt', () => { + expect(buildPrompt(undefined, '英语', '你好')).toBe( + '将以下文本翻译为 英语，注意只需要输出翻译后的结果，不要额外解释：\n你好', + ) + expect(buildPrompt('', '英语', '你好')).toBe(DEFAULT_PROMPT_TEMPLATE.replaceAll('{targetLang}', '英语').replaceAll('{sourceText}', '你好')) + expect(buildPrompt(' ', '英语', '你好')).toBe( + '将以下文本翻译为 英语，注意只需要输出翻译后的结果，不要额外解释：\n你好', + ) + }) + + it('自定义 prompt 支持占位符', () => { + expect(buildPrompt('Translate the text below to {targetLang}:\n{sourceText}', 'English', 'hello')).toBe( + 'Translate the text below to English:\nhello', + ) + expect(buildPrompt('翻译为{targetLang}', '英语', '你好')).toBe('翻译为英语：\n你好') + }) + + it('自定义 prompt 无占位符时追加原文', () => { + expect(buildPrompt('你是一个专业译员，请忠实地完成翻译任务', '英语', '你好')).toBe( + '你是一个专业译员，请忠实地完成翻译任务：\n你好', + ) + }) + + it('withTitle 拼接标题头', () => { + expect(withTitle('会议确认', TRANSLATED_TEXT)).toBe(`# 会议确认\n\n${TRANSLATED_TEXT}`) + expect(withTitle(' 会议确认 ', TRANSLATED_TEXT)).toBe(`# 会议确认\n\n${TRANSLATED_TEXT}`) + expect(withTitle(undefined, TRANSLATED_TEXT)).toBe(TRANSLATED_TEXT) + expect(withTitle('', TRANSLATED_TEXT)).toBe(TRANSLATED_TEXT) + expect(withTitle(' ', TRANSLATED_TEXT)).toBe(TRANSLATED_TEXT) + }) + + it('parseIssueNumber 校验 issue 编号', () => { + expect(parseIssueNumber('')).toBeUndefined() + expect(parseIssueNumber('42')).toBe(42) + expect(() => parseIssueNumber('abc')).toThrow('Invalid issue-number "abc"') + expect(() => parseIssueNumber('0')).toThrow('Invalid issue-number "0"') + expect(() => parseIssueNumber('-1')).toThrow('Invalid issue-number "-1"') + }) + + it('调用 chat.completions 并返回译文', async () => { + const client = createClient() + + await expect(translate(client, { model: 'hy-mt2-plus', prompt: 'prompt' })).resolves.toBe('translated text') + + expect(client.create).toHaveBeenCalledWith({ + model: 'hy-mt2-plus', + messages: [{ role: 'user', content: 'prompt' }], + }) + }) + + it('译文为空时抛错', async () => { + const client = createClient() + client.create.mockResolvedValueOnce({ choices: [{ message: { content: '' } }] }) + await expect(translate(client, { model: 'hy-mt2-plus', prompt: 'prompt' })).rejects.toThrow('Translation result is empty') + + client.create.mockResolvedValueOnce({ choices: [{ message: { content: null } }] }) + await expect(translate(client, { model: 'hy-mt2-plus', prompt: 'prompt' })).rejects.toThrow('Translation result is empty') + + client.create.mockResolvedValueOnce({ choices: [] }) + await expect(translate(client, { model: 'hy-mt2-plus', prompt: 'prompt' })).rejects.toThrow('Translation result is empty') + }) + + it('postComment 创建评论并返回评论 ID', async () => { + const issues = { + createComment: vi.fn().mockResolvedValue({ data: { id: 4242 } }), + } + + await expect(postComment(issues, { + body: 'body', + issueNumber: 12, + owner: 'Tencent', + repo: 'workflows', + })).resolves.toBe(4242) + + expect(issues.createComment).toHaveBeenCalledWith({ + body: 'body', + issue_number: 12, + owner: 'Tencent', + repo: 'workflows', + }) + }) + + it('main 使用默认 base-url 和 model 并输出译文', async () => { + await main() + + expect(core.startGroup).toHaveBeenCalledWith('ai-translate') + expect(core.info).toHaveBeenCalledWith(`base-url: ${DEFAULT_BASE_URL}`) + expect(core.info).toHaveBeenCalledWith(`model: ${DEFAULT_MODEL}`) + expect(core.info).not.toHaveBeenCalledWith(expect.stringContaining('test-api-key')) + expect(core.setOutput).toHaveBeenCalledWith('translated-text', TRANSLATED_TEXT) + expect(github.getOctokit).not.toHaveBeenCalled() + expect(core.setOutput).not.toHaveBeenCalledWith('comment-id', expect.anything()) + }) + + it('main 未提供 issue-number 时不发评论', async () => { + mockInputs({ title: '会议确认' }) + await main() + + expect(github.getOctokit).not.toHaveBeenCalled() + expect(core.setOutput).toHaveBeenCalledWith('translated-text', `# 会议确认\n\n${TRANSLATED_TEXT}`) + }) + + it('main 提供标题头和 issue-number 时发评论', async () => { + const createComment = mockOctokit() + mockInputs({ 'title': '会议确认', 'issue-number': '12', 'owner': 'Tencent', 'repo': 'tdesign' }) + + await main() + + const content = `# 会议确认\n\n${TRANSLATED_TEXT}` + expect(github.getOctokit).toHaveBeenCalledWith('gh-token') + expect(createComment).toHaveBeenCalledWith({ + body: content, + issue_number: 12, + owner: 'Tencent', + repo: 'tdesign', + }) + expect(core.setOutput).toHaveBeenCalledWith('translated-text', content) + expect(core.setOutput).toHaveBeenCalledWith('comment-id', '4242') + }) + + it('main 未提供 owner/repo 时使用当前仓库', async () => { + const createComment = mockOctokit() + mockInputs({ 'issue-number': '12' }) + + await main() + + expect(createComment).toHaveBeenCalledWith({ + body: TRANSLATED_TEXT, + issue_number: 12, + owner: 'Tencent', + repo: 'workflows', + }) + }) + + it('main 提供非法 issue-number 时抛错', async () => { + mockInputs({ 'issue-number': 'abc' }) + + await expect(main()).rejects.toThrow('Invalid issue-number "abc"') + expect(github.getOctokit).not.toHaveBeenCalled() + }) +}) diff --git a/actions/ai-translate/main.ts b/actions/ai-translate/main.ts new file mode 100644 index 0000000..c5ccae1 --- /dev/null +++ b/actions/ai-translate/main.ts @@ -0,0 +1,136 @@ +import * as core from '@actions/core' +import * as github from '@actions/github' +import OpenAI from 'openai' + +export const DEFAULT_BASE_URL = 'https://tokenhub.tencentmaas.com/v1' +export const DEFAULT_MODEL = 'hy-mt2-plus' +export const DEFAULT_PROMPT_TEMPLATE = '将以下文本翻译为 {targetLang}，注意只需要输出翻译后的结果，不要额外解释：\n{sourceText}' + +export interface TranslateParams { + model: string + prompt: string +} + +export interface ChatCompletionsApi { + create: (params: { model: string, messages: { role: 'user', content: string }[] }) => Promise<{ + choices: { message?: { content?: string | null } }[] + }> +} + +export interface CreateClientOptions { + apiKey: string + baseURL?: string +} + +export interface CreateCommentApi { + createComment: (params: { body: string, issue_number: number, owner: string, repo: string }) => Promise<{ data: { id: number } }> +} + +export interface PostCommentOptions { + body: string + issueNumber: number + owner: string + repo: string +} + +export function buildPrompt(prompt: string | undefined, targetLang: string, sourceText: string): string { + const template = prompt && prompt.trim() ? prompt : DEFAULT_PROMPT_TEMPLATE + const result = template.replaceAll('{targetLang}', targetLang) + + return template.includes('{sourceText}') + ? result.replaceAll('{sourceText}', sourceText) + : `${result}：\n${sourceText}` +} + +export function withTitle(title: string | undefined, translatedText: string): string { + const trimmedTitle = title && title.trim() ? title.trim() : '' + + return trimmedTitle ? `# ${trimmedTitle}\n\n${translatedText}` : translatedText +} + +export function parseIssueNumber(input: string): number | undefined { + if (!input) + return undefined + + const issueNumber = Number.parseInt(input, 10) + if (!Number.isInteger(issueNumber) || issueNumber <= 0) + throw new Error(`Invalid issue-number "${input}"`) + + return issueNumber +} + +export async function translate(client: ChatCompletionsApi, params: TranslateParams): Promise { + const { model, prompt } = params + + const response = await client.create({ + model, + messages: [{ role: 'user', content: prompt }], + }) + + const translatedText = response.choices[0]?.message?.content?.trim() + if (!translatedText) + throw new Error('Translation result is empty') + + return translatedText +} + +export function createClient(options: CreateClientOptions): ChatCompletionsApi { + const { apiKey, baseURL = DEFAULT_BASE_URL } = options + const client = new OpenAI({ apiKey, baseURL }) + return client.chat.completions +} + +export async function postComment(issues: CreateCommentApi, options: PostCommentOptions): Promise { + const { body, issueNumber, owner, repo } = options + const { data } = await issues.createComment({ + body, + issue_number: issueNumber, + owner, + repo, + }) + return data.id +} + +export async function main(): Promise { + const apiKey = core.getInput('api-key', { required: true }) + const baseURL = core.getInput('base-url') || DEFAULT_BASE_URL + const model = core.getInput('model') || DEFAULT_MODEL + const targetLang = core.getInput('target-lang', { required: true }) + const sourceText = core.getInput('source-text', { required: true }) + const prompt = core.getInput('prompt') + const title = core.getInput('title') + const issueNumber = parseIssueNumber(core.getInput('issue-number')) + + core.startGroup('ai-translate') + core.info(`base-url: ${baseURL}`) + core.info(`model: ${model}`) + core.info(`target-lang: ${targetLang}`) + core.info(`source-text length: ${sourceText.length}`) + if (issueNumber) + core.info(`issue-number: ${issueNumber}`) + core.endGroup() + + const translatedText = await translate(createClient({ apiKey, baseURL }), { + model, + prompt: buildPrompt(prompt, targetLang, sourceText), + }) + const content = withTitle(title, translatedText) + core.info('Translation succeeded') + core.setOutput('translated-text', content) + + if (!issueNumber) + return + + const token = core.getInput('token') + const owner = core.getInput('owner') || github.context.repo.owner + const repo = core.getInput('repo') || github.context.repo.repo + const octokit = github.getOctokit(token) + const commentId = await postComment(octokit.rest.issues, { + body: content, + issueNumber, + owner, + repo, + }) + core.info(`Comment created: ${commentId}`) + core.setOutput('comment-id', String(commentId)) +} diff --git a/actions/ai-translate/package.json b/actions/ai-translate/package.json new file mode 100644 index 0000000..11afe25 --- /dev/null +++ b/actions/ai-translate/package.json @@ -0,0 +1,17 @@ +{ + "name": "ai-translate", + "type": "module", + "main": "index.ts", + "scripts": { + "build": "tsdown" + }, + "dependencies": { + "@actions/core": "catalog:", + "@actions/github": "catalog:", + "openai": "catalog:" + }, + "devDependencies": { + "@types/node": "catalog:", + "tsdown": "catalog:" + } +} diff --git a/actions/ai-translate/tsdown.config.ts b/actions/ai-translate/tsdown.config.ts new file mode 100644 index 0000000..589b304 --- /dev/null +++ b/actions/ai-translate/tsdown.config.ts @@ -0,0 +1,29 @@ +import { defineConfig } from 'tsdown' + +export default defineConfig({ + entry: ['index.ts'], + deps: { + alwaysBundle: ['@actions/core', '@actions/github', 'openai'], + onlyBundle: [ + '@actions/core', + '@actions/exec', + '@actions/github', + '@actions/http-client', + '@actions/io', + '@octokit/auth-token', + '@octokit/core', + '@octokit/endpoint', + '@octokit/graphql', + '@octokit/plugin-paginate-rest', + '@octokit/plugin-rest-endpoint-methods', + '@octokit/request', + '@octokit/request-error', + 'before-after-hook', + 'fast-content-type-parse', + 'openai', + 'tunnel', + 'undici', + 'universal-user-agent', + ], + }, +}) diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index c21c4c5..3f5cfe8 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -191,6 +191,9 @@ catalogs: jsonc-parser: specifier: ^3.3.1 version: 3.3.1 + openai: + specifier: ^7.34.0 + version: 7.34.0 tsdown: specifier: ^0.23.1 version: 0.23.1 @@ -218,6 +221,25 @@ importers: specifier: 'catalog:' version: 5.0.3(@types/node@26.5.1)(vite@8.0.13(@types/node@26.5.1)(yaml@2.9.1)) + actions/ai-translate: + dependencies: + '@actions/core': + specifier: 'catalog:' + version: 3.0.1 + '@actions/github': + specifier: 'catalog:' + version: 9.1.1 + openai: + specifier: 'catalog:' + version: 7.34.0(undici@6.23.0) + devDependencies: + '@types/node': + specifier: 'catalog:' + version: 24.19.2 + tsdown: + specifier: 'catalog:' + version: 0.23.1(@typescript/native-preview@7.0.0-dev.20260707.2)(typescript@5.9.3) + actions/close-release-issue: dependencies: '@actions/core': @@ -2048,6 +2070,30 @@ packages: resolution: {integrity: sha512-5vvB5+W7ePv+p3uqxi+RcW1XAzLW0/hxt3/4X4Lc4qHudzOhmBiBwOY6DRob4WnanAEGvNcLjF+KNOufrUoEQw==} engines: {node: '>=12.20.0'} + openai@7.34.0: + resolution: {integrity: sha512-PMwuTQ/3cVyWZJOVpb6bzlrQj17uImlnUGQWqh5zHlN/snwK5ww4ZUHW8NYGtH6f9PQOEPxyD/f8WJVIHp1q2A==} + engines: {node: '>=22.0.0'} + peerDependencies: + '@aws-sdk/credential-provider-node': '>=3.972.0 <4' + '@smithy/hash-node': '>=4.3.0 <5' + '@smithy/signature-v4': '>=5.4.0 <6' + undici: '>=5 <9' + ws: ^8.21.0 + zod: ^3.25 || ^4.0 + peerDependenciesMeta: + '@aws-sdk/credential-provider-node': + optional: true + '@smithy/hash-node': + optional: true + '@smithy/signature-v4': + optional: true + undici: + optional: true + ws: + optional: true + zod: + optional: true + optionator@0.9.4: resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==} engines: {node: '>= 0.8.0'} @@ -4331,6 +4377,10 @@ snapshots: obug@3.0.0: {} + openai@7.34.0(undici@6.23.0): + optionalDependencies: + undici: 6.23.0 + optionator@0.9.4: dependencies: deep-is: 0.1.4 diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml index 12c2d90..f620ccb 100644 --- a/pnpm-workspace.yaml +++ b/pnpm-workspace.yaml @@ -22,6 +22,7 @@ catalog: '@typescript/native-preview': 7.0.0-dev.20260707.2 eslint: ^10.12.0 jsonc-parser: ^3.3.1 + openai: ^7.34.0 tsdown: ^0.23.1 vitest: ^5.0.3 yaml: ^2.9.1