codex-subscription-oauth-plugin 0.1.1

package/lib/openai-codex-responses-DPxdQtbt.js

@@ -0,0 +1,2827 @@
+import { n as __commonJSMin, t as getProviderEnvValue } from "./provider-env-DRzE1dvc.js";
+import { a as appendAssistantMessageDiagnostic, l as AssistantMessageEventStream, n as clampThinkingLevel, o as createAssistantMessageDiagnostic, s as formatThrownValue, t as calculateCost } from "./models-DaqoXO5b.js";
+//#region node_modules/@earendil-works/pi-ai/dist/session-resources.js
+const sessionResourceCleanups = /* @__PURE__ */ new Set();
+function registerSessionResourceCleanup(cleanup) {
+	sessionResourceCleanups.add(cleanup);
+	return () => {
+		sessionResourceCleanups.delete(cleanup);
+	};
+}
+//#endregion
+//#region node_modules/partial-json/dist/options.js
+var require_options = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Sometimes you don't allow every type to be partially parsed.
+	* For example, you may not want a partial number because it may increase its size gradually before it's complete.
+	* In this case, you can use the `Allow` object to control what types you allow to be partially parsed.
+	* @module
+	*/
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Allow = exports.ALL = exports.COLLECTION = exports.ATOM = exports.SPECIAL = exports.INF = exports._INFINITY = exports.INFINITY = exports.NAN = exports.BOOL = exports.NULL = exports.OBJ = exports.ARR = exports.NUM = exports.STR = void 0;
+	/**
+	* allow partial strings like `"hello \u12` to be parsed as `"hello "`
+	*/
+	exports.STR = 1;
+	/**
+	* allow partial numbers like `123.` to be parsed as `123`
+	*/
+	exports.NUM = 2;
+	/**
+	* allow partial arrays like `[1, 2,` to be parsed as `[1, 2]`
+	*/
+	exports.ARR = 4;
+	/**
+	* allow partial objects like `{"a": 1, "b":` to be parsed as `{"a": 1}`
+	*/
+	exports.OBJ = 8;
+	/**
+	* allow `nu` to be parsed as `null`
+	*/
+	exports.NULL = 16;
+	/**
+	* allow `tr` to be parsed as `true`, and `fa` to be parsed as `false`
+	*/
+	exports.BOOL = 32;
+	/**
+	* allow `Na` to be parsed as `NaN`
+	*/
+	exports.NAN = 64;
+	/**
+	* allow `Inf` to be parsed as `Infinity`
+	*/
+	exports.INFINITY = 128;
+	/**
+	* allow `-Inf` to be parsed as `-Infinity`
+	*/
+	exports._INFINITY = 256;
+	exports.INF = exports.INFINITY | exports._INFINITY;
+	exports.SPECIAL = exports.NULL | exports.BOOL | exports.INF | exports.NAN;
+	exports.ATOM = exports.STR | exports.NUM | exports.SPECIAL;
+	exports.COLLECTION = exports.ARR | exports.OBJ;
+	exports.ALL = exports.ATOM | exports.COLLECTION;
+	/**
+	* Control what types you allow to be partially parsed.
+	* The default is to allow all types to be partially parsed, which in most casees is the best option.
+	* @example
+	* If you don't want to allow partial objects, you can use the following code:
+	* ```ts
+	* import { Allow, parse } from "partial-json";
+	* parse(`[{"a": 1, "b": 2}, {"a": 3,`, Allow.ARR); // [ { a: 1, b: 2 } ]
+	* ```
+	* Or you can use `~` to disallow a type:
+	* ```ts
+	* parse(`[{"a": 1, "b": 2}, {"a": 3,`, ~Allow.OBJ); // [ { a: 1, b: 2 } ]
+	* ```
+	* @example
+	* If you don't want to allow partial strings, you can use the following code:
+	* ```ts
+	* import { Allow, parse } from "partial-json";
+	* parse(`["complete string", "incompl`, ~Allow.STR); // [ 'complete string' ]
+	* ```
+	*/
+	exports.Allow = {
+		STR: exports.STR,
+		NUM: exports.NUM,
+		ARR: exports.ARR,
+		OBJ: exports.OBJ,
+		NULL: exports.NULL,
+		BOOL: exports.BOOL,
+		NAN: exports.NAN,
+		INFINITY: exports.INFINITY,
+		_INFINITY: exports._INFINITY,
+		INF: exports.INF,
+		SPECIAL: exports.SPECIAL,
+		ATOM: exports.ATOM,
+		COLLECTION: exports.COLLECTION,
+		ALL: exports.ALL
+	};
+	exports.default = exports.Allow;
+}));
+//#endregion
+//#region node_modules/@earendil-works/pi-ai/dist/utils/json-parse.js
+var import_dist = (/* @__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 __exportStar = exports && exports.__exportStar || function(m, exports$1) {
+		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1, p)) __createBinding(exports$1, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Allow = exports.MalformedJSON = exports.PartialJSON = exports.parseJSON = exports.parse = void 0;
+	const options_1 = require_options();
+	Object.defineProperty(exports, "Allow", {
+		enumerable: true,
+		get: function() {
+			return options_1.Allow;
+		}
+	});
+	__exportStar(require_options(), exports);
+	var PartialJSON = class extends Error {};
+	exports.PartialJSON = PartialJSON;
+	var MalformedJSON = class extends Error {};
+	exports.MalformedJSON = MalformedJSON;
+	/**
+	* 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 = options_1.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);
+	}
+	exports.parseJSON = parseJSON;
+	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" || options_1.Allow.NULL & allow && length - index < 4 && "null".startsWith(jsonString.substring(index))) {
+				index += 4;
+				return null;
+			}
+			if (jsonString.substring(index, index + 4) === "true" || options_1.Allow.BOOL & allow && length - index < 4 && "true".startsWith(jsonString.substring(index))) {
+				index += 4;
+				return true;
+			}
+			if (jsonString.substring(index, index + 5) === "false" || options_1.Allow.BOOL & allow && length - index < 5 && "false".startsWith(jsonString.substring(index))) {
+				index += 5;
+				return false;
+			}
+			if (jsonString.substring(index, index + 8) === "Infinity" || options_1.Allow.INFINITY & allow && length - index < 8 && "Infinity".startsWith(jsonString.substring(index))) {
+				index += 8;
+				return Infinity;
+			}
+			if (jsonString.substring(index, index + 9) === "-Infinity" || options_1.Allow._INFINITY & allow && 1 < length - index && length - index < 9 && "-Infinity".startsWith(jsonString.substring(index))) {
+				index += 9;
+				return -Infinity;
+			}
+			if (jsonString.substring(index, index + 3) === "NaN" || options_1.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 (options_1.Allow.STR & allow) try {
+				return JSON.parse(jsonString.substring(start, index - Number(escape)) + "\"");
+			} catch (e) {
+				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 && options_1.Allow.OBJ & allow) return obj;
+					const key = parseStr();
+					skipBlank();
+					index++;
+					try {
+						obj[key] = parseAny();
+					} catch (e) {
+						if (options_1.Allow.OBJ & allow) return obj;
+						else throw e;
+					}
+					skipBlank();
+					if (jsonString[index] === ",") index++;
+				}
+			} catch (e) {
+				if (options_1.Allow.OBJ & allow) return obj;
+				else 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 (e) {
+				if (options_1.Allow.ARR & allow) return arr;
+				markPartialJSON("Expected ']' at end of array");
+			}
+			index++;
+			return arr;
+		};
+		const parseNum = () => {
+			if (index === 0) {
+				if (jsonString === "-") throwMalformedError("Not sure what '-' is");
+				try {
+					return JSON.parse(jsonString);
+				} catch (e) {
+					if (options_1.Allow.NUM & allow) try {
+						return JSON.parse(jsonString.substring(0, jsonString.lastIndexOf("e")));
+					} catch (e) {}
+					throwMalformedError(String(e));
+				}
+			}
+			const start = index;
+			if (jsonString[index] === "-") index++;
+			while (jsonString[index] && ",]}".indexOf(jsonString[index]) === -1) index++;
+			if (index == length && !(options_1.Allow.NUM & allow)) markPartialJSON("Unterminated number literal");
+			try {
+				return JSON.parse(jsonString.substring(start, index));
+			} catch (e) {
+				if (jsonString.substring(start, index) === "-") markPartialJSON("Not sure what '-' is");
+				try {
+					return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf("e")));
+				} catch (e) {
+					throwMalformedError(String(e));
+				}
+			}
+		};
+		const skipBlank = () => {
+			while (index < length && " \n\r	".includes(jsonString[index])) index++;
+		};
+		return parseAny();
+	};
+	exports.parse = parseJSON;
+})))();
+const VALID_JSON_ESCAPES = /* @__PURE__ */ new Set([
+	"\"",
+	"\\",
+	"/",
+	"b",
+	"f",
+	"n",
+	"r",
+	"t",
+	"u"
+]);
+function isControlCharacter(char) {
+	const codePoint = char.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 0 && codePoint <= 31;
+}
+function escapeControlCharacter(char) {
+	switch (char) {
+		case "\b": return "\\b";
+		case "\f": return "\\f";
+		case "\n": return "\\n";
+		case "\r": return "\\r";
+		case "	": return "\\t";
+		default: return `\\u${char.codePointAt(0)?.toString(16).padStart(4, "0") ?? "0000"}`;
+	}
+}
+/**
+* Repairs malformed JSON string literals by:
+* - escaping raw control characters inside strings
+* - doubling backslashes before invalid escape characters
+*/
+function repairJson(json) {
+	let repaired = "";
+	let inString = false;
+	for (let index = 0; index < json.length; index++) {
+		const char = json[index];
+		if (!inString) {
+			repaired += char;
+			if (char === "\"") inString = true;
+			continue;
+		}
+		if (char === "\"") {
+			repaired += char;
+			inString = false;
+			continue;
+		}
+		if (char === "\\") {
+			const nextChar = json[index + 1];
+			if (nextChar === void 0) {
+				repaired += "\\\\";
+				continue;
+			}
+			if (nextChar === "u") {
+				const unicodeDigits = json.slice(index + 2, index + 6);
+				if (/^[0-9a-fA-F]{4}$/.test(unicodeDigits)) {
+					repaired += `\\u${unicodeDigits}`;
+					index += 5;
+					continue;
+				}
+			}
+			if (VALID_JSON_ESCAPES.has(nextChar)) {
+				repaired += `\\${nextChar}`;
+				index += 1;
+				continue;
+			}
+			repaired += "\\\\";
+			continue;
+		}
+		repaired += isControlCharacter(char) ? escapeControlCharacter(char) : char;
+	}
+	return repaired;
+}
+function parseJsonWithRepair(json) {
+	try {
+		return JSON.parse(json);
+	} catch (error) {
+		const repairedJson = repairJson(json);
+		if (repairedJson !== json) return JSON.parse(repairedJson);
+		throw error;
+	}
+}
+/**
+* Attempts to parse potentially incomplete JSON during streaming.
+* Always returns a valid object, even if the JSON is incomplete.
+*
+* @param partialJson The partial JSON string from streaming
+* @returns Parsed object or empty object if parsing fails
+*/
+function parseStreamingJson(partialJson) {
+	if (!partialJson || partialJson.trim() === "") return {};
+	try {
+		return parseJsonWithRepair(partialJson);
+	} catch {
+		try {
+			return (0, import_dist.parse)(partialJson) ?? {};
+		} catch {
+			try {
+				return (0, import_dist.parse)(repairJson(partialJson)) ?? {};
+			} catch {
+				return {};
+			}
+		}
+	}
+}
+//#endregion
+//#region node_modules/@earendil-works/pi-ai/dist/utils/uuid.js
+const MAX_UUID_V7_TIMESTAMP = 0xffffffffffff;
+const MAX_SEQUENCE = (1n << 41n) - 1n;
+let lastOrdinaryTimestamp = -1;
+let sequence;
+/** Generate a time-ordered UUIDv7. A supplied timestamp is preserved for follower ids. */
+function uuidv7(timestampMs) {
+	const requestedTimestamp = timestampMs ?? Date.now();
+	if (!Number.isInteger(requestedTimestamp) || requestedTimestamp < 0 || requestedTimestamp > MAX_UUID_V7_TIMESTAMP) throw new RangeError(`UUIDv7 timestamp must be an integer between 0 and ${MAX_UUID_V7_TIMESTAMP}`);
+	const effectiveTimestamp = timestampMs === void 0 ? Math.max(requestedTimestamp, lastOrdinaryTimestamp) : timestampMs;
+	if (timestampMs === void 0) lastOrdinaryTimestamp = effectiveTimestamp;
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	globalThis.crypto.getRandomValues(bytes);
+	if (sequence === void 0) sequence = BigInt(bytes[1]) << 32n | BigInt(bytes[2]) << 24n | BigInt(bytes[3]) << 16n | BigInt(bytes[4]) << 8n | BigInt(bytes[5]);
+	else {
+		if (sequence === MAX_SEQUENCE) throw new RangeError("UUIDv7 generator sequence exhausted");
+		sequence++;
+	}
+	const timestamp = BigInt(effectiveTimestamp);
+	for (let index = 5; index >= 0; index--) bytes[index] = Number(timestamp >> BigInt((5 - index) * 8)) & 255;
+	bytes[6] = 112 | Number(sequence >> 37n & 15n);
+	bytes[7] = Number(sequence >> 29n & 255n);
+	bytes[8] = 128 | Number(sequence >> 23n & 63n);
+	bytes[9] = Number(sequence >> 15n & 255n);
+	bytes[10] = Number(sequence >> 7n & 255n);
+	bytes[11] = Number((sequence & 127n) << 1n) | bytes[11] & 1;
+	const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0"));
+	return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10).join("")}`;
+}
+//#endregion
+//#region node_modules/@earendil-works/pi-ai/dist/utils/abort-signals.js
+function combineAbortSignals(signals) {
+	const activeSignals = signals.filter((signal) => signal !== void 0);
+	if (activeSignals.length === 0) return { cleanup: () => {} };
+	if (activeSignals.length === 1) return {
+		signal: activeSignals[0],
+		cleanup: () => {}
+	};
+	const controller = new AbortController();
+	const listeners = [];
+	const abort = (signal) => {
+		if (!controller.signal.aborted) controller.abort(signal.reason);
+	};
+	for (const signal of activeSignals) {
+		if (signal.aborted) {
+			abort(signal);
+			break;
+		}
+		const listener = () => abort(signal);
+		signal.addEventListener("abort", listener, { once: true });
+		listeners.push({
+			signal,
+			listener
+		});
+	}
+	return {
+		signal: controller.signal,
+		cleanup: () => {
+			for (const { signal, listener } of listeners) signal.removeEventListener("abort", listener);
+		}
+	};
+}
+//#endregion
+//#region node_modules/@earendil-works/pi-ai/dist/utils/deferred-tools.js
+const identityToolName = (name) => name;
+/** Split current tools into prefix and transcript-loaded definitions. */
+function splitDeferredTools(context, enabled, normalizeName = identityToolName) {
+	const uniqueTools = /* @__PURE__ */ new Map();
+	for (const tool of context.tools ?? []) uniqueTools.set(normalizeName(tool.name), tool);
+	if (!enabled) return {
+		immediate: [...uniqueTools.values()],
+		deferred: /* @__PURE__ */ new Map()
+	};
+	const deferredNames = /* @__PURE__ */ new Set();
+	const usedNames = /* @__PURE__ */ new Set();
+	for (const message of context.messages) if (message.role === "assistant") {
+		for (const block of message.content) if (block.type === "toolCall") usedNames.add(normalizeName(block.name));
+	} else if (message.role === "toolResult") for (const name of message.addedToolNames ?? []) {
+		const normalizedName = normalizeName(name);
+		if (!usedNames.has(normalizedName)) deferredNames.add(normalizedName);
+	}
+	const immediate = [];
+	const deferred = /* @__PURE__ */ new Map();
+	for (const [name, tool] of uniqueTools) if (deferredNames.has(name)) deferred.set(name, tool);
+	else immediate.push(tool);
+	return {
+		immediate,
+		deferred
+	};
+}
+//#endregion
+//#region node_modules/@earendil-works/pi-ai/dist/utils/error-body.js
+const MAX_PROVIDER_ERROR_BODY_CHARS = 4e3;
+function normalizeProviderError(error) {
+	if (!(error instanceof Error)) return {
+		message: safeJsonStringify$1(error),
+		messageCarriesBody: false
+	};
+	const sdkError = error;
+	const status = extractStatus(sdkError);
+	const body = extractBody(sdkError);
+	const messageCarriesBody = body === void 0 || error.message.includes(body);
+	return {
+		status,
+		body,
+		message: error.message,
+		messageCarriesBody
+	};
+}
+/**
+* Probe the HTTP status, first numeric hit wins, in SDK-field order:
+* `statusCode` (Mistral) → `status` (`openai`, `@google/genai`) →
+* `$metadata.httpStatusCode` (Bedrock) → `$response.statusCode` (Bedrock).
+*/
+function extractStatus(error) {
+	if (typeof error.statusCode === "number") return error.statusCode;
+	if (typeof error.status === "number") return error.status;
+	if (typeof error.$metadata?.httpStatusCode === "number") return error.$metadata.httpStatusCode;
+	if (typeof error.$response?.statusCode === "number") return error.$response.statusCode;
+}
+/**
+* Probe the raw body reason, first usable hit wins, in SDK-field order:
+* `body` string (Mistral) → `error` parsed JSON body object (`openai` SDK's
+* `this.error`) → `$response.body` (Bedrock). Empty objects and unread response
+* streams are treated as no body so they do not surface as `"{}"` or serialized
+* stream internals. The chosen body is truncated to the cap.
+*/
+function extractBody(error) {
+	const bodyText = pickBodyText(error);
+	if (bodyText === void 0) return void 0;
+	const trimmed = bodyText.trim();
+	if (trimmed.length === 0) return void 0;
+	return truncateErrorText(trimmed, MAX_PROVIDER_ERROR_BODY_CHARS);
+}
+function pickBodyText(error) {
+	if (typeof error.body === "string") return error.body;
+	if (isPlainNonEmptyObject(error.error)) return safeJsonStringify$1(error.error);
+	const responseBody = error.$response?.body;
+	if (typeof responseBody === "string") return responseBody;
+	if (isReadableStreamLike(responseBody)) return void 0;
+	if (isPlainNonEmptyObject(responseBody)) return safeJsonStringify$1(responseBody);
+}
+function isReadableStreamLike(value) {
+	return typeof value === "object" && value !== null && "pipe" in value && typeof value.pipe === "function";
+}
+/**
+* Only a PLAIN object counts as an HTTP body. SDK error fields can hold class
+* instances instead of parsed bodies — AWS SDK v3's `$response.body` is an
+* HTTP stream/response wrapper object, and stringifying one produced garbage
+* like `{"_events":...}` as the "body", which then REPLACED `error.message`
+* in the composed display string. `error.message` is where the SDK puts the
+* real deserialized exception text ("Input is too long...", schema validation
+* details, ...), so the one useful string was discarded for noise. A class
+* instance yields no body, `messageCarriesBody` stays true, and the real
+* message survives. Complements the `pipe` sniffing above: web
+* ReadableStreams (pipeTo/pipeThrough, no `pipe`) and non-stream SDK wrapper
+* classes fail the prototype check, while parsed JSON bodies (plain objects
+* by construction) still pass.
+*/
+function isPlainNonEmptyObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null) return false;
+	return Object.keys(value).length > 0;
+}
+/**
+* Compose a display string from a normalized error. When the message already
+* carries the body (Anthropic / `@google/genai` happy path) or no body/status
+* was extracted, the message is returned unchanged. Otherwise the status and
+* body are surfaced, with an optional provider prefix.
+*
+* - no prefix: `"<status>: <body>"`
+* - prefix:    `"<prefix> (<status>): <body>"`
+*/
+function formatProviderError(norm, prefix) {
+	if (norm.messageCarriesBody || norm.status === void 0 || norm.body === void 0) return prefix !== void 0 && norm.status !== void 0 ? `${prefix} (${norm.status}): ${norm.message}` : norm.message;
+	return prefix !== void 0 ? `${prefix} (${norm.status}): ${norm.body}` : `${norm.status}: ${norm.body}`;
+}
+function truncateErrorText(text, maxChars) {
+	if (text.length <= maxChars) return text;
+	return `${text.slice(0, maxChars)}... [truncated ${text.length - maxChars} chars]`;
+}
+function safeJsonStringify$1(value) {
+	try {
+		const serialized = JSON.stringify(value);
+		return serialized === void 0 ? String(value) : serialized;
+	} catch {
+		return String(value);
+	}
+}
+//#endregion
+//#region node_modules/@earendil-works/pi-ai/dist/utils/headers.js
+function headersToRecord(headers) {
+	const result = {};
+	for (const [key, value] of headers.entries()) result[key] = value;
+	return result;
+}
+//#endregion
+//#region node_modules/@earendil-works/pi-ai/dist/utils/node-http-proxy.js
+const DEFAULT_PROXY_PORTS = {
+	ftp: 21,
+	gopher: 70,
+	http: 80,
+	https: 443,
+	ws: 80,
+	wss: 443
+};
+function getProxyEnv(key, env) {
+	const lowercaseKey = key.toLowerCase();
+	const uppercaseKey = key.toUpperCase();
+	return env?.[lowercaseKey] || env?.[uppercaseKey] || getProviderEnvValue(lowercaseKey) || getProviderEnvValue(uppercaseKey) || "";
+}
+function parseProxyTargetUrl(targetUrl) {
+	if (targetUrl instanceof URL) return targetUrl;
+	try {
+		return new URL(targetUrl);
+	} catch {
+		return;
+	}
+}
+function stripBrackets(host) {
+	return host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+}
+function parseNoProxyEntry(entry) {
+	const trimmed = entry.trim().toLowerCase();
+	if (!trimmed) return void 0;
+	if (trimmed.startsWith("[")) {
+		const closingBracket = trimmed.indexOf("]");
+		if (closingBracket !== -1) {
+			const host = trimmed.slice(1, closingBracket);
+			const rest = trimmed.slice(closingBracket + 1);
+			if (rest.startsWith(":")) {
+				const port = Number.parseInt(rest.slice(1), 10);
+				return {
+					host,
+					port: Number.isNaN(port) ? 0 : port
+				};
+			}
+			return {
+				host,
+				port: 0
+			};
+		}
+	}
+	if (trimmed.includes(":") && trimmed.split(":").length > 2) return {
+		host: trimmed,
+		port: 0
+	};
+	const colonIndex = trimmed.lastIndexOf(":");
+	if (colonIndex !== -1 && colonIndex === trimmed.indexOf(":")) {
+		const host = trimmed.slice(0, colonIndex);
+		const port = Number.parseInt(trimmed.slice(colonIndex + 1), 10);
+		if (!Number.isNaN(port)) return {
+			host,
+			port
+		};
+	}
+	return {
+		host: trimmed,
+		port: 0
+	};
+}
+function shouldProxyHostname(hostname, port, env) {
+	const noProxy = getProxyEnv("no_proxy", env).toLowerCase();
+	if (!noProxy) return true;
+	if (noProxy === "*") return false;
+	const normalizedTargetHost = stripBrackets(hostname.toLowerCase());
+	return noProxy.split(/[,\s]/).every((entry) => {
+		const parsed = parseNoProxyEntry(entry);
+		if (!parsed) return true;
+		if (parsed.port && parsed.port !== port) return true;
+		let domain = stripBrackets(parsed.host);
+		if (domain.startsWith("*.")) domain = domain.slice(2);
+		else if (domain.startsWith(".") || domain.startsWith("*")) domain = domain.slice(1);
+		if (!domain) return true;
+		if (normalizedTargetHost === domain) return false;
+		if (normalizedTargetHost.endsWith(`.${domain}`)) return false;
+		return true;
+	});
+}
+function getProxyForUrl(targetUrl, env) {
+	const parsedUrl = parseProxyTargetUrl(targetUrl);
+	if (!parsedUrl?.protocol || !parsedUrl.host) return "";
+	const protocol = parsedUrl.protocol.split(":", 1)[0];
+	if (!shouldProxyHostname(stripBrackets(parsedUrl.hostname || parsedUrl.host.replace(/:\d*$/, "")), Number.parseInt(parsedUrl.port, 10) || DEFAULT_PROXY_PORTS[protocol] || 0, env)) return "";
+	let proxy = getProxyEnv(`${protocol}_proxy`, env) || getProxyEnv("all_proxy", env);
+	if (proxy && !proxy.includes("://")) proxy = `${protocol}://${proxy}`;
+	return proxy;
+}
+const UNSUPPORTED_PROXY_PROTOCOL_MESSAGE = "Unsupported proxy protocol. SOCKS and PAC proxy URLs are not supported; use an HTTP or HTTPS proxy URL.";
+function resolveHttpProxyUrlForTarget(targetUrl, env) {
+	const proxy = getProxyForUrl(targetUrl, env);
+	if (!proxy) return;
+	let proxyUrl;
+	try {
+		proxyUrl = new URL(proxy);
+	} catch (error) {
+		throw new Error(`Invalid proxy URL ${JSON.stringify(proxy)}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (proxyUrl.protocol !== "http:" && proxyUrl.protocol !== "https:") throw new Error(`${UNSUPPORTED_PROXY_PROTOCOL_MESSAGE} Got ${proxyUrl.protocol}`);
+	return proxyUrl;
+}
+//#endregion
+//#region node_modules/@earendil-works/pi-ai/dist/utils/pi-user-agent.js
+function loadNodeOs() {
+	if (typeof process === "undefined" || !(process.versions?.node || process.versions?.bun)) return null;
+	return process.getBuiltinModule?.("node:os") ?? null;
+}
+const nodeOs = loadNodeOs();
+function getPiUserAgent() {
+	return nodeOs ? `pi (${nodeOs.platform()} ${nodeOs.release()}; ${nodeOs.arch()})` : "pi (browser)";
+}
+//#endregion
+//#region node_modules/@earendil-works/pi-ai/dist/api/constrained-sampling.js
+var UnsupportedStrictJsonSchemaError = class extends Error {};
+const UNSUPPORTED_STRICT_SCHEMA_KEYS = [
+	"$ref",
+	"$defs",
+	"definitions",
+	"allOf",
+	"oneOf",
+	"patternProperties",
+	"dependentSchemas",
+	"dependencies",
+	"unevaluatedProperties",
+	"propertyNames",
+	"contains",
+	"prefixItems",
+	"not",
+	"if",
+	"then",
+	"else"
+];
+function isJsonSchemaObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStructuredSchema(schema) {
+	if (!isJsonSchemaObject(schema)) return false;
+	const types = typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) ? schema.type : [];
+	return types.includes("object") || types.includes("array") || schema.properties !== void 0 || schema.items !== void 0;
+}
+function schemaAllowsNull(schema) {
+	if (!isJsonSchemaObject(schema)) return false;
+	if (schema.type === "null" || Array.isArray(schema.type) && schema.type.includes("null")) return true;
+	if (schema.const === null || Array.isArray(schema.enum) && schema.enum.includes(null)) return true;
+	return Array.isArray(schema.anyOf) && schema.anyOf.some((variant) => schemaAllowsNull(variant));
+}
+function makeJsonSchemaNodeStrict(schema) {
+	if (!isJsonSchemaObject(schema)) throw new UnsupportedStrictJsonSchemaError("boolean schemas are unsupported");
+	for (const key of UNSUPPORTED_STRICT_SCHEMA_KEYS) if (schema[key] !== void 0) throw new UnsupportedStrictJsonSchemaError(`${key} schemas are unsupported`);
+	if (schema.anyOf !== void 0) {
+		if (!Array.isArray(schema.anyOf) || schema.anyOf.length === 0) throw new UnsupportedStrictJsonSchemaError("anyOf must contain at least one schema");
+		for (const variant of schema.anyOf) {
+			if (isStructuredSchema(variant)) throw new UnsupportedStrictJsonSchemaError("object and array unions are unsupported");
+			makeJsonSchemaNodeStrict(variant);
+		}
+	}
+	if (schema.items !== void 0) {
+		if (Array.isArray(schema.items)) throw new UnsupportedStrictJsonSchemaError("tuple schemas are unsupported");
+		makeJsonSchemaNodeStrict(schema.items);
+	}
+	const isObjectSchema = schema.type === "object";
+	if (schema.properties !== void 0 && !isObjectSchema) throw new UnsupportedStrictJsonSchemaError("properties require type object");
+	if (!isObjectSchema) return;
+	if (schema.additionalProperties !== void 0 && schema.additionalProperties !== false) throw new UnsupportedStrictJsonSchemaError("schema-valued or true additionalProperties is unsupported");
+	if (schema.properties !== void 0 && !isJsonSchemaObject(schema.properties)) throw new UnsupportedStrictJsonSchemaError("object properties must be a schema map");
+	if (schema.required !== void 0 && (!Array.isArray(schema.required) || schema.required.some((key) => typeof key !== "string"))) throw new UnsupportedStrictJsonSchemaError("object required must be a string array");
+	const properties = schema.properties ?? {};
+	const propertyNames = Object.keys(properties);
+	const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+	if ([...required].some((key) => !propertyNames.includes(key))) throw new UnsupportedStrictJsonSchemaError("required contains an unknown property");
+	for (const [key, property] of Object.entries(properties)) {
+		makeJsonSchemaNodeStrict(property);
+		if (!required.has(key) && !schemaAllowsNull(property)) properties[key] = { anyOf: [property, { type: "null" }] };
+	}
+	schema.required = propertyNames;
+	schema.additionalProperties = false;
+}
+/** Convert a tool schema to the strict subset expected by provider constrained sampling. */
+function makeStrictJsonSchema(schema) {
+	const cloned = structuredClone(schema);
+	if (!isJsonSchemaObject(cloned)) throw new UnsupportedStrictJsonSchemaError("root schema must have type object");
+	makeJsonSchemaNodeStrict(cloned);
+	if (cloned.type !== "object") throw new UnsupportedStrictJsonSchemaError("root schema must have type object");
+	return cloned;
+}
+function getJsonSchemaToolParameters(tool, strict) {
+	return strict === true ? makeStrictJsonSchema(tool.parameters) : tool.parameters;
+}
+function getGrammarToolInput(toolName, arguments_, inputProperty) {
+	const input = arguments_[inputProperty];
+	if (typeof input !== "string") throw new Error(`Grammar tool call "${toolName}" requires argument "${inputProperty}" to be a string.`);
+	return input;
+}
+function appendGrammarToolInputJsonDelta(buffer, inputProperty, nextInput, close) {
+	if (buffer.closed) {
+		if (close && nextInput === buffer.input) return void 0;
+		throw new Error(`grammar tool input for property "${inputProperty}" changed after it was closed`);
+	}
+	if (!nextInput.startsWith(buffer.input)) throw new Error(`grammar tool input for property "${inputProperty}" changed non-monotonically`);
+	const inputDelta = nextInput.slice(buffer.input.length);
+	if (!close && inputDelta.length === 0) return void 0;
+	let delta = "";
+	if (!buffer.started) {
+		delta += `{${JSON.stringify(inputProperty)}:"`;
+		buffer.started = true;
+	}
+	delta += JSON.stringify(inputDelta).slice(1, -1);
+	buffer.input = nextInput;
+	if (close) {
+		delta += "\"}";
+		buffer.closed = true;
+	}
+	return delta;
+}
+function inferGrammarInputProperty(tool) {
+	const schema = tool.parameters;
+	if (schema.type !== "object") throw new Error("grammar constrained sampling requires an object parameter schema");
+	if (!Array.isArray(schema.required) || schema.required.length !== 1 || typeof schema.required[0] !== "string") throw new Error("grammar constrained sampling requires exactly one required string property");
+	const inputProperty = schema.required[0];
+	if (!schema.properties?.[inputProperty]) throw new Error(`grammar constrained sampling requires a properties entry for ${inputProperty}`);
+	if (schema.properties[inputProperty]?.type !== "string") throw new Error(`grammar constrained sampling property ${inputProperty} must have type string`);
+	return inputProperty;
+}
+function resolveJsonSchemaStrictSampling(tool, supportsStrictMode) {
+	const config = tool.constrainedSampling;
+	if (!config || config.type !== "json_schema") return void 0;
+	if (supportsStrictMode) try {
+		makeStrictJsonSchema(tool.parameters);
+		return true;
+	} catch (error) {
+		if (!(error instanceof UnsupportedStrictJsonSchemaError)) throw error;
+		if (config.strict !== "require") return void 0;
+		throw new Error(`Tool "${tool.name}" requires JSON-schema constrained sampling, but ${error.message}.`);
+	}
+	if (config.strict === "require") throw new Error(`Tool "${tool.name}" requires JSON-schema constrained sampling, but strict tools are unsupported.`);
+}
+function resolveGrammarConstrainedSampling(tool, supportsOpenAIGrammarTools) {
+	const config = tool.constrainedSampling;
+	if (!config || config.type !== "grammar") return;
+	if (!supportsOpenAIGrammarTools) return;
+	const larkDefinition = config.variants.openai_lark;
+	const regexDefinition = config.variants.openai_regex;
+	const hasLarkDefinition = typeof larkDefinition === "string" && larkDefinition.trim().length > 0;
+	const hasRegexDefinition = typeof regexDefinition === "string" && regexDefinition.trim().length > 0;
+	if (!hasLarkDefinition && !hasRegexDefinition) throw new Error(`Tool "${tool.name}" cannot use grammar constrained sampling: no supported grammar variant was provided.`);
+	try {
+		return {
+			format: hasLarkDefinition ? "lark" : "regex",
+			definition: hasLarkDefinition ? larkDefinition : regexDefinition,
+			inputProperty: inferGrammarInputProperty(tool)
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Tool "${tool.name}" cannot use grammar constrained sampling: ${message}.`);
+	}
+}
+function createGrammarToolInputProperties(tools, supportsOpenAIGrammarTools) {
+	const properties = /* @__PURE__ */ new Map();
+	for (const tool of tools ?? []) {
+		const grammar = resolveGrammarConstrainedSampling(tool, supportsOpenAIGrammarTools);
+		if (grammar) properties.set(tool.name, grammar.inputProperty);
+	}
+	return properties;
+}
+function clampOpenAIPromptCacheKey(key) {
+	if (key === void 0) return void 0;
+	const chars = Array.from(key);
+	if (chars.length <= 64) return key;
+	return chars.slice(0, 64).join("");
+}
+//#endregion
+//#region node_modules/@earendil-works/pi-ai/dist/utils/hash.js
+/** Fast deterministic hash to shorten long strings */
+function shortHash(str) {
+	let h1 = 3735928559;
+	let h2 = 1103547991;
+	for (let i = 0; i < str.length; i++) {
+		const ch = str.charCodeAt(i);
+		h1 = Math.imul(h1 ^ ch, 2654435761);
+		h2 = Math.imul(h2 ^ ch, 1597334677);
+	}
+	h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+	h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+	return (h2 >>> 0).toString(36) + (h1 >>> 0).toString(36);
+}
+//#endregion
+//#region node_modules/@earendil-works/pi-ai/dist/utils/sanitize-unicode.js
+/**
+* Removes unpaired Unicode surrogate characters from a string.
+*
+* Unpaired surrogates (high surrogates 0xD800-0xDBFF without matching low surrogates 0xDC00-0xDFFF,
+* or vice versa) cause JSON serialization errors in many API providers.
+*
+* Valid emoji and other characters outside the Basic Multilingual Plane use properly paired
+* surrogates and will NOT be affected by this function.
+*
+* @param text - The text to sanitize
+* @returns The sanitized text with unpaired surrogates removed
+*
+* @example
+* // Valid emoji (properly paired surrogates) are preserved
+* sanitizeSurrogates("Hello 🙈 World") // => "Hello 🙈 World"
+*
+* // Unpaired high surrogate is removed
+* const unpaired = String.fromCharCode(0xD83D); // high surrogate without low
+* sanitizeSurrogates(`Text ${unpaired} here`) // => "Text  here"
+*/
+function sanitizeSurrogates(text) {
+	return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
+}
+//#endregion
+//#region node_modules/@earendil-works/pi-ai/dist/api/transform-messages.js
+const NON_VISION_USER_IMAGE_PLACEHOLDER = "(image omitted: model does not support images)";
+const NON_VISION_TOOL_IMAGE_PLACEHOLDER = "(tool image omitted: model does not support images)";
+function replaceImagesWithPlaceholder(content, placeholder) {
+	const result = [];
+	let previousWasPlaceholder = false;
+	for (const block of content) {
+		if (block.type === "image") {
+			if (!previousWasPlaceholder) result.push({
+				type: "text",
+				text: placeholder
+			});
+			previousWasPlaceholder = true;
+			continue;
+		}
+		result.push(block);
+		previousWasPlaceholder = block.text === placeholder;
+	}
+	return result;
+}
+function downgradeUnsupportedImages(messages, model) {
+	if (model.input.includes("image")) return messages;
+	return messages.map((msg) => {
+		if (msg.role === "user" && Array.isArray(msg.content)) return {
+			...msg,
+			content: replaceImagesWithPlaceholder(msg.content, NON_VISION_USER_IMAGE_PLACEHOLDER)
+		};
+		if (msg.role === "toolResult") return {
+			...msg,
+			content: replaceImagesWithPlaceholder(msg.content, NON_VISION_TOOL_IMAGE_PLACEHOLDER)
+		};
+		return msg;
+	});
+}
+/**
+* Normalize tool call ID for cross-provider compatibility.
+* OpenAI Responses API generates IDs that are 450+ chars with special characters like `|`.
+* Anthropic APIs require IDs matching ^[a-zA-Z0-9_-]+$ (max 64 chars).
+*/
+function transformMessages(messages, model, normalizeToolCallId) {
+	const toolCallIdMap = /* @__PURE__ */ new Map();
+	const transformed = downgradeUnsupportedImages(messages.map((msg) => msg.content == null ? {
+		...msg,
+		content: []
+	} : msg), model).map((msg) => {
+		if (msg.role === "user") return msg;
+		if (msg.role === "toolResult") {
+			const normalizedId = toolCallIdMap.get(msg.toolCallId);
+			if (normalizedId && normalizedId !== msg.toolCallId) return {
+				...msg,
+				toolCallId: normalizedId
+			};
+			return msg;
+		}
+		if (msg.role === "assistant") {
+			const assistantMsg = msg;
+			const isSameModel = assistantMsg.provider === model.provider && assistantMsg.api === model.api && assistantMsg.model === model.id;
+			const transformedContent = assistantMsg.content.flatMap((block) => {
+				if (block.type === "thinking") {
+					if (block.redacted) return isSameModel ? block : [];
+					if (isSameModel && block.thinkingSignature) return block;
+					if (!block.thinking || block.thinking.trim() === "") return [];
+					if (isSameModel) return block;
+					return {
+						type: "text",
+						text: block.thinking
+					};
+				}
+				if (block.type === "text") {
+					if (isSameModel) return block;
+					return {
+						type: "text",
+						text: block.text
+					};
+				}
+				if (block.type === "toolCall") {
+					const toolCall = block;
+					let normalizedToolCall = toolCall;
+					if (!isSameModel && toolCall.thoughtSignature) {
+						normalizedToolCall = { ...toolCall };
+						delete normalizedToolCall.thoughtSignature;
+					}
+					if (!isSameModel && normalizeToolCallId) {
+						const normalizedId = normalizeToolCallId(toolCall.id, model, assistantMsg);
+						if (normalizedId !== toolCall.id) {
+							toolCallIdMap.set(toolCall.id, normalizedId);
+							normalizedToolCall = {
+								...normalizedToolCall,
+								id: normalizedId
+							};
+						}
+					}
+					return normalizedToolCall;
+				}
+				return block;
+			});
+			return {
+				...assistantMsg,
+				content: transformedContent
+			};
+		}
+		return msg;
+	});
+	const result = [];
+	let pendingToolCalls = [];
+	let existingToolResultIds = /* @__PURE__ */ new Set();
+	const insertSyntheticToolResults = () => {
+		if (pendingToolCalls.length > 0) {
+			for (const tc of pendingToolCalls) if (!existingToolResultIds.has(tc.id)) result.push({
+				role: "toolResult",
+				toolCallId: tc.id,
+				toolName: tc.name,
+				content: [{
+					type: "text",
+					text: "No result provided"
+				}],
+				isError: true,
+				timestamp: Date.now()
+			});
+			pendingToolCalls = [];
+			existingToolResultIds = /* @__PURE__ */ new Set();
+		}
+	};
+	for (let i = 0; i < transformed.length; i++) {
+		const msg = transformed[i];
+		if (msg.role === "assistant") {
+			insertSyntheticToolResults();
+			const assistantMsg = msg;
+			if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") continue;
+			const toolCalls = assistantMsg.content.filter((b) => b.type === "toolCall");
+			if (toolCalls.length > 0) {
+				pendingToolCalls = toolCalls;
+				existingToolResultIds = /* @__PURE__ */ new Set();
+			}
+			result.push(msg);
+		} else if (msg.role === "toolResult") {
+			existingToolResultIds.add(msg.toolCallId);
+			result.push(msg);
+		} else if (msg.role === "user") {
+			insertSyntheticToolResults();
+			result.push(msg);
+		} else result.push(msg);
+	}
+	insertSyntheticToolResults();
+	return result;
+}
+//#endregion
+//#region node_modules/@earendil-works/pi-ai/dist/api/openai-responses-shared.js
+function encodeTextSignatureV1(id, phase) {
+	const payload = {
+		v: 1,
+		id
+	};
+	if (phase) payload.phase = phase;
+	return JSON.stringify(payload);
+}
+function parseTextSignature(signature) {
+	if (!signature) return void 0;
+	if (signature.startsWith("{")) try {
+		const parsed = JSON.parse(signature);
+		if (parsed.v === 1 && typeof parsed.id === "string") {
+			if (parsed.phase === "commentary" || parsed.phase === "final_answer") return {
+				id: parsed.id,
+				phase: parsed.phase
+			};
+			return { id: parsed.id };
+		}
+	} catch {}
+	return { id: signature };
+}
+function convertToolResultOutput(model, content) {
+	const textResult = content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+	const images = content.filter((c) => c.type === "image");
+	const hasText = textResult.length > 0;
+	if (images.length === 0 || !model.input.includes("image")) return sanitizeSurrogates(hasText ? textResult : images.length > 0 ? "(see attached image)" : "(no tool output)");
+	const output = [];
+	if (hasText) output.push({
+		type: "input_text",
+		text: sanitizeSurrogates(textResult)
+	});
+	for (const image of images) output.push({
+		type: "input_image",
+		detail: "auto",
+		image_url: `data:${image.mimeType};base64,${image.data}`
+	});
+	return output;
+}
+function convertResponsesMessages(model, context, allowedToolCallProviders, options) {
+	const messages = [];
+	const loadedToolNames = /* @__PURE__ */ new Set();
+	const normalizeIdPart = (part) => {
+		const sanitized = part.replace(/[^a-zA-Z0-9_-]/g, "_");
+		return (sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized).replace(/_+$/, "");
+	};
+	const buildForeignResponsesItemId = (itemId) => {
+		const normalized = `fc_${shortHash(itemId)}`;
+		return normalized.length > 64 ? normalized.slice(0, 64) : normalized;
+	};
+	const normalizeToolCallId = (id, _targetModel, source) => {
+		if (!allowedToolCallProviders.has(model.provider)) return normalizeIdPart(id);
+		if (!id.includes("|")) return normalizeIdPart(id);
+		const [callId, itemId] = id.split("|");
+		const normalizedCallId = normalizeIdPart(callId);
+		let normalizedItemId = source.provider !== model.provider || source.api !== model.api ? buildForeignResponsesItemId(itemId) : normalizeIdPart(itemId);
+		if (!normalizedItemId.startsWith("fc_")) normalizedItemId = normalizeIdPart(`fc_${normalizedItemId}`);
+		return `${normalizedCallId}|${normalizedItemId}`;
+	};
+	const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
+	if ((options?.includeSystemPrompt ?? true) && context.systemPrompt) {
+		const compat = model.compat;
+		const role = model.reasoning && compat?.supportsDeveloperRole !== false ? "developer" : "system";
+		messages.push({
+			role,
+			content: sanitizeSurrogates(context.systemPrompt)
+		});
+	}
+	let msgIndex = 0;
+	for (const msg of transformedMessages) {
+		if (msg.role === "user") if (typeof msg.content === "string") messages.push({
+			role: "user",
+			content: [{
+				type: "input_text",
+				text: sanitizeSurrogates(msg.content)
+			}]
+		});
+		else {
+			const content = msg.content.map((item) => {
+				if (item.type === "text") return {
+					type: "input_text",
+					text: sanitizeSurrogates(item.text)
+				};
+				return {
+					type: "input_image",
+					detail: "auto",
+					image_url: `data:${item.mimeType};base64,${item.data}`
+				};
+			});
+			if (content.length === 0) continue;
+			messages.push({
+				role: "user",
+				content
+			});
+		}
+		else if (msg.role === "assistant") {
+			const output = [];
+			const assistantMsg = msg;
+			const isSameProviderAndApi = assistantMsg.provider === model.provider && assistantMsg.api === model.api;
+			const isSameModel = isSameProviderAndApi && assistantMsg.model === model.id;
+			const isDifferentModel = isSameProviderAndApi && assistantMsg.model !== model.id;
+			let textBlockIndex = 0;
+			for (const block of msg.content) if (block.type === "thinking") {
+				if (block.thinkingSignature) {
+					const reasoningItem = JSON.parse(block.thinkingSignature);
+					output.push(reasoningItem);
+				}
+			} else if (block.type === "text") {
+				const textBlock = block;
+				const parsedSignature = parseTextSignature(textBlock.textSignature);
+				const fallbackMessageId = textBlockIndex === 0 ? `msg_pi_${msgIndex}` : `msg_pi_${msgIndex}_${textBlockIndex}`;
+				textBlockIndex++;
+				let msgId = parsedSignature?.id;
+				if (!msgId) msgId = fallbackMessageId;
+				else if (msgId.length > 64) msgId = `msg_${shortHash(msgId)}`;
+				output.push({
+					type: "message",
+					role: "assistant",
+					content: [{
+						type: "output_text",
+						text: sanitizeSurrogates(textBlock.text),
+						annotations: []
+					}],
+					status: "completed",
+					id: msgId,
+					phase: parsedSignature?.phase
+				});
+			} else if (block.type === "toolCall") {
+				const toolCall = block;
+				const [callId, itemIdRaw] = toolCall.id.split("|");
+				const customInputProperty = options?.grammarToolInputProperties?.get(toolCall.name);
+				let itemId = itemIdRaw;
+				if (isDifferentModel && itemId?.startsWith("fc_") || customInputProperty === void 0 && !itemId?.startsWith("fc_")) itemId = void 0;
+				const canReplayNamespace = isSameModel || options?.deferredTools?.has(toolCall.name) === true;
+				if (customInputProperty !== void 0) output.push({
+					type: "custom_tool_call",
+					id: itemId,
+					call_id: callId,
+					name: toolCall.name,
+					input: sanitizeSurrogates(getGrammarToolInput(toolCall.name, toolCall.arguments, customInputProperty)),
+					...canReplayNamespace && toolCall.namespace !== void 0 ? { namespace: toolCall.namespace } : {}
+				});
+				else output.push({
+					type: "function_call",
+					id: itemId,
+					call_id: callId,
+					name: toolCall.name,
+					arguments: JSON.stringify(toolCall.arguments),
+					...canReplayNamespace && toolCall.namespace !== void 0 ? { namespace: toolCall.namespace } : {}
+				});
+			}
+			if (output.length === 0) continue;
+			messages.push(...output);
+		} else if (msg.role === "toolResult") {
+			const [callId] = msg.toolCallId.split("|");
+			const output = convertToolResultOutput(model, msg.content);
+			if (options?.grammarToolInputProperties?.has(msg.toolName)) messages.push({
+				type: "custom_tool_call_output",
+				call_id: callId,
+				output
+			});
+			else messages.push({
+				type: "function_call_output",
+				call_id: callId,
+				output
+			});
+			const deferredTools = [];
+			for (const name of msg.addedToolNames ?? []) {
+				const tool = options?.deferredTools?.get(name);
+				if (!tool || loadedToolNames.has(name)) continue;
+				loadedToolNames.add(name);
+				deferredTools.push(tool);
+			}
+			if (deferredTools.length > 0 && options?.deferredToolsMode === "additional-tools") messages.push({
+				type: "additional_tools",
+				role: "developer",
+				tools: convertResponsesTools(deferredTools, options.toolOptions)
+			});
+			else if (deferredTools.length > 0 && options?.deferredToolsMode === "tool-search") {
+				const names = deferredTools.map((tool) => tool.name);
+				const searchCallId = `pi_tool_load_${shortHash(`${msg.toolCallId}:${names.join(",")}`)}`;
+				messages.push({
+					type: "tool_search_call",
+					call_id: searchCallId,
+					execution: "client",
+					status: "completed",
+					arguments: {
+						query: names.join(" "),
+						limit: names.length
+					}
+				});
+				messages.push({
+					type: "tool_search_output",
+					call_id: searchCallId,
+					execution: "client",
+					status: "completed",
+					tools: convertResponsesTools(deferredTools, {
+						...options.toolOptions,
+						deferLoading: true
+					})
+				});
+			}
+		}
+		msgIndex++;
+	}
+	return messages;
+}
+function convertResponsesTools(tools, options) {
+	const defaultStrict = options?.strict === void 0 ? false : options.strict;
+	const supportsStrictMode = options?.supportsStrictMode ?? true;
+	const supportsOpenAIGrammarTools = options?.supportsOpenAIGrammarTools ?? false;
+	return tools.map((tool) => {
+		const grammar = resolveGrammarConstrainedSampling(tool, supportsOpenAIGrammarTools);
+		if (grammar) return {
+			type: "custom",
+			name: tool.name,
+			description: tool.description,
+			format: {
+				type: "grammar",
+				syntax: grammar.format,
+				definition: grammar.definition
+			},
+			...options?.deferLoading ? { defer_loading: true } : {}
+		};
+		const strict = resolveJsonSchemaStrictSampling(tool, supportsStrictMode) ?? defaultStrict;
+		const functionTool = {
+			type: "function",
+			name: tool.name,
+			description: tool.description,
+			parameters: getJsonSchemaToolParameters(tool, strict === true),
+			...options?.deferLoading ? { defer_loading: true } : {}
+		};
+		if (supportsStrictMode) functionTool.strict = strict;
+		return functionTool;
+	});
+}
+function getCustomToolCallInput(block) {
+	const property = block.customInput?.property;
+	if (property === void 0) return "";
+	const value = block.arguments[property];
+	return typeof value === "string" ? value : "";
+}
+function appendCustomToolCallInput(block, nextInput, close) {
+	const customInput = block.customInput;
+	if (!customInput) return void 0;
+	const delta = appendGrammarToolInputJsonDelta(customInput.jsonBuffer, customInput.property, nextInput, close);
+	block.arguments = { [customInput.property]: nextInput };
+	return delta;
+}
+async function processResponsesStream(openaiStream, output, stream, model, options) {
+	let sawTerminalResponseEvent = false;
+	const outputSlots = /* @__PURE__ */ new Map();
+	const reasoningBlocksById = /* @__PURE__ */ new Map();
+	const applyMessagePhaseStopReason = (item) => {
+		if (item.type === "message" && item.phase === "final_answer") output.stopReason = "stop";
+	};
+	const getSlot = (outputIndex, type) => {
+		const slot = outputSlots.get(outputIndex);
+		return slot?.type === type ? slot : void 0;
+	};
+	const pushToolCallDelta = (slot, delta) => {
+		if (delta === void 0) return;
+		stream.push({
+			type: "toolcall_delta",
+			contentIndex: slot.contentIndex,
+			delta,
+			partial: output
+		});
+	};
+	const createSlot = (outputIndex, item) => {
+		if (item.type === "reasoning") {
+			const block = {
+				type: "thinking",
+				thinking: ""
+			};
+			output.content.push(block);
+			const slot = {
+				type: "thinking",
+				block,
+				contentIndex: output.content.length - 1
+			};
+			outputSlots.set(outputIndex, slot);
+			stream.push({
+				type: "thinking_start",
+				contentIndex: slot.contentIndex,
+				partial: output
+			});
+			return slot;
+		}
+		if (item.type === "message") {
+			applyMessagePhaseStopReason(item);
+			const block = {
+				type: "text",
+				text: ""
+			};
+			output.content.push(block);
+			const slot = {
+				type: "text",
+				block,
+				contentIndex: output.content.length - 1
+			};
+			outputSlots.set(outputIndex, slot);
+			stream.push({
+				type: "text_start",
+				contentIndex: slot.contentIndex,
+				partial: output
+			});
+			return slot;
+		}
+		if (item.type === "function_call") {
+			const block = {
+				type: "toolCall",
+				id: `${item.call_id}|${item.id}`,
+				name: item.name,
+				arguments: {},
+				...item.namespace !== void 0 ? { namespace: item.namespace } : {},
+				partialJson: item.arguments || ""
+			};
+			output.content.push(block);
+			const slot = {
+				type: "toolCall",
+				block,
+				contentIndex: output.content.length - 1
+			};
+			outputSlots.set(outputIndex, slot);
+			stream.push({
+				type: "toolcall_start",
+				contentIndex: slot.contentIndex,
+				partial: output
+			});
+			return slot;
+		}
+		if (item.type === "custom_tool_call") {
+			const inputProperty = options?.grammarToolInputProperties?.get(item.name) ?? "input";
+			const input = item.input || "";
+			const block = {
+				type: "toolCall",
+				id: `${item.call_id}|${item.id}`,
+				name: item.name,
+				arguments: { [inputProperty]: input },
+				...item.namespace !== void 0 ? { namespace: item.namespace } : {},
+				customInput: {
+					property: inputProperty,
+					jsonBuffer: {
+						input: "",
+						started: false,
+						closed: false
+					}
+				}
+			};
+			output.content.push(block);
+			const slot = {
+				type: "toolCall",
+				block,
+				contentIndex: output.content.length - 1
+			};
+			outputSlots.set(outputIndex, slot);
+			stream.push({
+				type: "toolcall_start",
+				contentIndex: slot.contentIndex,
+				partial: output
+			});
+			return slot;
+		}
+	};
+	const getOrCreateSlot = (outputIndex, item) => {
+		return outputSlots.get(outputIndex) ?? createSlot(outputIndex, item);
+	};
+	const backfillReasoningSignatures = (responseOutput) => {
+		for (const item of responseOutput) {
+			if (item.type !== "reasoning" || !item.encrypted_content) continue;
+			const block = reasoningBlocksById.get(item.id);
+			if (!block?.thinkingSignature) continue;
+			const storedItem = JSON.parse(block.thinkingSignature);
+			if (storedItem.encrypted_content) continue;
+			block.thinkingSignature = JSON.stringify({
+				...storedItem,
+				encrypted_content: item.encrypted_content
+			});
+		}
+	};
+	const finalizeResponse = (response) => {
+		sawTerminalResponseEvent = true;
+		backfillReasoningSignatures(response.output ?? []);
+		if (response?.id) output.responseId = response.id;
+		if (response?.usage) {
+			const inputDetails = response.usage.input_tokens_details;
+			const cachedTokens = inputDetails?.cached_tokens || 0;
+			const cacheWriteTokens = inputDetails?.cache_write_tokens || 0;
+			output.usage = {
+				input: Math.max(0, (response.usage.input_tokens || 0) - cachedTokens - cacheWriteTokens),
+				output: response.usage.output_tokens || 0,
+				cacheRead: cachedTokens,
+				cacheWrite: cacheWriteTokens,
+				reasoning: response.usage.output_tokens_details?.reasoning_tokens || 0,
+				totalTokens: response.usage.total_tokens || 0,
+				cost: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					total: 0
+				}
+			};
+		}
+		calculateCost(model, output.usage);
+		if (options?.applyServiceTierPricing) {
+			const serviceTier = options.resolveServiceTier ? options.resolveServiceTier(response?.service_tier, options.serviceTier) : response?.service_tier ?? options.serviceTier;
+			options.applyServiceTierPricing(output.usage, serviceTier);
+		}
+		const status = response?.status;
+		const incompleteDetails = response?.incomplete_details;
+		const incompleteReason = typeof incompleteDetails?.reason === "string" ? incompleteDetails.reason : void 0;
+		output.rawStopReason = incompleteReason ? `${status}.${incompleteReason}` : status;
+		const mappedStop = mapStopReason(status, incompleteReason);
+		output.stopReason = mappedStop.stopReason;
+		if (mappedStop.errorMessage === void 0) delete output.errorMessage;
+		else output.errorMessage = mappedStop.errorMessage;
+		if (output.content.some((b) => b.type === "toolCall") && output.stopReason === "stop") output.stopReason = "toolUse";
+	};
+	for await (const event of openaiStream) if (event.type === "response.created") output.responseId = event.response.id;
+	else if (event.type === "response.output_item.added") createSlot(event.output_index, event.item);
+	else if (event.type === "response.reasoning_summary_text.delta") {
+		const slot = getSlot(event.output_index, "thinking");
+		if (!slot) continue;
+		slot.block.thinking += event.delta;
+		stream.push({
+			type: "thinking_delta",
+			contentIndex: slot.contentIndex,
+			delta: event.delta,
+			partial: output
+		});
+	} else if (event.type === "response.reasoning_summary_part.done") {
+		const slot = getSlot(event.output_index, "thinking");
+		if (!slot) continue;
+		slot.block.thinking += "\n\n";
+		stream.push({
+			type: "thinking_delta",
+			contentIndex: slot.contentIndex,
+			delta: "\n\n",
+			partial: output
+		});
+	} else if (event.type === "response.reasoning_text.delta") {
+		const slot = getSlot(event.output_index, "thinking");
+		if (!slot) continue;
+		slot.block.thinking += event.delta;
+		stream.push({
+			type: "thinking_delta",
+			contentIndex: slot.contentIndex,
+			delta: event.delta,
+			partial: output
+		});
+	} else if (event.type === "response.output_text.delta") {
+		const slot = getSlot(event.output_index, "text");
+		if (!slot) continue;
+		slot.block.text += event.delta;
+		stream.push({
+			type: "text_delta",
+			contentIndex: slot.contentIndex,
+			delta: event.delta,
+			partial: output
+		});
+	} else if (event.type === "response.refusal.delta") {
+		const slot = getSlot(event.output_index, "text");
+		if (!slot) continue;
+		slot.block.text += event.delta;
+		stream.push({
+			type: "text_delta",
+			contentIndex: slot.contentIndex,
+			delta: event.delta,
+			partial: output
+		});
+	} else if (event.type === "response.function_call_arguments.delta") {
+		const slot = getSlot(event.output_index, "toolCall");
+		if (!slot || slot.block.partialJson === void 0) continue;
+		slot.block.partialJson += event.delta;
+		slot.block.arguments = parseStreamingJson(slot.block.partialJson);
+		pushToolCallDelta(slot, event.delta);
+	} else if (event.type === "response.function_call_arguments.done") {
+		const slot = getSlot(event.output_index, "toolCall");
+		if (!slot || slot.block.partialJson === void 0) continue;
+		const previousPartialJson = slot.block.partialJson;
+		slot.block.partialJson = event.arguments;
+		slot.block.arguments = parseStreamingJson(slot.block.partialJson);
+		if (event.arguments.startsWith(previousPartialJson)) {
+			const delta = event.arguments.slice(previousPartialJson.length);
+			if (delta.length > 0) pushToolCallDelta(slot, delta);
+		}
+	} else if (event.type === "response.custom_tool_call_input.delta") {
+		const slot = getSlot(event.output_index, "toolCall");
+		if (!slot || !slot.block.customInput) continue;
+		pushToolCallDelta(slot, appendCustomToolCallInput(slot.block, getCustomToolCallInput(slot.block) + event.delta, false));
+	} else if (event.type === "response.custom_tool_call_input.done") {
+		const slot = getSlot(event.output_index, "toolCall");
+		if (!slot || !slot.block.customInput) continue;
+		pushToolCallDelta(slot, appendCustomToolCallInput(slot.block, event.input, true));
+	} else if (event.type === "response.output_item.done") {
+		const item = event.item;
+		applyMessagePhaseStopReason(item);
+		const slot = getOrCreateSlot(event.output_index, item);
+		if (item.type === "reasoning" && slot?.type === "thinking") {
+			const summaryText = item.summary?.map((s) => s.text).join("\n\n") || "";
+			const contentText = item.content?.map((c) => c.text).join("\n\n") || "";
+			slot.block.thinking = summaryText || contentText || slot.block.thinking;
+			slot.block.thinkingSignature = JSON.stringify(item);
+			reasoningBlocksById.set(item.id, slot.block);
+			stream.push({
+				type: "thinking_end",
+				contentIndex: slot.contentIndex,
+				content: slot.block.thinking,
+				partial: output
+			});
+			outputSlots.delete(event.output_index);
+		} else if (item.type === "message" && slot?.type === "text") {
+			slot.block.text = item.content?.map((c) => c.type === "output_text" ? c.text : c.refusal).join("") || "";
+			slot.block.textSignature = encodeTextSignatureV1(item.id, item.phase ?? void 0);
+			stream.push({
+				type: "text_end",
+				contentIndex: slot.contentIndex,
+				content: slot.block.text,
+				partial: output
+			});
+			outputSlots.delete(event.output_index);
+		} else if (item.type === "function_call" && slot?.type === "toolCall" && slot.block.partialJson !== void 0) {
+			slot.block.arguments = parseStreamingJson(item.arguments || slot.block.partialJson || "{}");
+			if (item.namespace !== void 0) slot.block.namespace = item.namespace;
+			delete slot.block.partialJson;
+			stream.push({
+				type: "toolcall_end",
+				contentIndex: slot.contentIndex,
+				toolCall: slot.block,
+				partial: output
+			});
+			outputSlots.delete(event.output_index);
+		} else if (item.type === "custom_tool_call" && slot?.type === "toolCall" && slot.block.customInput) {
+			pushToolCallDelta(slot, appendCustomToolCallInput(slot.block, item.input ?? getCustomToolCallInput(slot.block), true));
+			if (item.namespace !== void 0) slot.block.namespace = item.namespace;
+			delete slot.block.customInput;
+			stream.push({
+				type: "toolcall_end",
+				contentIndex: slot.contentIndex,
+				toolCall: slot.block,
+				partial: output
+			});
+			outputSlots.delete(event.output_index);
+		}
+	} else if (event.type === "response.completed" || event.type === "response.incomplete") finalizeResponse(event.response);
+	else if (event.type === "error") throw new Error(`Error Code ${event.code}: ${event.message}` || "Unknown error");
+	else if (event.type === "response.failed") {
+		sawTerminalResponseEvent = true;
+		output.rawStopReason = event.response?.status;
+		const error = event.response?.error;
+		const details = event.response?.incomplete_details;
+		const msg = error ? `${error.code || "unknown"}: ${error.message || "no message"}` : details?.reason ? `incomplete: ${details.reason}` : "Unknown error (no error details in response)";
+		throw new Error(msg);
+	}
+	if (!sawTerminalResponseEvent) throw new Error("OpenAI Responses stream ended before a terminal response event");
+}
+function mapStopReason(status, incompleteReason) {
+	if (!status) return { stopReason: "stop" };
+	switch (status) {
+		case "completed": return { stopReason: "stop" };
+		case "incomplete":
+			if (incompleteReason === "max_output_tokens") return { stopReason: "length" };
+			return {
+				stopReason: "error",
+				errorMessage: incompleteReason ? `Response incomplete: ${incompleteReason}` : "Response incomplete without a provider reason"
+			};
+		case "failed":
+		case "cancelled": return { stopReason: "error" };
+		case "in_progress":
+		case "queued": return { stopReason: "stop" };
+		default: throw new Error(`Unhandled stop reason: ${status}`);
+	}
+}
+//#endregion
+//#region node_modules/@earendil-works/pi-ai/dist/utils/estimate.js
+const CHARS_PER_TOKEN = 4;
+const ESTIMATED_IMAGE_CHARS = 4800;
+function calculateContextTokens(usage) {
+	return usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}
+function safeJsonStringify(value) {
+	try {
+		return JSON.stringify(value) ?? "undefined";
+	} catch {
+		return "[unserializable]";
+	}
+}
+function estimateTextAndImageContentChars(content) {
+	if (typeof content === "string") return content.length;
+	let chars = 0;
+	for (const block of content) chars += block.type === "text" ? block.text.length : ESTIMATED_IMAGE_CHARS;
+	return chars;
+}
+function estimateTextTokens(text) {
+	return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function estimateTextAndImageContentTokens(content) {
+	return Math.ceil(estimateTextAndImageContentChars(content) / CHARS_PER_TOKEN);
+}
+function estimateMessageTokens(message) {
+	let chars = 0;
+	if (message.role === "user") return estimateTextAndImageContentTokens(message.content);
+	if (message.role === "toolResult") return estimateTextAndImageContentTokens(message.content);
+	for (const block of message.content) if (block.type === "text") chars += block.text.length;
+	else if (block.type === "thinking") chars += block.thinking.length;
+	else chars += block.name.length + safeJsonStringify(block.arguments).length;
+	return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+function getLastAssistantUsageInfo(messages) {
+	let latestPrefixTimestamp = Number.NEGATIVE_INFINITY;
+	let usageInfo;
+	for (let i = 0; i < messages.length; i++) {
+		const message = messages[i];
+		if (message.role === "assistant") {
+			const assistant = message;
+			if (assistant.timestamp >= latestPrefixTimestamp && assistant.stopReason !== "aborted" && assistant.stopReason !== "error" && calculateContextTokens(assistant.usage) > 0) usageInfo = {
+				usage: assistant.usage,
+				index: i
+			};
+		}
+		latestPrefixTimestamp = Math.max(latestPrefixTimestamp, message.timestamp);
+	}
+	return usageInfo;
+}
+function estimateMessages(messages) {
+	const usageInfo = getLastAssistantUsageInfo(messages);
+	if (usageInfo) {
+		const usageTokens = calculateContextTokens(usageInfo.usage);
+		let trailingTokens = 0;
+		for (let i = usageInfo.index + 1; i < messages.length; i++) trailingTokens += estimateMessageTokens(messages[i]);
+		return {
+			tokens: usageTokens + trailingTokens,
+			usageTokens,
+			trailingTokens,
+			lastUsageIndex: usageInfo.index
+		};
+	}
+	let tokens = 0;
+	for (const message of messages) tokens += estimateMessageTokens(message);
+	return {
+		tokens,
+		usageTokens: 0,
+		trailingTokens: tokens,
+		lastUsageIndex: null
+	};
+}
+function estimateToolsTokens(tools) {
+	if (!tools || tools.length === 0) return 0;
+	return estimateTextTokens(safeJsonStringify(tools));
+}
+function isMessageArray(value) {
+	return Array.isArray(value);
+}
+function estimateContextTokens(context) {
+	if (isMessageArray(context)) return estimateMessages(context);
+	const estimate = estimateMessages(context.messages);
+	if (estimate.lastUsageIndex !== null) {
+		const addedNames = new Set(context.messages.slice(estimate.lastUsageIndex + 1).filter((message) => message.role === "toolResult").flatMap((message) => message.addedToolNames ?? []));
+		const addedToolTokens = estimateToolsTokens(context.tools?.filter((tool) => addedNames.has(tool.name)));
+		return {
+			tokens: estimate.tokens + addedToolTokens,
+			usageTokens: estimate.usageTokens,
+			trailingTokens: estimate.trailingTokens + addedToolTokens,
+			lastUsageIndex: estimate.lastUsageIndex
+		};
+	}
+	const prefixTokens = (context.systemPrompt ? estimateTextTokens(context.systemPrompt) : 0) + estimateToolsTokens(context.tools);
+	return {
+		tokens: estimate.tokens + prefixTokens,
+		usageTokens: estimate.usageTokens,
+		trailingTokens: estimate.trailingTokens + prefixTokens,
+		lastUsageIndex: estimate.lastUsageIndex
+	};
+}
+//#endregion
+//#region node_modules/@earendil-works/pi-ai/dist/api/simple-options.js
+const CONTEXT_SAFETY_TOKENS = 4096;
+const MIN_MAX_TOKENS = 1;
+function clampMaxTokensToContext(model, context, maxTokens) {
+	if (model.contextWindow <= 0) return Math.max(MIN_MAX_TOKENS, maxTokens);
+	const available = model.contextWindow - estimateContextTokens(context).tokens - CONTEXT_SAFETY_TOKENS;
+	return Math.min(maxTokens, Math.max(MIN_MAX_TOKENS, available));
+}
+function buildBaseOptions(model, context, options, apiKey) {
+	const samplingParams = model.samplingParams || options?.samplingParams ? {
+		...model.samplingParams,
+		...options?.samplingParams
+	} : void 0;
+	return {
+		temperature: options?.temperature,
+		samplingParams,
+		maxTokens: clampMaxTokensToContext(model, context, options?.maxTokens ?? model.maxTokens),
+		signal: options?.signal,
+		telemetryContext: options?.telemetryContext,
+		apiKey: apiKey || options?.apiKey,
+		fetch: options?.fetch,
+		transport: options?.transport,
+		cacheRetention: options?.cacheRetention,
+		sessionId: options?.sessionId,
+		headers: options?.headers,
+		onPayload: options?.onPayload,
+		onResponse: options?.onResponse,
+		timeoutMs: options?.timeoutMs,
+		websocketConnectTimeoutMs: options?.websocketConnectTimeoutMs,
+		maxRetries: options?.maxRetries,
+		maxRetryDelayMs: options?.maxRetryDelayMs,
+		metadata: options?.metadata,
+		env: options?.env
+	};
+}
+//#endregion
+//#region node_modules/@earendil-works/pi-ai/dist/api/openai-codex-responses.js
+const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+const JWT_CLAIM_PATH = "https://api.openai.com/auth";
+const DEFAULT_MAX_RETRIES = 0;
+const BASE_DELAY_MS = 1e3;
+const DEFAULT_MAX_RETRY_DELAY_MS = 6e4;
+const DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS = 15e3;
+const REQUEST_COMPRESSION_ZSTD_LEVEL = 3;
+const CODEX_TOOL_CALL_PROVIDERS = /* @__PURE__ */ new Set([
+	"openai",
+	"openai-codex",
+	"opencode"
+]);
+const WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE = 1009;
+const WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE = "websocket_connection_limit_reached";
+const PREVIOUS_RESPONSE_NOT_FOUND_CODE = "previous_response_not_found";
+const CODEX_RESPONSE_STATUSES = /* @__PURE__ */ new Set([
+	"completed",
+	"incomplete",
+	"failed",
+	"cancelled",
+	"queued",
+	"in_progress"
+]);
+function assertSuccessfulOutput(output) {
+	if (output.stopReason === "pending") throw new Error("Codex stream ended without a stop reason");
+	if (output.stopReason === "error" || output.stopReason === "aborted") throw new Error(output.errorMessage || "An unknown error occurred");
+}
+function isTerminalRateLimitError(errorText) {
+	return /GoUsageLimitError|FreeUsageLimitError|Monthly usage limit reached|available balance|insufficient_quota|out of budget|quota exceeded|billing/i.test(errorText);
+}
+function isRetryableError(status, errorText) {
+	if (status === 429 && isTerminalRateLimitError(errorText)) return false;
+	if (status === 429 || status === 500 || status === 502 || status === 503 || status === 504) return true;
+	return /rate.?limit|overloaded|service.?unavailable|upstream.?connect|connection.?refused/i.test(errorText);
+}
+function getRetryAfterDelayMs(headers) {
+	const retryAfterMs = headers.get("retry-after-ms");
+	if (retryAfterMs !== null) {
+		const millis = Number(retryAfterMs);
+		if (Number.isFinite(millis)) return Math.max(0, millis);
+	}
+	const retryAfter = headers.get("retry-after");
+	if (!retryAfter) return;
+	const seconds = Number(retryAfter);
+	if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+	const date = Date.parse(retryAfter);
+	if (!Number.isNaN(date)) return Math.max(0, date - Date.now());
+}
+var RetryDelayExceededError = class extends Error {};
+function validateRetryDelayMs(delayMs, options) {
+	const maxRetryDelayMs = options?.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
+	if (maxRetryDelayMs > 0 && delayMs > maxRetryDelayMs) throw new RetryDelayExceededError(`Server requested ${Math.ceil(delayMs / 1e3)}s retry delay (max: ${Math.ceil(maxRetryDelayMs / 1e3)}s)`);
+	return delayMs;
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(/* @__PURE__ */ new Error("Request was aborted"));
+			return;
+		}
+		const timeout = setTimeout(resolve, ms);
+		signal?.addEventListener("abort", () => {
+			clearTimeout(timeout);
+			reject(/* @__PURE__ */ new Error("Request was aborted"));
+		});
+	});
+}
+function normalizeTimeoutMs(value) {
+	if (value === void 0) return void 0;
+	if (!Number.isFinite(value) || value < 0) throw new Error(`Invalid timeoutMs: ${String(value)}`);
+	return Math.floor(value);
+}
+function loadNodeZlib() {
+	if (typeof process === "undefined" || !(process.versions?.node || process.versions?.bun)) return null;
+	return process.getBuiltinModule?.("node:zlib") ?? null;
+}
+function compressRequestBodyZstd(bodyJson) {
+	const zlib = loadNodeZlib();
+	if (!zlib || typeof zlib.zstdCompressSync !== "function") return null;
+	try {
+		const compressed = zlib.zstdCompressSync(bodyJson, { params: { [zlib.constants.ZSTD_c_compressionLevel]: REQUEST_COMPRESSION_ZSTD_LEVEL } });
+		return new Uint8Array(compressed.buffer, compressed.byteOffset, compressed.byteLength);
+	} catch {
+		return null;
+	}
+}
+const stream = (model, context, options) => {
+	const stream = new AssistantMessageEventStream();
+	(async () => {
+		const output = {
+			role: "assistant",
+			content: [],
+			api: "openai-codex-responses",
+			provider: model.provider,
+			model: model.id,
+			usage: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				totalTokens: 0,
+				cost: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					total: 0
+				}
+			},
+			stopReason: "pending",
+			timestamp: Date.now()
+		};
+		try {
+			const apiKey = options?.apiKey;
+			if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
+			const accountId = extractAccountId(apiKey);
+			const grammarToolInputProperties = createGrammarToolInputProperties(context.tools, model.compat?.supportsOpenAIGrammarTools ?? false);
+			const cacheSessionId = options?.cacheRetention === "none" ? void 0 : options?.sessionId;
+			const codexSessionId = clampOpenAIPromptCacheKey(cacheSessionId);
+			let body = buildRequestBody(model, context, options, codexSessionId, grammarToolInputProperties);
+			const nextBody = await options?.onPayload?.(body, model);
+			if (nextBody !== void 0) body = nextBody;
+			const websocketRequestId = codexSessionId || uuidv7();
+			const sseHeaders = buildSSEHeaders(model.headers, options?.headers, accountId, apiKey, codexSessionId);
+			const websocketHeaders = buildWebSocketHeaders(model.headers, options?.headers, accountId, apiKey, websocketRequestId);
+			const bodyJson = JSON.stringify(body);
+			const httpTimeoutMs = normalizeTimeoutMs(options?.timeoutMs);
+			const websocketConnectTimeoutMs = normalizeTimeoutMs(options?.websocketConnectTimeoutMs);
+			const transport = options?.transport || "auto";
+			let startEmitted = false;
+			const websocketDisabledForSession = transport !== "sse" && isWebSocketSseFallbackActive(cacheSessionId);
+			if (websocketDisabledForSession) recordWebSocketSseFallback(cacheSessionId);
+			if (transport !== "sse" && !websocketDisabledForSession) {
+				let websocketStarted = false;
+				let retriedWebSocketConnectionLimit = false;
+				let retriedMissingWebSocketContinuation = false;
+				while (true) {
+					websocketStarted = false;
+					try {
+						await processWebSocketStream(resolveCodexWebSocketUrl(model.baseUrl), body, websocketHeaders, output, stream, model, () => {
+							websocketStarted = true;
+							if (!startEmitted) {
+								startEmitted = true;
+								stream.push({
+									type: "start",
+									partial: output
+								});
+							}
+						}, httpTimeoutMs, websocketConnectTimeoutMs, cacheSessionId, accountId, grammarToolInputProperties, options);
+						if (options?.signal?.aborted) throw new Error("Request was aborted");
+						assertSuccessfulOutput(output);
+						stream.push({
+							type: "done",
+							reason: output.stopReason,
+							message: output
+						});
+						stream.end();
+						return;
+					} catch (error) {
+						const aborted = options?.signal?.aborted;
+						const connectionLimitBeforeStart = !websocketStarted && isWebSocketConnectionLimitReachedError(error);
+						const previousResponseNotFound = isPreviousResponseNotFoundError(error);
+						if (!aborted && previousResponseNotFound && !retriedMissingWebSocketContinuation) {
+							retriedMissingWebSocketContinuation = true;
+							continue;
+						}
+						if (!aborted && connectionLimitBeforeStart && !retriedWebSocketConnectionLimit) {
+							retriedWebSocketConnectionLimit = true;
+							continue;
+						}
+						if (aborted || isCodexNonTransportError(error) && !connectionLimitBeforeStart) throw error;
+						appendAssistantMessageDiagnostic(output, createAssistantMessageDiagnostic("provider_transport_failure", error, {
+							configuredTransport: transport,
+							fallbackTransport: websocketStarted ? void 0 : "sse",
+							eventsEmitted: websocketStarted,
+							phase: websocketStarted ? "after_message_stream_start" : "before_message_stream_start",
+							requestBytes: new TextEncoder().encode(bodyJson).byteLength
+						}));
+						recordWebSocketFailure(cacheSessionId, error);
+						if (websocketStarted) throw error;
+						recordWebSocketSseFallback(cacheSessionId);
+						break;
+					}
+				}
+			}
+			const compressedBody = compressRequestBodyZstd(bodyJson);
+			if (compressedBody) sseHeaders.set("content-encoding", "zstd");
+			const sseBody = compressedBody ?? bodyJson;
+			let response;
+			let lastError;
+			const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
+			for (let attempt = 0; attempt <= maxRetries; attempt++) {
+				if (options?.signal?.aborted) throw new Error("Request was aborted");
+				try {
+					const headerTimeoutSignal = httpTimeoutMs !== void 0 && httpTimeoutMs > 0 ? AbortSignal.timeout(httpTimeoutMs) : void 0;
+					const combinedSignal = combineAbortSignals([options?.signal, headerTimeoutSignal]);
+					try {
+						response = await (options?.fetch ?? globalThis.fetch)(resolveCodexUrl(model.baseUrl), {
+							method: "POST",
+							headers: sseHeaders,
+							body: sseBody,
+							signal: combinedSignal.signal
+						});
+					} catch (error) {
+						if (headerTimeoutSignal?.aborted && !options?.signal?.aborted) throw new Error(`Codex SSE response headers timed out after ${httpTimeoutMs}ms`);
+						throw error;
+					} finally {
+						combinedSignal.cleanup();
+					}
+					await options?.onResponse?.({
+						status: response.status,
+						headers: headersToRecord(response.headers)
+					}, model);
+					if (response.ok) break;
+					const errorText = await response.text();
+					if (attempt < maxRetries && isRetryableError(response.status, errorText)) {
+						const retryAfterDelayMs = getRetryAfterDelayMs(response.headers);
+						await sleep(retryAfterDelayMs === void 0 ? BASE_DELAY_MS * 2 ** attempt : validateRetryDelayMs(retryAfterDelayMs, options), options?.signal);
+						continue;
+					}
+					const info = await parseErrorResponse(new Response(errorText, {
+						status: response.status,
+						statusText: response.statusText
+					}));
+					throw new Error(info.friendlyMessage || info.message);
+				} catch (error) {
+					if (error instanceof Error) {
+						if (error.name === "AbortError" || error.message === "Request was aborted") throw new Error("Request was aborted");
+					}
+					lastError = error instanceof Error ? error : new Error(String(error));
+					if (attempt < maxRetries && !(lastError instanceof RetryDelayExceededError) && !lastError.message.includes("usage limit")) {
+						await sleep(BASE_DELAY_MS * 2 ** attempt, options?.signal);
+						continue;
+					}
+					throw lastError;
+				}
+			}
+			if (!response?.ok) throw lastError ?? /* @__PURE__ */ new Error("Failed after retries");
+			if (!response.body) throw new Error("No response body");
+			if (!startEmitted) {
+				startEmitted = true;
+				stream.push({
+					type: "start",
+					partial: output
+				});
+			}
+			await processStream(response, output, stream, model, grammarToolInputProperties, options);
+			if (options?.signal?.aborted) throw new Error("Request was aborted");
+			assertSuccessfulOutput(output);
+			stream.push({
+				type: "done",
+				reason: output.stopReason,
+				message: output
+			});
+			stream.end();
+		} catch (error) {
+			for (const block of output.content) {
+				delete block.partialJson;
+				delete block.customInput;
+			}
+			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+			output.errorMessage = formatProviderError(normalizeProviderError(error));
+			stream.push({
+				type: "error",
+				reason: output.stopReason,
+				error: output
+			});
+			stream.end();
+		}
+	})();
+	return stream;
+};
+const streamSimple = (model, context, options) => {
+	const apiKey = options?.apiKey;
+	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
+	const base = {
+		...buildBaseOptions(model, context, options, apiKey),
+		toolChoice: options?.toolChoice
+	};
+	const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : void 0;
+	const reasoningEffort = clampedReasoning === "off" ? void 0 : clampedReasoning;
+	return stream(model, context, {
+		...base,
+		reasoningEffort
+	});
+};
+function buildRequestBody(model, context, options, cacheSessionId, grammarToolInputProperties = createGrammarToolInputProperties(context.tools, model.compat?.supportsOpenAIGrammarTools ?? false)) {
+	const supportsStrictMode = model.compat?.supportsStrictMode ?? true;
+	const supportsOpenAIGrammarTools = model.compat?.supportsOpenAIGrammarTools ?? false;
+	const deferredToolsMode = model.compat?.supportsAdditionalTools ? "additional-tools" : model.compat?.supportsToolSearch ? "tool-search" : void 0;
+	const toolPlacement = splitDeferredTools(context, deferredToolsMode !== void 0);
+	const messages = convertResponsesMessages(model, context, CODEX_TOOL_CALL_PROVIDERS, {
+		includeSystemPrompt: false,
+		grammarToolInputProperties,
+		deferredTools: toolPlacement.deferred,
+		deferredToolsMode,
+		toolOptions: {
+			strict: null,
+			supportsStrictMode,
+			supportsOpenAIGrammarTools
+		}
+	});
+	const body = {
+		model: model.id,
+		store: false,
+		stream: true,
+		instructions: context.systemPrompt || "You are a helpful assistant.",
+		input: messages,
+		text: { verbosity: options?.textVerbosity || "low" },
+		include: ["reasoning.encrypted_content"],
+		prompt_cache_key: cacheSessionId,
+		tool_choice: options?.toolChoice ?? "auto",
+		parallel_tool_calls: true
+	};
+	if (options?.temperature !== void 0) body.temperature = options.temperature;
+	if (options?.serviceTier !== void 0) body.service_tier = options.serviceTier;
+	if (toolPlacement.immediate.length > 0) body.tools = convertResponsesTools(toolPlacement.immediate, {
+		strict: null,
+		supportsStrictMode,
+		supportsOpenAIGrammarTools
+	});
+	if (options?.reasoningEffort !== void 0) {
+		const effort = options.reasoningEffort === "none" ? model.thinkingLevelMap?.off ?? "none" : model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+		if (effort !== null) body.reasoning = {
+			effort,
+			summary: options.reasoningSummary ?? "auto"
+		};
+	}
+	return body;
+}
+function getServiceTierCostMultiplier(model, serviceTier) {
+	switch (serviceTier) {
+		case "flex": return .5;
+		case "priority": return model.id === "gpt-5.5" ? 2.5 : 2;
+		default: return 1;
+	}
+}
+function applyServiceTierPricing(usage, serviceTier, model) {
+	const multiplier = getServiceTierCostMultiplier(model, serviceTier);
+	if (multiplier === 1) return;
+	usage.cost.input *= multiplier;
+	usage.cost.output *= multiplier;
+	usage.cost.cacheRead *= multiplier;
+	usage.cost.cacheWrite *= multiplier;
+	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+}
+function resolveCodexServiceTier(responseServiceTier, requestServiceTier) {
+	if (responseServiceTier === "default" && (requestServiceTier === "flex" || requestServiceTier === "priority")) return requestServiceTier;
+	return responseServiceTier ?? requestServiceTier;
+}
+function resolveCodexUrl(baseUrl) {
+	const normalized = (baseUrl && baseUrl.trim().length > 0 ? baseUrl : DEFAULT_CODEX_BASE_URL).replace(/\/+$/, "");
+	if (normalized.endsWith("/codex/responses")) return normalized;
+	if (normalized.endsWith("/codex")) return `${normalized}/responses`;
+	return `${normalized}/codex/responses`;
+}
+function resolveCodexWebSocketUrl(baseUrl) {
+	const url = new URL(resolveCodexUrl(baseUrl));
+	if (url.protocol === "https:") url.protocol = "wss:";
+	if (url.protocol === "http:") url.protocol = "ws:";
+	return url.toString();
+}
+async function processStream(response, output, stream, model, grammarToolInputProperties, options) {
+	await processResponsesStream(mapCodexEvents(parseSSE(response, options?.signal), output), output, stream, model, {
+		serviceTier: options?.serviceTier,
+		grammarToolInputProperties,
+		resolveServiceTier: resolveCodexServiceTier,
+		applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model)
+	});
+}
+var CodexApiError = class extends Error {
+	code;
+	payload;
+	constructor(message, options) {
+		super(message);
+		this.name = "CodexApiError";
+		this.code = options?.code;
+		this.payload = options?.payload;
+		this.cause = options?.cause;
+	}
+};
+var CodexProtocolError = class extends Error {
+	payload;
+	constructor(message, options) {
+		super(message);
+		this.name = "CodexProtocolError";
+		this.payload = options?.payload;
+		this.cause = options?.cause;
+	}
+};
+function isCodexNonTransportError(error) {
+	return error instanceof CodexApiError || error instanceof CodexProtocolError;
+}
+function isWebSocketConnectionLimitReachedError(error) {
+	return error instanceof CodexApiError && error.code === WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE;
+}
+function isPreviousResponseNotFoundError(error) {
+	return error instanceof CodexApiError && error.code === PREVIOUS_RESPONSE_NOT_FOUND_CODE;
+}
+function extractCodexEventError(event) {
+	const nested = event.error && typeof event.error === "object" ? event.error : void 0;
+	return {
+		code: typeof event.code === "string" ? event.code : typeof nested?.code === "string" ? nested.code : void 0,
+		message: typeof event.message === "string" ? event.message : typeof nested?.message === "string" ? nested.message : void 0
+	};
+}
+async function* mapCodexEvents(events, output) {
+	for await (const event of events) {
+		const type = typeof event.type === "string" ? event.type : void 0;
+		if (!type) continue;
+		if (type === "error") {
+			const { code, message } = extractCodexEventError(event);
+			throw new CodexApiError(`Codex error: ${message || code || JSON.stringify(event)}`, {
+				code,
+				payload: event
+			});
+		}
+		if (type === "response.failed") {
+			const response = event.response;
+			const code = response?.error?.code;
+			const message = response?.error?.message;
+			throw new CodexApiError(message || "Codex response failed", {
+				code,
+				payload: event
+			});
+		}
+		if (type === "response.done" || type === "response.completed" || type === "response.incomplete") {
+			const response = event.response;
+			if (typeof response?.end_turn === "boolean") output.endTurn = response.end_turn;
+			const normalizedResponse = response ? {
+				...response,
+				status: normalizeCodexStatus(response.status)
+			} : response;
+			yield {
+				...event,
+				type: "response.completed",
+				response: normalizedResponse
+			};
+			return;
+		}
+		yield event;
+	}
+}
+function normalizeCodexStatus(status) {
+	if (typeof status !== "string") return void 0;
+	return CODEX_RESPONSE_STATUSES.has(status) ? status : void 0;
+}
+async function* parseSSE(response, signal) {
+	if (!response.body) return;
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	const onAbort = () => {
+		reader.cancel().catch(() => {});
+	};
+	signal?.addEventListener("abort", onAbort, { once: true });
+	try {
+		while (true) {
+			if (signal?.aborted) throw new Error("Request was aborted");
+			const { done, value } = await reader.read();
+			if (signal?.aborted) throw new Error("Request was aborted");
+			buffer += done ? decoder.decode() : decoder.decode(value, { stream: true });
+			if (done && buffer.trim()) buffer += "\n\n";
+			let idx = buffer.indexOf("\n\n");
+			while (idx !== -1) {
+				const chunk = buffer.slice(0, idx);
+				buffer = buffer.slice(idx + 2);
+				const dataLines = chunk.split("\n").filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim());
+				if (dataLines.length > 0) {
+					const data = dataLines.join("\n").trim();
+					if (data && data !== "[DONE]") try {
+						yield JSON.parse(data);
+					} catch (cause) {
+						throw new CodexProtocolError(`Invalid Codex SSE JSON: ${formatThrownValue(cause)}`, {
+							cause,
+							payload: data
+						});
+					}
+				}
+				idx = buffer.indexOf("\n\n");
+			}
+			if (done) break;
+		}
+	} finally {
+		signal?.removeEventListener("abort", onAbort);
+		try {
+			await reader.cancel();
+		} catch {}
+		try {
+			reader.releaseLock();
+		} catch {}
+	}
+}
+const OPENAI_BETA_RESPONSES_WEBSOCKETS = "responses_websockets=2026-02-06";
+const SESSION_WEBSOCKET_CACHE_TTL_MS = 300 * 1e3;
+const SESSION_WEBSOCKET_MAX_AGE_MS = 3300 * 1e3;
+const websocketSessionCache = /* @__PURE__ */ new Map();
+const websocketDebugStats = /* @__PURE__ */ new Map();
+const websocketSseFallbackSessions = /* @__PURE__ */ new Set();
+function getOrCreateWebSocketDebugStats(sessionId) {
+	let stats = websocketDebugStats.get(sessionId);
+	if (!stats) {
+		stats = {
+			requests: 0,
+			connectionsCreated: 0,
+			connectionsReused: 0,
+			cachedContextRequests: 0,
+			storeTrueRequests: 0,
+			fullContextRequests: 0,
+			deltaRequests: 0,
+			lastInputItems: 0,
+			websocketFailures: 0,
+			sseFallbacks: 0
+		};
+		websocketDebugStats.set(sessionId, stats);
+	}
+	return stats;
+}
+function getOpenAICodexWebSocketDebugStats(sessionId) {
+	const stats = websocketDebugStats.get(sessionId);
+	return stats ? { ...stats } : void 0;
+}
+function resetOpenAICodexWebSocketDebugStats(sessionId) {
+	if (sessionId) {
+		websocketDebugStats.delete(sessionId);
+		websocketSseFallbackSessions.delete(sessionId);
+		return;
+	}
+	websocketDebugStats.clear();
+	websocketSseFallbackSessions.clear();
+}
+function closeOpenAICodexWebSocketSessions(sessionId) {
+	const closeEntry = (entry) => {
+		if (entry.idleTimer) clearTimeout(entry.idleTimer);
+		closeWebSocketSilently(entry.socket, 1e3, "debug_close");
+	};
+	if (sessionId) {
+		for (const entry of websocketSessionCache.get(sessionId)?.values() ?? []) closeEntry(entry);
+		websocketSessionCache.delete(sessionId);
+		return;
+	}
+	for (const accountEntries of websocketSessionCache.values()) for (const entry of accountEntries.values()) closeEntry(entry);
+	websocketSessionCache.clear();
+}
+registerSessionResourceCleanup(closeOpenAICodexWebSocketSessions);
+function isWebSocketSseFallbackActive(sessionId) {
+	return sessionId ? websocketSseFallbackSessions.has(sessionId) : false;
+}
+function recordWebSocketSseFallback(sessionId) {
+	if (!sessionId) return;
+	const stats = getOrCreateWebSocketDebugStats(sessionId);
+	stats.sseFallbacks++;
+	stats.websocketFallbackActive = isWebSocketSseFallbackActive(sessionId);
+}
+function recordWebSocketFailure(sessionId, error) {
+	if (!sessionId) return;
+	websocketSseFallbackSessions.add(sessionId);
+	const stats = getOrCreateWebSocketDebugStats(sessionId);
+	stats.websocketFailures++;
+	stats.lastWebSocketError = formatThrownValue(error);
+	stats.websocketFallbackActive = true;
+}
+let _cachedWebsocket = null;
+async function getWebSocketConstructor(env) {
+	if (!env && _cachedWebsocket) return _cachedWebsocket;
+	if (typeof process !== "undefined" && process.versions?.bun) {
+		const WebSocketWithProxy = class extends WebSocket {
+			constructor(url, options) {
+				let _opts = {};
+				if (Array.isArray(options) || typeof options === "string") _opts = { protocols: options };
+				else _opts = { ...options };
+				const proxyUrl = resolveHttpProxyUrlForTarget(url.toString().replace(/^wss:/, "https:").replace(/^ws:/, "http:"), env);
+				super(url, {
+					..._opts,
+					...proxyUrl ? { proxy: proxyUrl.toString() } : {}
+				});
+			}
+		};
+		if (!env) _cachedWebsocket = WebSocketWithProxy;
+		return WebSocketWithProxy;
+	}
+	const ctor = globalThis.WebSocket;
+	if (typeof ctor !== "function") return null;
+	return ctor;
+}
+var WebSocketCloseError = class extends Error {
+	code;
+	reason;
+	wasClean;
+	constructor(message, options) {
+		super(message);
+		this.name = "WebSocketCloseError";
+		this.code = options?.code;
+		this.reason = options?.reason;
+		this.wasClean = options?.wasClean;
+	}
+};
+function getWebSocketReadyState(socket) {
+	const readyState = socket.readyState;
+	return typeof readyState === "number" ? readyState : void 0;
+}
+function isWebSocketReusable(socket) {
+	const readyState = getWebSocketReadyState(socket);
+	return readyState === void 0 || readyState === 1;
+}
+function isWebSocketSessionExpired(entry) {
+	return Date.now() - entry.createdAt >= SESSION_WEBSOCKET_MAX_AGE_MS;
+}
+function closeWebSocketSilently(socket, code = 1e3, reason = "done") {
+	try {
+		socket.close(code, reason);
+	} catch {}
+}
+function scheduleSessionWebSocketExpiry(sessionId, accountId, entry) {
+	if (entry.idleTimer) clearTimeout(entry.idleTimer);
+	entry.idleTimer = setTimeout(() => {
+		if (entry.busy) return;
+		closeWebSocketSilently(entry.socket, 1e3, "idle_timeout");
+		const accountEntries = websocketSessionCache.get(sessionId);
+		if (accountEntries?.get(accountId) === entry) accountEntries.delete(accountId);
+		if (accountEntries?.size === 0) websocketSessionCache.delete(sessionId);
+	}, SESSION_WEBSOCKET_CACHE_TTL_MS);
+}
+async function connectWebSocket(url, headers, signal, connectTimeoutMs = DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS, env) {
+	const WebSocketCtor = await getWebSocketConstructor(env);
+	if (!WebSocketCtor) throw new Error("WebSocket transport is not available in this runtime");
+	const wsHeaders = headersToRecord(headers);
+	delete wsHeaders["OpenAI-Beta"];
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		let timeout;
+		let socket;
+		try {
+			socket = new WebSocketCtor(url, { headers: wsHeaders });
+		} catch (error) {
+			reject(error instanceof Error ? error : new Error(String(error)));
+			return;
+		}
+		const cleanup = () => {
+			if (timeout) {
+				clearTimeout(timeout);
+				timeout = void 0;
+			}
+			socket.removeEventListener("open", onOpen);
+			socket.removeEventListener("error", onError);
+			socket.removeEventListener("close", onClose);
+			signal?.removeEventListener("abort", onAbort);
+		};
+		const fail = (error, closeReason) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			if (closeReason) closeWebSocketSilently(socket, 1e3, closeReason);
+			reject(error);
+		};
+		const onOpen = () => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			resolve(socket);
+		};
+		const onError = (event) => {
+			fail(extractWebSocketError(event));
+		};
+		const onClose = (event) => {
+			fail(extractWebSocketCloseError(event));
+		};
+		const onAbort = () => {
+			fail(/* @__PURE__ */ new Error("Request was aborted"), "aborted");
+		};
+		socket.addEventListener("open", onOpen);
+		socket.addEventListener("error", onError);
+		socket.addEventListener("close", onClose);
+		signal?.addEventListener("abort", onAbort);
+		if (connectTimeoutMs > 0) timeout = setTimeout(() => {
+			fail(/* @__PURE__ */ new Error(`WebSocket connect timeout after ${connectTimeoutMs}ms`), "connect_timeout");
+		}, connectTimeoutMs);
+		if (signal?.aborted) onAbort();
+	});
+}
+async function acquireWebSocket(url, headers, sessionId, accountId, signal, connectTimeoutMs, env) {
+	if (!sessionId) {
+		const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs, env);
+		return {
+			socket,
+			reused: false,
+			release: () => closeWebSocketSilently(socket)
+		};
+	}
+	let accountEntries = websocketSessionCache.get(sessionId);
+	const cached = accountEntries?.get(accountId);
+	if (cached) {
+		if (cached.idleTimer) {
+			clearTimeout(cached.idleTimer);
+			cached.idleTimer = void 0;
+		}
+		if (!cached.busy && isWebSocketSessionExpired(cached)) {
+			closeWebSocketSilently(cached.socket, 1e3, "connection_age_limit");
+			accountEntries?.delete(accountId);
+			if (accountEntries?.size === 0) websocketSessionCache.delete(sessionId);
+		} else if (!cached.busy && isWebSocketReusable(cached.socket)) {
+			cached.busy = true;
+			return {
+				socket: cached.socket,
+				entry: cached,
+				reused: true,
+				release: ({ keep } = {}) => {
+					if (!keep || !isWebSocketReusable(cached.socket)) {
+						closeWebSocketSilently(cached.socket);
+						const currentEntries = websocketSessionCache.get(sessionId);
+						if (currentEntries?.get(accountId) === cached) currentEntries.delete(accountId);
+						if (currentEntries?.size === 0) websocketSessionCache.delete(sessionId);
+						return;
+					}
+					cached.busy = false;
+					scheduleSessionWebSocketExpiry(sessionId, accountId, cached);
+				}
+			};
+		}
+		if (cached.busy) {
+			const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs, env);
+			return {
+				socket,
+				reused: false,
+				release: () => {
+					closeWebSocketSilently(socket);
+				}
+			};
+		}
+		if (!isWebSocketReusable(cached.socket)) {
+			closeWebSocketSilently(cached.socket);
+			accountEntries?.delete(accountId);
+			if (accountEntries?.size === 0) websocketSessionCache.delete(sessionId);
+		}
+	}
+	const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs, env);
+	const entry = {
+		socket,
+		busy: true,
+		createdAt: Date.now()
+	};
+	accountEntries = websocketSessionCache.get(sessionId);
+	if (!accountEntries) {
+		accountEntries = /* @__PURE__ */ new Map();
+		websocketSessionCache.set(sessionId, accountEntries);
+	}
+	accountEntries.set(accountId, entry);
+	return {
+		socket,
+		entry,
+		reused: false,
+		release: ({ keep } = {}) => {
+			if (!keep || !isWebSocketReusable(entry.socket)) {
+				closeWebSocketSilently(entry.socket);
+				if (entry.idleTimer) clearTimeout(entry.idleTimer);
+				const currentEntries = websocketSessionCache.get(sessionId);
+				if (currentEntries?.get(accountId) === entry) currentEntries.delete(accountId);
+				if (currentEntries?.size === 0) websocketSessionCache.delete(sessionId);
+				return;
+			}
+			entry.busy = false;
+			scheduleSessionWebSocketExpiry(sessionId, accountId, entry);
+		}
+	};
+}
+function extractWebSocketError(event) {
+	if (event && typeof event === "object") {
+		const message = "message" in event ? event.message : void 0;
+		if (typeof message === "string" && message.length > 0) return new Error(message);
+		const nestedError = "error" in event ? event.error : void 0;
+		if (nestedError instanceof Error && nestedError.message.length > 0) return nestedError;
+		if (nestedError && typeof nestedError === "object" && "message" in nestedError) {
+			const nestedMessage = nestedError.message;
+			if (typeof nestedMessage === "string" && nestedMessage.length > 0) return new Error(nestedMessage);
+		}
+	}
+	return /* @__PURE__ */ new Error("WebSocket error");
+}
+function extractWebSocketCloseError(event) {
+	if (event && typeof event === "object") {
+		const code = "code" in event ? event.code : void 0;
+		const reason = "reason" in event ? event.reason : void 0;
+		const wasClean = "wasClean" in event ? event.wasClean : void 0;
+		const codeText = typeof code === "number" ? ` ${code}` : "";
+		let reasonText = typeof reason === "string" && reason.length > 0 ? ` ${reason}` : "";
+		if (!reasonText && code === WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE) reasonText = " message too big";
+		return new WebSocketCloseError(`WebSocket closed${codeText}${reasonText}`.trim(), {
+			code: typeof code === "number" ? code : void 0,
+			reason: typeof reason === "string" && reason.length > 0 ? reason : void 0,
+			wasClean: typeof wasClean === "boolean" ? wasClean : void 0
+		});
+	}
+	return /* @__PURE__ */ new Error("WebSocket closed");
+}
+async function decodeWebSocketData(data) {
+	if (typeof data === "string") return data;
+	if (data instanceof ArrayBuffer) return new TextDecoder().decode(new Uint8Array(data));
+	if (ArrayBuffer.isView(data)) {
+		const view = data;
+		return new TextDecoder().decode(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+	}
+	if (data && typeof data === "object" && "arrayBuffer" in data) {
+		const arrayBuffer = await data.arrayBuffer();
+		return new TextDecoder().decode(new Uint8Array(arrayBuffer));
+	}
+	return null;
+}
+async function* parseWebSocket(socket, signal, idleTimeoutMs) {
+	const queue = [];
+	let pending = null;
+	let done = false;
+	let failed = null;
+	let sawCompletion = false;
+	const wake = () => {
+		if (!pending) return;
+		const resolve = pending;
+		pending = null;
+		resolve();
+	};
+	const onMessage = (event) => {
+		(async () => {
+			let text = null;
+			try {
+				if (!event || typeof event !== "object" || !("data" in event)) return;
+				text = await decodeWebSocketData(event.data);
+				if (!text) return;
+				const parsed = JSON.parse(text);
+				const type = typeof parsed.type === "string" ? parsed.type : "";
+				if (type === "response.completed" || type === "response.done" || type === "response.incomplete") {
+					sawCompletion = true;
+					done = true;
+				}
+				queue.push(parsed);
+				wake();
+			} catch (cause) {
+				failed = new CodexProtocolError(`Invalid Codex WebSocket JSON: ${formatThrownValue(cause)}`, {
+					cause,
+					payload: text
+				});
+				done = true;
+				wake();
+			}
+		})();
+	};
+	const onError = (event) => {
+		failed = extractWebSocketError(event);
+		done = true;
+		wake();
+	};
+	const onClose = (event) => {
+		if (sawCompletion) {
+			done = true;
+			wake();
+			return;
+		}
+		if (!failed) failed = extractWebSocketCloseError(event);
+		done = true;
+		wake();
+	};
+	const onAbort = () => {
+		failed = /* @__PURE__ */ new Error("Request was aborted");
+		done = true;
+		wake();
+	};
+	socket.addEventListener("message", onMessage);
+	socket.addEventListener("error", onError);
+	socket.addEventListener("close", onClose);
+	signal?.addEventListener("abort", onAbort);
+	try {
+		while (true) {
+			if (signal?.aborted) throw new Error("Request was aborted");
+			if (queue.length > 0) {
+				yield queue.shift();
+				continue;
+			}
+			if (done) break;
+			let timeout;
+			await new Promise((resolve, reject) => {
+				pending = resolve;
+				if (idleTimeoutMs !== void 0 && idleTimeoutMs > 0) timeout = setTimeout(() => {
+					const error = /* @__PURE__ */ new Error(`WebSocket idle timeout after ${idleTimeoutMs}ms`);
+					failed = error;
+					done = true;
+					pending = null;
+					closeWebSocketSilently(socket, 1e3, "idle_timeout");
+					reject(error);
+				}, idleTimeoutMs);
+			}).finally(() => {
+				if (timeout) clearTimeout(timeout);
+			});
+		}
+		if (failed) throw failed;
+		if (!sawCompletion) throw new Error("WebSocket stream closed before response.completed");
+	} finally {
+		socket.removeEventListener("message", onMessage);
+		socket.removeEventListener("error", onError);
+		socket.removeEventListener("close", onClose);
+		signal?.removeEventListener("abort", onAbort);
+	}
+}
+function requestBodyWithoutInput(body) {
+	const { input: _input, previous_response_id: _previousResponseId, ...rest } = body;
+	return rest;
+}
+function responseInputsEqual(a, b) {
+	return JSON.stringify(a ?? []) === JSON.stringify(b ?? []);
+}
+function requestBodiesMatchExceptInput(a, b) {
+	return JSON.stringify(requestBodyWithoutInput(a)) === JSON.stringify(requestBodyWithoutInput(b));
+}
+function getCachedWebSocketInputDelta(body, continuation) {
+	if (!requestBodiesMatchExceptInput(body, continuation.lastRequestBody)) return;
+	const currentInput = body.input ?? [];
+	const baseline = [...continuation.lastRequestBody.input ?? [], ...continuation.lastResponseItems];
+	if (currentInput.length < baseline.length) return;
+	if (!responseInputsEqual(currentInput.slice(0, baseline.length), baseline)) return;
+	return currentInput.slice(baseline.length);
+}
+function buildCachedWebSocketRequestBody(entry, body) {
+	const continuation = entry.continuation;
+	if (!continuation) return body;
+	const delta = getCachedWebSocketInputDelta(body, continuation);
+	if (!delta || !continuation.lastResponseId) {
+		entry.continuation = void 0;
+		return body;
+	}
+	return {
+		...body,
+		previous_response_id: continuation.lastResponseId,
+		input: delta
+	};
+}
+async function* startWebSocketOutputOnFirstEvent(events, onStart) {
+	let started = false;
+	for await (const event of events) {
+		if (!started) {
+			started = true;
+			onStart();
+		}
+		yield event;
+	}
+}
+async function processWebSocketStream(url, body, headers, output, stream, model, onStart, idleTimeoutMs, websocketConnectTimeoutMs, cacheSessionId, accountId, grammarToolInputProperties, options) {
+	const { socket, entry, reused, release } = await acquireWebSocket(url, headers, cacheSessionId, accountId, options?.signal, websocketConnectTimeoutMs, options?.env);
+	let keepConnection = true;
+	const useCachedContext = options?.transport === "websocket-cached" || options?.transport === "auto";
+	const fullBody = body;
+	const requestBody = useCachedContext && entry ? buildCachedWebSocketRequestBody(entry, fullBody) : fullBody;
+	const stats = cacheSessionId ? getOrCreateWebSocketDebugStats(cacheSessionId) : void 0;
+	if (stats) {
+		stats.requests++;
+		if (reused) stats.connectionsReused++;
+		else stats.connectionsCreated++;
+		if (useCachedContext) stats.cachedContextRequests++;
+		if (requestBody.store === true) stats.storeTrueRequests++;
+		stats.lastInputItems = requestBody.input?.length ?? 0;
+		if (requestBody.previous_response_id) {
+			stats.deltaRequests++;
+			stats.lastDeltaInputItems = requestBody.input?.length ?? 0;
+			stats.lastPreviousResponseId = requestBody.previous_response_id;
+		} else {
+			stats.fullContextRequests++;
+			stats.lastDeltaInputItems = void 0;
+			stats.lastPreviousResponseId = void 0;
+		}
+	}
+	try {
+		socket.send(JSON.stringify({
+			type: "response.create",
+			...requestBody
+		}));
+		await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal, idleTimeoutMs), output), onStart), output, stream, model, {
+			serviceTier: options?.serviceTier,
+			grammarToolInputProperties,
+			resolveServiceTier: resolveCodexServiceTier,
+			applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model)
+		});
+		if (options?.signal?.aborted) keepConnection = false;
+		else if (useCachedContext && entry && output.responseId) {
+			const responseItems = convertResponsesMessages(model, { messages: [output] }, CODEX_TOOL_CALL_PROVIDERS, {
+				includeSystemPrompt: false,
+				grammarToolInputProperties
+			}).filter((item) => item.type !== "function_call_output" && item.type !== "custom_tool_call_output");
+			entry.continuation = {
+				lastRequestBody: fullBody,
+				lastResponseId: output.responseId,
+				lastResponseItems: responseItems
+			};
+		}
+	} catch (error) {
+		if (entry) entry.continuation = void 0;
+		keepConnection = false;
+		throw error;
+	} finally {
+		release({ keep: keepConnection });
+	}
+}
+async function parseErrorResponse(response) {
+	const raw = await response.text();
+	let message = raw || response.statusText || "Request failed";
+	let friendlyMessage;
+	try {
+		const err = JSON.parse(raw)?.error;
+		if (err) {
+			const code = err.code || err.type || "";
+			if (/usage_limit_reached|usage_not_included|rate_limit_exceeded/i.test(code) || response.status === 429) {
+				const plan = err.plan_type ? ` (${err.plan_type.toLowerCase()} plan)` : "";
+				const mins = err.resets_at ? Math.max(0, Math.round((err.resets_at * 1e3 - Date.now()) / 6e4)) : void 0;
+				friendlyMessage = `You have hit your ChatGPT usage limit${plan}.${mins !== void 0 ? ` Try again in ~${mins} min.` : ""}`.trim();
+			}
+			message = err.message || friendlyMessage || message;
+		}
+	} catch {}
+	return {
+		message,
+		friendlyMessage
+	};
+}
+function extractAccountId(token) {
+	try {
+		const parts = token.split(".");
+		if (parts.length !== 3) throw new Error("Invalid token");
+		const accountId = JSON.parse(atob(parts[1]))?.[JWT_CLAIM_PATH]?.chatgpt_account_id;
+		if (!accountId) throw new Error("No account ID in token");
+		return accountId;
+	} catch {
+		throw new Error("Failed to extract accountId from token");
+	}
+}
+function buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token) {
+	const headers = new Headers(initHeaders);
+	for (const [key, value] of Object.entries(additionalHeaders || {})) if (value === null) headers.delete(key);
+	else headers.set(key, value);
+	headers.set("Authorization", `Bearer ${token}`);
+	headers.set("chatgpt-account-id", accountId);
+	headers.set("originator", "pi");
+	headers.set("User-Agent", getPiUserAgent());
+	return headers;
+}
+function buildSSEHeaders(initHeaders, additionalHeaders, accountId, token, sessionId) {
+	const headers = buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token);
+	headers.set("OpenAI-Beta", "responses=experimental");
+	headers.set("accept", "text/event-stream");
+	headers.set("content-type", "application/json");
+	if (sessionId) {
+		headers.set("session-id", sessionId);
+		headers.set("x-client-request-id", sessionId);
+	}
+	return headers;
+}
+function buildWebSocketHeaders(initHeaders, additionalHeaders, accountId, token, requestId) {
+	const headers = buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token);
+	headers.delete("accept");
+	headers.delete("content-type");
+	headers.delete("OpenAI-Beta");
+	headers.delete("openai-beta");
+	headers.set("OpenAI-Beta", OPENAI_BETA_RESPONSES_WEBSOCKETS);
+	headers.set("x-client-request-id", requestId);
+	headers.set("session-id", requestId);
+	return headers;
+}
+//#endregion
+export { closeOpenAICodexWebSocketSessions, getOpenAICodexWebSocketDebugStats, resetOpenAICodexWebSocketDebugStats, stream, streamSimple };