pi2dsh 0.13.2 → 0.14.0

package/dist/pi-ai-DpqiLdPA.mjs

@@ -0,0 +1,3244 @@
+
+import { i as __require } from "./rolldown-runtime-CTfmNlz1.mjs";
+import { t as AssistantMessageEventStream$1 } from "./event-stream-QxN1yvIF.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { Type as Type$1 } from "typebox";
+//#region src/compat/vendor/pi-uuid.ts
+let lastTimestamp = -Infinity;
+let sequence = 0;
+function fillRandomBytes(bytes) {
+	if (globalThis.crypto?.getRandomValues) {
+		globalThis.crypto.getRandomValues(bytes);
+		return;
+	}
+	for (let i = 0; i < bytes.length; i++) bytes[i] = Math.floor(Math.random() * 256);
+}
+/** Generate a time-ordered UUIDv7. */
+function uuidv7() {
+	const random = /* @__PURE__ */ new Uint8Array(16);
+	fillRandomBytes(random);
+	const timestamp = Date.now();
+	if (timestamp > lastTimestamp) {
+		sequence = random[6] * 16777216 + random[7] * 65536 + random[8] * 256 + random[9];
+		lastTimestamp = timestamp;
+	} else {
+		sequence = sequence + 1 >>> 0;
+		if (sequence === 0) lastTimestamp++;
+	}
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	bytes[0] = lastTimestamp / 1099511627776 & 255;
+	bytes[1] = lastTimestamp / 4294967296 & 255;
+	bytes[2] = lastTimestamp / 16777216 & 255;
+	bytes[3] = lastTimestamp / 65536 & 255;
+	bytes[4] = lastTimestamp / 256 & 255;
+	bytes[5] = lastTimestamp & 255;
+	bytes[6] = 112 | sequence >>> 28 & 15;
+	bytes[7] = sequence >>> 20 & 255;
+	bytes[8] = 128 | sequence >>> 14 & 63;
+	bytes[9] = sequence >>> 6 & 255;
+	bytes[10] = (sequence & 63) << 2 | random[10] & 3;
+	bytes[11] = random[11];
+	bytes[12] = random[12];
+	bytes[13] = random[13];
+	bytes[14] = random[14];
+	bytes[15] = random[15];
+	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, 16).join("")}`;
+}
+//#endregion
+//#region src/compat/vendor/pi-ai-retry.ts
+function buildProviderErrorPattern(patterns) {
+	return new RegExp(patterns.join("|"), "i");
+}
+const NON_RETRYABLE_PROVIDER_LIMIT_ERROR_PATTERN = buildProviderErrorPattern([
+	"GoUsageLimitError",
+	"FreeUsageLimitError",
+	"Monthly usage limit reached",
+	"available balance",
+	"insufficient_quota",
+	"out of budget",
+	"quota exceeded",
+	"billing"
+]);
+const RETRYABLE_PROVIDER_ERROR_PATTERN = buildProviderErrorPattern([
+	"overloaded",
+	"rate.?limit",
+	"too many requests",
+	"429",
+	"500",
+	"502",
+	"503",
+	"504",
+	"524",
+	"service.?unavailable",
+	"server.?error",
+	"internal.?error",
+	"provider.?returned.?error",
+	"exceeded request buffer limit while retrying upstream",
+	"network.?error",
+	"connection.?error",
+	"connection.?refused",
+	"connection.?lost",
+	"other side closed",
+	"fetch failed",
+	"getaddrinfo",
+	"ENOTFOUND",
+	"EAI_AGAIN",
+	"upstream.?connect",
+	"reset before headers",
+	"socket hang up",
+	"socket connection was closed",
+	"timed? out",
+	"timeout",
+	"terminated",
+	"websocket.?closed",
+	"websocket.?error",
+	"ended without",
+	"stream ended before message_stop",
+	"stream ended before a terminal response event",
+	"http2 request did not get a response",
+	"retry delay",
+	"you can retry your request",
+	"try your request again",
+	"please retry your request",
+	"ResourceExhausted"
+]);
+var RetrySleepAbortError = class extends Error {
+	constructor() {
+		super("Aborted");
+	}
+};
+function sleep$1(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(new RetrySleepAbortError());
+			return;
+		}
+		const timeout = setTimeout(resolve, ms);
+		signal?.addEventListener("abort", () => {
+			clearTimeout(timeout);
+			reject(new RetrySleepAbortError());
+		}, { once: true });
+	});
+}
+/**
+* Run a single assistant-producing call with bounded retry on transient errors.
+*
+* Behavior:
+* - A successful response is returned immediately. Aborts are terminal and never
+*   retried, but reported as unsuccessful if they happen after a retry was scheduled.
+*   Aborts during the backoff sleep are normalized to an aborted `AssistantMessage`
+*   too, so callers do not need to care when cancellation happened.
+* - A non-retryable error (per {@link isRetryableAssistantError}, including quota/
+*   billing exhaustion) is returned immediately so deterministic errors fail fast.
+* - Otherwise retries up to `maxRetries` times with exponential backoff, emitting
+*   `onRetryScheduled` before each sleep, `onRetryAttemptStart` after each sleep before
+*   the retried call starts, and `onRetryFinished` once at the end (whether the loop
+*   ends in success, exhausted retries, or an aborted backoff).
+*
+* When `policy` is undefined or disabled, the first response is returned unchanged
+* (equivalent to calling `produce()` directly).
+*/
+async function retryAssistantCall(produce, policy, signal, callbacks) {
+	const maxAttempts = policy?.enabled ? policy.maxRetries : 0;
+	let attempt = 0;
+	let lastRetry;
+	for (;;) {
+		const response = await produce();
+		if (response.stopReason === "aborted") {
+			if (lastRetry) await callbacks?.onRetryFinished?.(false, lastRetry.attempt);
+			return response;
+		}
+		if (response.stopReason !== "error") {
+			if (lastRetry) await callbacks?.onRetryFinished?.(true, lastRetry.attempt);
+			return response;
+		}
+		if (attempt >= maxAttempts || !isRetryableAssistantError(response)) {
+			if (lastRetry) await callbacks?.onRetryFinished?.(false, lastRetry.attempt, response.errorMessage);
+			return response;
+		}
+		attempt++;
+		lastRetry = {
+			attempt,
+			errorMessage: response.errorMessage || "Unknown error"
+		};
+		const delayMs = policy.baseDelayMs * 2 ** (attempt - 1);
+		await callbacks?.onRetryScheduled?.(attempt, maxAttempts, delayMs, lastRetry.errorMessage);
+		try {
+			await sleep$1(delayMs, signal);
+		} catch (error) {
+			await callbacks?.onRetryFinished?.(false, attempt, lastRetry.errorMessage);
+			if (error instanceof RetrySleepAbortError) return {
+				...response,
+				stopReason: "aborted",
+				errorMessage: void 0
+			};
+			throw error;
+		}
+		await callbacks?.onRetryAttemptStart?.();
+	}
+}
+/**
+* Classifies whether a failed assistant message looks like a transient provider
+* or transport error, so callers can decide if the last assistant turn should be
+* restarted.
+*
+* This does not implement retry policy. Callers should first handle context
+* overflow separately, then apply their own retry budget, backoff, and reporting
+* before restarting the assistant turn.
+*/
+function isRetryableAssistantError(message) {
+	if (message.stopReason !== "error" || !message.errorMessage) return false;
+	const errorMessage = message.errorMessage;
+	if (NON_RETRYABLE_PROVIDER_LIMIT_ERROR_PATTERN.test(errorMessage)) return false;
+	return RETRYABLE_PROVIDER_ERROR_PATTERN.test(errorMessage);
+}
+//#endregion
+//#region src/compat/vendor/pi-ai-overflow.ts
+/**
+* Regex patterns to detect context overflow errors from different providers.
+*
+* These patterns match error messages returned when the input exceeds
+* the model's context window.
+*
+* Provider-specific patterns (with example error messages):
+*
+* - Anthropic: "prompt is too long: 213462 tokens > 200000 maximum"
+* - Anthropic: "413 {\"error\":{\"type\":\"request_too_large\",\"message\":\"Request exceeds the maximum size\"}}"
+* - OpenAI: "Your input exceeds the context window of this model"
+* - OpenAI/LiteLLM: "Requested token count exceeds the model's maximum context length of 131072 tokens"
+* - OpenAI-compatible: "Input length (265330) exceeds model's maximum context length (262144)."
+* - Google: "The input token count (1196265) exceeds the maximum number of tokens allowed (1048575)"
+* - xAI: "This model's maximum prompt length is 131072 but the request contains 537812 tokens"
+* - Groq: "Please reduce the length of the messages or completion"
+* - OpenRouter: "This endpoint's maximum context length is X tokens. However, you requested about Y tokens"
+* - OpenRouter/Poolside: "Input length X exceeds the maximum allowed input length of Y tokens."
+* - Together AI: "The input (X tokens) is longer than the model's context length (Y tokens)."
+* - llama.cpp: "the request exceeds the available context size, try increasing it"
+* - LM Studio: "tokens to keep from the initial prompt is greater than the context length"
+* - GitHub Copilot: "prompt token count of X exceeds the limit of Y"
+* - MiniMax: "invalid params, context window exceeds limit"
+* - Kimi For Coding: "Your request exceeded model token limit: X (requested: Y)"
+* - DS4: "Prompt has X tokens, but the configured context size is Y tokens"
+* - Cerebras: "400/413 status code (no body)"
+* - Mistral: "Prompt contains X tokens ... too large for model with Y maximum context length"
+* - z.ai: Does NOT error, accepts overflow silently - handled via usage.input > contextWindow
+* - Xiaomi MiMo: Truncates input to fill contextWindow exactly, then returns finish_reason "length"
+*   with output=0 (no room left to generate). Detected via stopReason "length" + zero output +
+*   input filling the context window.
+* - DashScope/Qwen: "Range of input length should be [1, X]" (HTTP 400 invalid_parameter_error)
+* - Ollama: Some deployments truncate silently, others return errors like "prompt too long; exceeded max context length by X tokens"
+*/
+const OVERFLOW_PATTERNS = [
+	/prompt is too long/i,
+	/request_too_large/i,
+	/input is too long for requested model/i,
+	/exceeds the context window/i,
+	/exceeds (?:the )?(?:model'?s )?maximum context length(?: of [\d,]+ tokens?|\s*\([\d,]+\))/i,
+	/input token count.*exceeds the maximum/i,
+	/maximum prompt length is \d+/i,
+	/reduce the length of the messages/i,
+	/maximum context length is \d+ tokens/i,
+	/exceeds (?:the )?maximum allowed input length of [\d,]+ tokens?/i,
+	/input \(\d+ tokens\) is longer than the model'?s context length \(\d+ tokens\)/i,
+	/exceeds the limit of \d+/i,
+	/exceeds the available context size/i,
+	/greater than the context length/i,
+	/context window exceeds limit/i,
+	/exceeded model token limit/i,
+	/too large for model with \d+ maximum context length/i,
+	/prompt has [\d,]+ tokens?, but the configured context size is [\d,]+ tokens?/i,
+	/model_context_window_exceeded/i,
+	/prompt too long; exceeded (?:max )?context length/i,
+	/range of input length should be/i,
+	/context[_ ]length[_ ]exceeded/i,
+	/too many tokens/i,
+	/token limit exceeded/i,
+	/^4(?:00|13)\s*(?:status code)?\s*\(no body\)/i
+];
+/**
+* Patterns that indicate non-overflow errors (e.g. rate limiting, server errors).
+* Error messages matching any of these are excluded from overflow detection
+* even if they also match an OVERFLOW_PATTERN.
+*
+* Example: Bedrock formats throttling errors as "ThrottlingException: Too many tokens,
+* please wait before trying again." which would match the /too many tokens/i overflow
+* pattern without this exclusion.
+*/
+const NON_OVERFLOW_PATTERNS = [
+	/^(Throttling error|Service unavailable):/i,
+	/rate limit/i,
+	/too many requests/i
+];
+/**
+* Check if an assistant message represents a context overflow error.
+*
+* This handles three cases:
+* 1. Error-based overflow: Most providers return stopReason "error" with a
+*    specific error message pattern.
+* 2. Silent overflow: Some providers accept overflow requests and return
+*    successfully. For these, we check if usage.input exceeds the context window.
+* 3. Length-stop overflow: Xiaomi MiMo can return "length" with zero output when
+*    the input fills the context window.
+*
+* ## Reliability by Provider
+*
+* **Reliable detection (returns error with detectable message):**
+* - Anthropic: "prompt is too long: X tokens > Y maximum" or "request_too_large"
+* - OpenAI (Completions & Responses): "exceeds the context window", "exceeds the model's maximum context length of X tokens", or "exceeds model's maximum context length (X)"
+* - Google Gemini: "input token count exceeds the maximum"
+* - xAI (Grok): "maximum prompt length is X but request contains Y"
+* - Groq: "reduce the length of the messages"
+* - Cerebras: 400/413 status code (no body)
+* - Mistral: "Prompt contains X tokens ... too large for model with Y maximum context length"
+* - OpenRouter (most backends): "maximum context length is X tokens"
+* - OpenRouter/Poolside: "Input length X exceeds the maximum allowed input length of Y tokens."
+* - Together AI: "The input (X tokens) is longer than the model's context length (Y tokens)."
+* - llama.cpp: "exceeds the available context size"
+* - LM Studio: "greater than the context length"
+* - Kimi For Coding: "exceeded model token limit: X (requested: Y)"
+* - DS4: "Prompt has X tokens, but the configured context size is Y tokens"
+* - DashScope/Qwen: "Range of input length should be [1, X]"
+*
+* **Unreliable detection:**
+* - z.ai: Sometimes accepts overflow silently (detectable via usage.input > contextWindow),
+*   sometimes returns rate limit errors. Pass contextWindow param to detect silent overflow.
+* - Xiaomi MiMo: Truncates input to fit contextWindow then returns stopReason "length" with
+*   output=0. Pass contextWindow param to detect via the "filled context + zero output" signal.
+* - Ollama: May truncate input silently for some setups, but may also return explicit
+*   overflow errors that match the patterns above. Silent truncation still cannot be
+*   detected here because we do not know the expected token count.
+*
+* ## Custom Providers
+*
+* If you've added custom models via settings.json, this function may not detect
+* overflow errors from those providers. To add support:
+*
+* 1. Send a request that exceeds the model's context window
+* 2. Check the errorMessage in the response
+* 3. Create a regex pattern that matches the error
+* 4. The pattern should be added to OVERFLOW_PATTERNS in this file, or
+*    check the errorMessage yourself before calling this function
+*
+* @param message - The assistant message to check
+* @param contextWindow - Optional context window size for detecting silent overflow (z.ai)
+* @returns true if the message indicates a context overflow
+*/
+function isContextOverflow(message, contextWindow) {
+	if (message.stopReason === "error" && message.errorMessage) {
+		if (!NON_OVERFLOW_PATTERNS.some((p) => p.test(message.errorMessage)) && OVERFLOW_PATTERNS.some((p) => p.test(message.errorMessage))) return true;
+	}
+	if (contextWindow && message.stopReason === "stop") {
+		if (message.usage.input + message.usage.cacheRead > contextWindow) return true;
+	}
+	if (contextWindow && message.stopReason === "length" && message.usage.output === 0) {
+		if (message.usage.input + message.usage.cacheRead >= contextWindow * .99) return true;
+	}
+	return false;
+}
+/**
+* Check whether a length stop ended below the caller or model's intended output limit.
+* Such responses may be caused by context pressure or provider-side truncation, so callers
+* can make one bounded compact-and-retry attempt. `desiredMaxOutput` must be the original
+* limit before any context-based clamping.
+*/
+function isRecoverableLength(message, desiredMaxOutput) {
+	return message.stopReason === "length" && desiredMaxOutput > 0 && message.usage.output < desiredMaxOutput;
+}
+//#endregion
+//#region src/compat/vendor/pi-ai-event-stream.ts
+var EventStream = class {
+	queue = [];
+	waiting = [];
+	done = false;
+	finalResultPromise;
+	resolveFinalResult;
+	isComplete;
+	extractResult;
+	constructor(isComplete, extractResult) {
+		this.isComplete = isComplete;
+		this.extractResult = extractResult;
+		this.finalResultPromise = new Promise((resolve) => {
+			this.resolveFinalResult = resolve;
+		});
+	}
+	push(event) {
+		if (this.done) return;
+		if (this.isComplete(event)) {
+			this.done = true;
+			this.resolveFinalResult(this.extractResult(event));
+		}
+		const waiter = this.waiting.shift();
+		if (waiter) waiter({
+			value: event,
+			done: false
+		});
+		else this.queue.push(event);
+	}
+	end(result) {
+		this.done = true;
+		if (result !== void 0) this.resolveFinalResult(result);
+		while (this.waiting.length > 0) this.waiting.shift()({
+			value: void 0,
+			done: true
+		});
+	}
+	async *[Symbol.asyncIterator]() {
+		while (true) if (this.queue.length > 0) yield this.queue.shift();
+		else if (this.done) return;
+		else {
+			const result = await new Promise((resolve) => this.waiting.push(resolve));
+			if (result.done) return;
+			yield result.value;
+		}
+	}
+	result() {
+		return this.finalResultPromise;
+	}
+};
+var AssistantMessageEventStream = class extends EventStream {
+	constructor() {
+		super((event) => event.type === "done" || event.type === "error", (event) => {
+			if (event.type === "done") return event.message;
+			else if (event.type === "error") return event.error;
+			throw new Error("Unexpected event type for final result");
+		});
+	}
+};
+//#endregion
+//#region src/compat/vendor/pi-ai-lazy.ts
+function createSetupErrorMessage$1(model, error) {
+	return {
+		role: "assistant",
+		content: [],
+		api: model.api,
+		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: "error",
+		errorMessage: error instanceof Error ? error.message : String(error),
+		timestamp: Date.now()
+	};
+}
+function hasResult$1(source) {
+	return typeof source.result === "function";
+}
+async function forwardStream$1(target, source) {
+	for await (const event of source) target.push(event);
+	target.end(hasResult$1(source) ? await source.result() : void 0);
+}
+/**
+* Returns a stream synchronously while running async setup (auth resolution,
+* lazy module loading) behind it. Setup failures terminate the stream with an
+* error event.
+*/
+function lazyStream$1(model, setup) {
+	const outer = new AssistantMessageEventStream();
+	setup().then((inner) => forwardStream$1(outer, inner)).catch((error) => {
+		const message = createSetupErrorMessage$1(model, error);
+		outer.push({
+			type: "error",
+			reason: "error",
+			error: message
+		});
+		outer.end(message);
+	});
+	return outer;
+}
+function lazyApi$1(load, capabilities) {
+	const api = {
+		stream: (model, context, options) => lazyStream$1(model, async () => (await load()).stream(model, context, options)),
+		streamSimple: (model, context, options) => lazyStream$1(model, async () => (await load()).streamSimple(model, context, options))
+	};
+	if (capabilities?.fetchDeferred) api.fetchDeferred = (model, handle, options) => lazyStream$1(model, async () => {
+		const implementation = await load();
+		if (!implementation.fetchDeferred) throw new Error("API does not support deferred responses");
+		return implementation.fetchDeferred(model, handle, options);
+	});
+	if (capabilities?.cancelDeferred) api.cancelDeferred = async (model, handle, options) => {
+		const implementation = await load();
+		if (!implementation.cancelDeferred) throw new Error("API cannot cancel deferred responses");
+		await implementation.cancelDeferred(model, handle, options);
+	};
+	return api;
+}
+//#endregion
+//#region src/compat/vendor/pi-ai-provider.ts
+function withCauseDetail(message, cause) {
+	if (cause === void 0 || cause === null) return message;
+	const detail = formatThrownValue(cause).trim();
+	if (!detail || message.includes(detail)) return message;
+	return `${message}: ${detail}`;
+}
+var ModelsError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(withCauseDetail(message, options?.cause), options);
+		this.name = "ModelsError";
+		this.code = code;
+	}
+};
+/**
+* Builds a provider from parts. Built-in provider factories and models.json
+* custom providers both go through this. A single `api` streams all models;
+* an `api` map dispatches on `model.api`, and a model whose api has no entry
+* produces a stream error.
+*/
+function createProvider(input) {
+	const baselineModels = input.models;
+	let dynamicModels = [];
+	const fetchModels = input.fetchModels;
+	const currentModels = () => {
+		const merged = [...baselineModels];
+		for (const model of dynamicModels) {
+			const index = merged.findIndex((entry) => entry.id === model.id);
+			if (index >= 0) merged[index] = model;
+			else merged.push(model);
+		}
+		return merged;
+	};
+	const single = typeof input.api.stream === "function" ? input.api : void 0;
+	const byApi = single ? void 0 : input.api;
+	const apiFor = (model) => single ?? byApi?.[model.api];
+	const dispatch = (model, run) => {
+		const streams = apiFor(model);
+		if (!streams) return lazyStream$1(model, async () => {
+			throw new ModelsError("stream", `Provider ${input.id} has no API implementation for "${model.api}"`);
+		});
+		return run(streams);
+	};
+	const provider = {
+		id: input.id,
+		name: input.name ?? input.id,
+		baseUrl: input.baseUrl,
+		headers: input.headers,
+		auth: input.auth,
+		getModels: currentModels,
+		refreshModels: fetchModels ? async (context) => {
+			if (context.stored) {
+				const restored = context.stored.models.filter((model) => model.provider === input.id).map((model) => model);
+				if (!await context.publish({ update: () => {
+					dynamicModels = restored;
+				} })) return;
+			}
+			if (!context.allowNetwork || context.signal.aborted) return;
+			const refreshed = await fetchModels(context);
+			if (context.signal.aborted) return;
+			await context.publish({
+				persist: {
+					models: refreshed,
+					checkedAt: Date.now()
+				},
+				update: () => {
+					dynamicModels = refreshed;
+				}
+			});
+		} : void 0,
+		filterModels: input.filterModels,
+		stream: (model, context, options) => dispatch(model, (streams) => streams.stream(model, context, options)),
+		streamSimple: (model, context, options) => dispatch(model, (streams) => streams.streamSimple(model, context, options))
+	};
+	const streams = single ? [single] : Object.values(byApi ?? {}).filter((entry) => entry !== void 0);
+	if (streams.some((entry) => entry.fetchDeferred !== void 0)) provider.fetchDeferred = (model, handle, options) => lazyStream$1(model, async () => {
+		const implementation = apiFor(model);
+		if (!implementation?.fetchDeferred) throw new ModelsError("provider", `Provider ${input.id} does not support deferred responses for "${model.api}"`);
+		return implementation.fetchDeferred(model, handle, options);
+	});
+	if (streams.some((entry) => entry.cancelDeferred !== void 0)) provider.cancelDeferred = async (model, handle, options) => {
+		const implementation = apiFor(model);
+		if (!implementation?.cancelDeferred) throw new ModelsError("provider", `Provider ${input.id} cannot cancel deferred responses for "${model.api}"`);
+		await implementation.cancelDeferred(model, handle, options);
+	};
+	return provider;
+}
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/api/lazy.js
+function createSetupErrorMessage(model, error) {
+	return {
+		role: "assistant",
+		content: [],
+		api: model.api,
+		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: "error",
+		errorMessage: error instanceof Error ? error.message : String(error),
+		timestamp: Date.now()
+	};
+}
+function hasResult(source) {
+	return typeof source.result === "function";
+}
+async function forwardStream(target, source) {
+	for await (const event of source) target.push(event);
+	target.end(hasResult(source) ? await source.result() : void 0);
+}
+/**
+* Returns a stream synchronously while running async setup (auth resolution,
+* lazy module loading) behind it. Setup failures terminate the stream with an
+* error event.
+*/
+function lazyStream(model, setup) {
+	const outer = new AssistantMessageEventStream$1();
+	setup().then((inner) => forwardStream(outer, inner)).catch((error) => {
+		const message = createSetupErrorMessage(model, error);
+		outer.push({
+			type: "error",
+			reason: "error",
+			error: message
+		});
+		outer.end(message);
+	});
+	return outer;
+}
+function lazyApi(load, capabilities) {
+	const api = {
+		stream: (model, context, options) => lazyStream(model, async () => (await load()).stream(model, context, options)),
+		streamSimple: (model, context, options) => lazyStream(model, async () => (await load()).streamSimple(model, context, options))
+	};
+	if (capabilities?.fetchDeferred) api.fetchDeferred = (model, handle, options) => lazyStream(model, async () => {
+		const implementation = await load();
+		if (!implementation.fetchDeferred) throw new Error("API does not support deferred responses");
+		return implementation.fetchDeferred(model, handle, options);
+	});
+	if (capabilities?.cancelDeferred) api.cancelDeferred = async (model, handle, options) => {
+		const implementation = await load();
+		if (!implementation.cancelDeferred) throw new Error("API cannot cancel deferred responses");
+		await implementation.cancelDeferred(model, handle, options);
+	};
+	return api;
+}
+//#endregion
+//#region src/compat/vendor/pi-oauth-flows/provider-env.ts
+let procEnvCache = null;
+/**
+* Fallback for https://github.com/oven-sh/bun/issues/27802.
+* Bun compiled binaries can expose an empty process.env inside Linux sandboxes
+* even though /proc/self/environ contains the environment.
+*
+* This intentionally duplicates restoreSandboxEnv() in
+* packages/coding-agent/src/bun/restore-sandbox-env.ts. The ai package can be
+* used directly, without going through that entrypoint, so provider env lookup
+* must not depend on process.env having been patched.
+*/
+function getBunSandboxEnvValue(name) {
+	if (typeof process === "undefined" || !process.versions?.bun || Object.keys(process.env).length > 0) return;
+	if (procEnvCache === null) {
+		procEnvCache = /* @__PURE__ */ new Map();
+		try {
+			const { readFileSync } = __require("node:fs");
+			const data = readFileSync("/proc/self/environ", "utf-8");
+			for (const entry of data.split("\0")) {
+				const idx = entry.indexOf("=");
+				if (idx > 0) procEnvCache.set(entry.slice(0, idx), entry.slice(idx + 1));
+			}
+		} catch {}
+	}
+	return procEnvCache.get(name);
+}
+/**
+* Resolve a provider env value from scoped overrides, normal process.env, then
+* the duplicated Bun sandbox fallback for direct pi-ai consumers.
+*/
+function getProviderEnvValue(name, env) {
+	return env?.[name] || (typeof process !== "undefined" ? process.env[name] : void 0) || getBunSandboxEnvValue(name) || void 0;
+}
+//#endregion
+//#region src/compat/vendor/pi-oauth-flows/device-code.ts
+const CANCEL_MESSAGE = "Login cancelled";
+const TIMEOUT_MESSAGE = "Device flow timed out";
+const SLOW_DOWN_TIMEOUT_MESSAGE = "Device flow timed out after one or more slow_down responses. This is often caused by clock drift in WSL or VM environments. Please sync or restart the VM clock and try again.";
+const MINIMUM_INTERVAL_MS = 1e3;
+const DEFAULT_POLL_INTERVAL_SECONDS$1 = 5;
+const SLOW_DOWN_INTERVAL_INCREMENT_MS = 5e3;
+function abortableSleep(ms, signal, cancelMessage) {
+	return new Promise((resolve, reject) => {
+		if (signal.aborted) {
+			reject(new Error(cancelMessage));
+			return;
+		}
+		const onAbort = () => {
+			clearTimeout(timeout);
+			reject(new Error(cancelMessage));
+		};
+		const timeout = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+async function pollOAuthDeviceCodeFlow(options) {
+	const deadline = typeof options.expiresInSeconds === "number" ? Date.now() + options.expiresInSeconds * 1e3 : Number.POSITIVE_INFINITY;
+	let intervalMs = Math.max(MINIMUM_INTERVAL_MS, Math.floor((options.intervalSeconds ?? DEFAULT_POLL_INTERVAL_SECONDS$1) * 1e3));
+	let slowDownResponses = 0;
+	if (options.waitBeforeFirstPoll) {
+		const remainingMs = deadline - Date.now();
+		if (remainingMs > 0) await abortableSleep(Math.min(intervalMs, remainingMs), options.signal, CANCEL_MESSAGE);
+	}
+	while (Date.now() < deadline) {
+		if (options.signal.aborted) throw new Error(CANCEL_MESSAGE);
+		const result = await options.poll();
+		if (result.status === "complete") return result.value;
+		if (result.status === "failed") throw new Error(result.message);
+		if (result.status === "slow_down") {
+			slowDownResponses += 1;
+			intervalMs = typeof result.intervalSeconds === "number" && Number.isFinite(result.intervalSeconds) && result.intervalSeconds > 0 ? Math.max(MINIMUM_INTERVAL_MS, Math.floor(result.intervalSeconds * 1e3)) : Math.max(MINIMUM_INTERVAL_MS, intervalMs + SLOW_DOWN_INTERVAL_INCREMENT_MS);
+		}
+		const remainingMs = deadline - Date.now();
+		if (remainingMs <= 0) break;
+		await abortableSleep(Math.min(intervalMs, remainingMs), options.signal, CANCEL_MESSAGE);
+	}
+	throw new Error(slowDownResponses > 0 ? SLOW_DOWN_TIMEOUT_MESSAGE : TIMEOUT_MESSAGE);
+}
+//#endregion
+//#region src/compat/vendor/pi-oauth-flows/oauth-page.ts
+const LOGO_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 800" aria-hidden="true"><path fill="#fff" fill-rule="evenodd" d="M165.29 165.29 H517.36 V400 H400 V517.36 H282.65 V634.72 H165.29 Z M282.65 282.65 V400 H400 V282.65 Z"/><path fill="#fff" d="M517.36 400 H634.72 V634.72 H517.36 Z"/></svg>`;
+function escapeHtml(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
+}
+function renderPage(options) {
+	const title = escapeHtml(options.title);
+	const heading = escapeHtml(options.heading);
+	const message = escapeHtml(options.message);
+	const details = options.details ? escapeHtml(options.details) : void 0;
+	return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${title}</title>
+  <style>
+    :root {
+      --text: #fafafa;
+      --text-dim: #a1a1aa;
+      --page-bg: #09090b;
+      --font-sans: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+      --font-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+    }
+    * { box-sizing: border-box; }
+    html { color-scheme: dark; }
+    body {
+      margin: 0;
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      padding: 24px;
+      background: var(--page-bg);
+      color: var(--text);
+      font-family: var(--font-sans);
+      text-align: center;
+    }
+    main {
+      width: 100%;
+      max-width: 560px;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+    }
+    .logo {
+      width: 72px;
+      height: 72px;
+      display: block;
+      margin-bottom: 24px;
+    }
+    h1 {
+      margin: 0 0 10px;
+      font-size: 28px;
+      line-height: 1.15;
+      font-weight: 650;
+      color: var(--text);
+    }
+    p {
+      margin: 0;
+      line-height: 1.7;
+      color: var(--text-dim);
+      font-size: 15px;
+    }
+    .details {
+      margin-top: 16px;
+      font-family: var(--font-mono);
+      font-size: 13px;
+      color: var(--text-dim);
+      white-space: pre-wrap;
+      word-break: break-word;
+    }
+  </style>
+</head>
+<body>
+  <main>
+    <div class="logo">${LOGO_SVG}</div>
+    <h1>${heading}</h1>
+    <p>${message}</p>
+    ${details ? `<div class="details">${details}</div>` : ""}
+  </main>
+</body>
+</html>`;
+}
+function oauthSuccessHtml(message) {
+	return renderPage({
+		title: "Authentication successful",
+		heading: "Authentication successful",
+		message
+	});
+}
+function oauthErrorHtml(message, details) {
+	return renderPage({
+		title: "Authentication failed",
+		heading: "Authentication failed",
+		message,
+		details
+	});
+}
+//#endregion
+//#region src/compat/vendor/pi-oauth-flows/pkce.ts
+/**
+* PKCE utilities using Web Crypto API.
+* Works in both Node.js 20+ and browsers.
+*/
+/**
+* Encode bytes as base64url string.
+*/
+function base64urlEncode(bytes) {
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+/**
+* Generate PKCE code verifier and challenge.
+* Uses Web Crypto API for cross-platform compatibility.
+*/
+async function generatePKCE() {
+	const verifierBytes = /* @__PURE__ */ new Uint8Array(32);
+	crypto.getRandomValues(verifierBytes);
+	const verifier = base64urlEncode(verifierBytes);
+	const data = new TextEncoder().encode(verifier);
+	const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+	return {
+		verifier,
+		challenge: base64urlEncode(new Uint8Array(hashBuffer))
+	};
+}
+//#endregion
+//#region src/compat/vendor/pi-oauth-flows/openai-codex.ts
+/**
+* OpenAI Codex (ChatGPT OAuth) flow
+*
+* NOTE: This module uses Node.js crypto and http for the OAuth callback.
+* It is only intended for CLI use, not browser environments.
+*/
+let _randomBytes = null;
+let _http = null;
+if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
+	import("node:crypto").then((m) => {
+		_randomBytes = m.randomBytes;
+	});
+	import("node:http").then((m) => {
+		_http = m;
+	});
+}
+const CLIENT_ID$3 = "app_EMoamEEZ73f0CkXaXp7hrann";
+const AUTH_BASE_URL = "https://auth.openai.com";
+const AUTHORIZE_URL$1 = `${AUTH_BASE_URL}/oauth/authorize`;
+const TOKEN_URL$1 = `${AUTH_BASE_URL}/oauth/token`;
+const REDIRECT_URI$1 = "http://localhost:1455/auth/callback";
+const DEVICE_USER_CODE_URL = `${AUTH_BASE_URL}/api/accounts/deviceauth/usercode`;
+const DEVICE_TOKEN_URL = `${AUTH_BASE_URL}/api/accounts/deviceauth/token`;
+const DEVICE_VERIFICATION_URI = `${AUTH_BASE_URL}/codex/device`;
+const DEVICE_REDIRECT_URI = `${AUTH_BASE_URL}/deviceauth/callback`;
+const DEVICE_CODE_TIMEOUT_SECONDS$1 = 900;
+const OPENAI_CODEX_BROWSER_LOGIN_METHOD = "browser";
+const OPENAI_CODEX_DEVICE_CODE_LOGIN_METHOD = "device_code";
+const SCOPE = "openid profile email offline_access";
+const JWT_CLAIM_PATH = "https://api.openai.com/auth";
+function getCallbackHost() {
+	return getProviderEnvValue("PI_OAUTH_CALLBACK_HOST") || "127.0.0.1";
+}
+function createState() {
+	if (!_randomBytes) throw new Error("OpenAI Codex OAuth is only available in Node.js environments");
+	return _randomBytes(16).toString("hex");
+}
+function parseAuthorizationInput$1(input) {
+	const value = input.trim();
+	if (!value) return {};
+	try {
+		const url = new URL(value);
+		return {
+			code: url.searchParams.get("code") ?? void 0,
+			state: url.searchParams.get("state") ?? void 0
+		};
+	} catch {}
+	if (value.includes("#")) {
+		const [code, state] = value.split("#", 2);
+		return {
+			code,
+			state
+		};
+	}
+	if (value.includes("code=")) {
+		const params = new URLSearchParams(value);
+		return {
+			code: params.get("code") ?? void 0,
+			state: params.get("state") ?? void 0
+		};
+	}
+	return { code: value };
+}
+function decodeJwt(token) {
+	try {
+		const parts = token.split(".");
+		if (parts.length !== 3) return null;
+		const payload = parts[1] ?? "";
+		const decoded = atob(payload);
+		return JSON.parse(decoded);
+	} catch {
+		return null;
+	}
+}
+async function fetchWithLoginCancellation(input, init) {
+	try {
+		return await fetch(input, init);
+	} catch (error) {
+		if (init.signal?.aborted) throw new Error("Login cancelled");
+		throw error;
+	}
+}
+async function readTokenResponse(response, operation) {
+	if (!response.ok) {
+		const text = await response.text().catch(() => "");
+		throw new Error(`OpenAI Codex token ${operation} failed (${response.status}): ${text || response.statusText}`);
+	}
+	const json = await response.json();
+	if (!json?.access_token || !json.refresh_token || typeof json.expires_in !== "number") throw new Error(`OpenAI Codex token ${operation} response missing fields: ${JSON.stringify(json)}`);
+	return {
+		access: json.access_token,
+		refresh: json.refresh_token,
+		expires: Date.now() + json.expires_in * 1e3
+	};
+}
+async function exchangeAuthorizationCode$1(code, verifier, redirectUri, signal) {
+	return readTokenResponse(await fetchWithLoginCancellation(TOKEN_URL$1, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: new URLSearchParams({
+			grant_type: "authorization_code",
+			client_id: CLIENT_ID$3,
+			code,
+			code_verifier: verifier,
+			redirect_uri: redirectUri
+		}),
+		signal
+	}), "exchange");
+}
+async function refreshAccessToken(refreshToken, signal) {
+	let response;
+	try {
+		response = await fetch(TOKEN_URL$1, {
+			method: "POST",
+			headers: { "Content-Type": "application/x-www-form-urlencoded" },
+			body: new URLSearchParams({
+				grant_type: "refresh_token",
+				refresh_token: refreshToken,
+				client_id: CLIENT_ID$3
+			}),
+			signal
+		});
+	} catch (error) {
+		throw new Error(`OpenAI Codex token refresh error: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	return readTokenResponse(response, "refresh");
+}
+async function startOpenAICodexDeviceAuth(signal) {
+	const response = await fetchWithLoginCancellation(DEVICE_USER_CODE_URL, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ client_id: CLIENT_ID$3 }),
+		signal
+	});
+	if (!response.ok) {
+		if (response.status === 404) throw new Error("OpenAI Codex device code login is not enabled for this server. Use browser login or verify the server URL.");
+		const responseBody = await response.text().catch(() => "");
+		throw new Error(`OpenAI Codex device code request failed with status ${response.status}${responseBody ? `: ${responseBody}` : ""}`);
+	}
+	const json = await response.json();
+	const intervalSeconds = typeof json?.interval === "string" ? Number(json.interval.trim()) : json?.interval;
+	if (!json?.device_auth_id || !json.user_code || typeof intervalSeconds !== "number" || !Number.isFinite(intervalSeconds) || intervalSeconds < 0) throw new Error(`Invalid OpenAI Codex device code response: ${JSON.stringify(json)}`);
+	return {
+		deviceAuthId: json.device_auth_id,
+		userCode: json.user_code,
+		intervalSeconds
+	};
+}
+async function pollOpenAICodexDeviceAuth(device, signal) {
+	return pollOAuthDeviceCodeFlow({
+		intervalSeconds: device.intervalSeconds,
+		expiresInSeconds: DEVICE_CODE_TIMEOUT_SECONDS$1,
+		signal,
+		poll: async () => {
+			const response = await fetchWithLoginCancellation(DEVICE_TOKEN_URL, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					device_auth_id: device.deviceAuthId,
+					user_code: device.userCode
+				}),
+				signal
+			});
+			if (response.ok) {
+				const json = await response.json();
+				if (!json?.authorization_code || !json.code_verifier) return {
+					status: "failed",
+					message: `Invalid OpenAI Codex device auth token response: ${JSON.stringify(json)}`
+				};
+				return {
+					status: "complete",
+					value: {
+						authorizationCode: json.authorization_code,
+						codeVerifier: json.code_verifier
+					}
+				};
+			}
+			if (response.status === 403 || response.status === 404) return { status: "pending" };
+			const responseBody = await response.text().catch(() => "");
+			let errorCode;
+			try {
+				const error = JSON.parse(responseBody)?.error;
+				errorCode = typeof error === "object" ? error?.code : error;
+			} catch {}
+			if (errorCode === "deviceauth_authorization_pending") return { status: "pending" };
+			if (errorCode === "slow_down") return { status: "slow_down" };
+			return {
+				status: "failed",
+				message: `OpenAI Codex device auth failed with status ${response.status}${responseBody ? `: ${responseBody}` : ""}`
+			};
+		}
+	});
+}
+async function createAuthorizationFlow(originator = "pi") {
+	const { verifier, challenge } = await generatePKCE();
+	const state = createState();
+	const url = new URL(AUTHORIZE_URL$1);
+	url.searchParams.set("response_type", "code");
+	url.searchParams.set("client_id", CLIENT_ID$3);
+	url.searchParams.set("redirect_uri", REDIRECT_URI$1);
+	url.searchParams.set("scope", SCOPE);
+	url.searchParams.set("code_challenge", challenge);
+	url.searchParams.set("code_challenge_method", "S256");
+	url.searchParams.set("state", state);
+	url.searchParams.set("id_token_add_organizations", "true");
+	url.searchParams.set("codex_cli_simplified_flow", "true");
+	url.searchParams.set("originator", originator);
+	return {
+		verifier,
+		state,
+		url: url.toString()
+	};
+}
+function startLocalOAuthServer(state) {
+	if (!_http) throw new Error("OpenAI Codex OAuth is only available in Node.js environments");
+	let settleWait;
+	const waitForCodePromise = new Promise((resolve) => {
+		let settled = false;
+		settleWait = (value) => {
+			if (settled) return;
+			settled = true;
+			resolve(value);
+		};
+	});
+	const server = _http.createServer((req, res) => {
+		try {
+			const url = new URL(req.url || "", "http://localhost");
+			if (url.pathname !== "/auth/callback") {
+				res.statusCode = 404;
+				res.setHeader("Content-Type", "text/html; charset=utf-8");
+				res.end(oauthErrorHtml("Callback route not found."));
+				return;
+			}
+			if (url.searchParams.get("state") !== state) {
+				res.statusCode = 400;
+				res.setHeader("Content-Type", "text/html; charset=utf-8");
+				res.end(oauthErrorHtml("State mismatch."));
+				return;
+			}
+			const code = url.searchParams.get("code");
+			if (!code) {
+				res.statusCode = 400;
+				res.setHeader("Content-Type", "text/html; charset=utf-8");
+				res.end(oauthErrorHtml("Missing authorization code."));
+				return;
+			}
+			res.statusCode = 200;
+			res.setHeader("Content-Type", "text/html; charset=utf-8");
+			res.end(oauthSuccessHtml("OpenAI authentication completed. You can close this window."));
+			settleWait?.({ code });
+		} catch {
+			res.statusCode = 500;
+			res.setHeader("Content-Type", "text/html; charset=utf-8");
+			res.end(oauthErrorHtml("Internal error while processing OAuth callback."));
+		}
+	});
+	return new Promise((resolve) => {
+		server.listen(1455, getCallbackHost(), () => {
+			resolve({
+				close: () => server.close(),
+				cancelWait: () => {
+					settleWait?.(null);
+				},
+				waitForCode: () => waitForCodePromise
+			});
+		}).on("error", (_err) => {
+			settleWait?.(null);
+			resolve({
+				close: () => {
+					try {
+						server.close();
+					} catch {}
+				},
+				cancelWait: () => {},
+				waitForCode: async () => null
+			});
+		});
+	});
+}
+function getAccountId(accessToken) {
+	const accountId = (decodeJwt(accessToken)?.[JWT_CLAIM_PATH])?.chatgpt_account_id;
+	return typeof accountId === "string" && accountId.length > 0 ? accountId : null;
+}
+function credentialsFromToken(token) {
+	const accountId = getAccountId(token.access);
+	if (!accountId) throw new Error("Failed to extract accountId from token");
+	return {
+		type: "oauth",
+		access: token.access,
+		refresh: token.refresh,
+		expires: token.expires,
+		accountId
+	};
+}
+async function exchangeAuthorizationCodeForCredentials(code, verifier, redirectUri, signal) {
+	return credentialsFromToken(await exchangeAuthorizationCode$1(code, verifier, redirectUri, signal));
+}
+async function loginOpenAICodexDeviceCode(interaction) {
+	const device = await startOpenAICodexDeviceAuth(interaction.signal);
+	interaction.notify({
+		type: "device_code",
+		userCode: device.userCode,
+		verificationUri: DEVICE_VERIFICATION_URI,
+		intervalSeconds: device.intervalSeconds,
+		expiresInSeconds: DEVICE_CODE_TIMEOUT_SECONDS$1
+	});
+	const code = await pollOpenAICodexDeviceAuth(device, interaction.signal);
+	return exchangeAuthorizationCodeForCredentials(code.authorizationCode, code.codeVerifier, DEVICE_REDIRECT_URI, interaction.signal);
+}
+async function loginOpenAICodex(interaction) {
+	const { verifier, state, url } = await createAuthorizationFlow();
+	const server = await startLocalOAuthServer(state);
+	const manualAbort = new AbortController();
+	const onAbort = () => server.cancelWait();
+	interaction.signal.addEventListener("abort", onAbort, { once: true });
+	if (interaction.signal.aborted) onAbort();
+	let code;
+	let manualCode;
+	let manualError;
+	interaction.notify({
+		type: "auth_url",
+		url,
+		instructions: "A browser window should open. Complete login to finish."
+	});
+	try {
+		const manualPromise = interaction.prompt({
+			type: "manual_code",
+			message: "Complete login in your browser, or paste the authorization code / redirect URL here:",
+			placeholder: REDIRECT_URI$1,
+			signal: manualAbort.signal
+		}).then((input) => {
+			manualCode = input;
+			server.cancelWait();
+		}).catch((error) => {
+			manualError = error instanceof Error ? error : new Error(String(error));
+			server.cancelWait();
+		});
+		const result = await server.waitForCode();
+		if (manualError) throw manualError;
+		if (result?.code) code = result.code;
+		else if (manualCode) {
+			const parsed = parseAuthorizationInput$1(manualCode);
+			if (parsed.state && parsed.state !== state) throw new Error("State mismatch");
+			code = parsed.code;
+		}
+		if (!code) {
+			await manualPromise;
+			if (manualError) throw manualError;
+			if (manualCode) {
+				const parsed = parseAuthorizationInput$1(manualCode);
+				if (parsed.state && parsed.state !== state) throw new Error("State mismatch");
+				code = parsed.code;
+			}
+		}
+		if (!code) throw new Error("Missing authorization code");
+		return exchangeAuthorizationCodeForCredentials(code, verifier, REDIRECT_URI$1, interaction.signal);
+	} finally {
+		interaction.signal.removeEventListener("abort", onAbort);
+		manualAbort.abort();
+		server.close();
+	}
+}
+/**
+* Refresh OpenAI Codex OAuth token
+*/
+async function refreshOpenAICodexToken(refreshToken, signal) {
+	return credentialsFromToken(await refreshAccessToken(refreshToken, signal));
+}
+const openaiCodexOAuth = {
+	name: "OpenAI (ChatGPT Plus/Pro)",
+	isSubscription: true,
+	async login(interaction) {
+		const method = await interaction.prompt({
+			type: "select",
+			message: "Select OpenAI Codex login method:",
+			options: [{
+				id: OPENAI_CODEX_BROWSER_LOGIN_METHOD,
+				label: "Browser login (default)"
+			}, {
+				id: OPENAI_CODEX_DEVICE_CODE_LOGIN_METHOD,
+				label: "Device code login (headless)"
+			}]
+		});
+		if (method === OPENAI_CODEX_DEVICE_CODE_LOGIN_METHOD) return loginOpenAICodexDeviceCode(interaction);
+		if (method !== OPENAI_CODEX_BROWSER_LOGIN_METHOD) throw new Error(`Unknown OpenAI Codex login method: ${method}`);
+		return loginOpenAICodex(interaction);
+	},
+	refresh: (credential, signal) => refreshOpenAICodexToken(credential.refresh, signal),
+	async toAuth(credential) {
+		return { apiKey: credential.access };
+	}
+};
+//#endregion
+//#region src/compat/vendor/pi-oauth-flows/anthropic.ts
+/**
+* Anthropic OAuth flow (Claude Pro/Max)
+*
+* NOTE: This module uses Node.js http.createServer for the OAuth callback server.
+* It is only intended for CLI use, not browser environments.
+*/
+let nodeApis = null;
+let nodeApisPromise = null;
+const decode$1 = (s) => atob(s);
+const CLIENT_ID$2 = decode$1("OWQxYzI1MGEtZTYxYi00NGQ5LTg4ZWQtNTk0NGQxOTYyZjVl");
+const AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
+const TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+const CALLBACK_HOST = getProviderEnvValue("PI_OAUTH_CALLBACK_HOST") || "127.0.0.1";
+const CALLBACK_PORT = 53692;
+const CALLBACK_PATH = "/callback";
+const REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
+const SCOPES = "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload";
+async function getNodeApis() {
+	if (nodeApis) return nodeApis;
+	if (!nodeApisPromise) {
+		if (typeof process === "undefined" || !process.versions?.node && !process.versions?.bun) throw new Error("Anthropic OAuth is only available in Node.js environments");
+		nodeApisPromise = import("node:http").then((httpModule) => ({ createServer: httpModule.createServer }));
+	}
+	nodeApis = await nodeApisPromise;
+	return nodeApis;
+}
+function parseAuthorizationInput(input) {
+	const value = input.trim();
+	if (!value) return {};
+	try {
+		const url = new URL(value);
+		return {
+			code: url.searchParams.get("code") ?? void 0,
+			state: url.searchParams.get("state") ?? void 0
+		};
+	} catch {}
+	if (value.includes("#")) {
+		const [code, state] = value.split("#", 2);
+		return {
+			code,
+			state
+		};
+	}
+	if (value.includes("code=")) {
+		const params = new URLSearchParams(value);
+		return {
+			code: params.get("code") ?? void 0,
+			state: params.get("state") ?? void 0
+		};
+	}
+	return { code: value };
+}
+function formatErrorDetails(error) {
+	if (error instanceof Error) {
+		const details = [`${error.name}: ${error.message}`];
+		const errorWithCode = error;
+		if (errorWithCode.code) details.push(`code=${errorWithCode.code}`);
+		if (typeof errorWithCode.errno !== "undefined") details.push(`errno=${String(errorWithCode.errno)}`);
+		if (typeof error.cause !== "undefined") details.push(`cause=${formatErrorDetails(error.cause)}`);
+		if (error.stack) details.push(`stack=${error.stack}`);
+		return details.join("; ");
+	}
+	return String(error);
+}
+async function startCallbackServer(expectedState) {
+	const { createServer } = await getNodeApis();
+	return new Promise((resolve, reject) => {
+		let settleWait;
+		const waitForCodePromise = new Promise((resolveWait) => {
+			let settled = false;
+			settleWait = (value) => {
+				if (settled) return;
+				settled = true;
+				resolveWait(value);
+			};
+		});
+		const server = createServer((req, res) => {
+			try {
+				const url = new URL(req.url || "", "http://localhost");
+				if (url.pathname !== CALLBACK_PATH) {
+					res.writeHead(404, { "Content-Type": "text/html; charset=utf-8" });
+					res.end(oauthErrorHtml("Callback route not found."));
+					return;
+				}
+				const code = url.searchParams.get("code");
+				const state = url.searchParams.get("state");
+				const error = url.searchParams.get("error");
+				if (error) {
+					res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+					res.end(oauthErrorHtml("Anthropic authentication did not complete.", `Error: ${error}`));
+					return;
+				}
+				if (!code || !state) {
+					res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+					res.end(oauthErrorHtml("Missing code or state parameter."));
+					return;
+				}
+				if (state !== expectedState) {
+					res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+					res.end(oauthErrorHtml("State mismatch."));
+					return;
+				}
+				res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+				res.end(oauthSuccessHtml("Anthropic authentication completed. You can close this window."));
+				settleWait?.({
+					code,
+					state
+				});
+			} catch {
+				res.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" });
+				res.end("Internal error");
+			}
+		});
+		server.on("error", (err) => {
+			reject(err);
+		});
+		server.listen(CALLBACK_PORT, CALLBACK_HOST, () => {
+			resolve({
+				server,
+				redirectUri: REDIRECT_URI,
+				cancelWait: () => {
+					settleWait?.(null);
+				},
+				waitForCode: () => waitForCodePromise
+			});
+		});
+	});
+}
+async function postJson(url, body, signal) {
+	const response = await fetch(url, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Accept: "application/json"
+		},
+		body: JSON.stringify(body),
+		signal: AbortSignal.any([signal, AbortSignal.timeout(3e4)])
+	});
+	const responseBody = await response.text();
+	if (!response.ok) throw new Error(`HTTP request failed. status=${response.status}; url=${url}; body=${responseBody}`);
+	return responseBody;
+}
+async function exchangeAuthorizationCode(code, state, verifier, redirectUri, signal) {
+	let responseBody;
+	try {
+		responseBody = await postJson(TOKEN_URL, {
+			grant_type: "authorization_code",
+			client_id: CLIENT_ID$2,
+			code,
+			state,
+			redirect_uri: redirectUri,
+			code_verifier: verifier
+		}, signal);
+	} catch (error) {
+		throw new Error(`Token exchange request failed. url=${TOKEN_URL}; redirect_uri=${redirectUri}; response_type=authorization_code; details=${formatErrorDetails(error)}`);
+	}
+	let tokenData;
+	try {
+		tokenData = JSON.parse(responseBody);
+	} catch (error) {
+		throw new Error(`Token exchange returned invalid JSON. url=${TOKEN_URL}; body=${responseBody}; details=${formatErrorDetails(error)}`);
+	}
+	return {
+		type: "oauth",
+		refresh: tokenData.refresh_token,
+		access: tokenData.access_token,
+		expires: Date.now() + tokenData.expires_in * 1e3 - 3e5
+	};
+}
+async function loginAnthropic(interaction) {
+	const { verifier, challenge } = await generatePKCE();
+	const server = await startCallbackServer(verifier);
+	const manualAbort = new AbortController();
+	const onAbort = () => server.cancelWait();
+	interaction.signal.addEventListener("abort", onAbort, { once: true });
+	if (interaction.signal.aborted) onAbort();
+	let code;
+	let state;
+	let manualInput;
+	let manualError;
+	try {
+		const authParams = new URLSearchParams({
+			code: "true",
+			client_id: CLIENT_ID$2,
+			response_type: "code",
+			redirect_uri: REDIRECT_URI,
+			scope: SCOPES,
+			code_challenge: challenge,
+			code_challenge_method: "S256",
+			state: verifier
+		});
+		interaction.notify({
+			type: "auth_url",
+			url: `${AUTHORIZE_URL}?${authParams.toString()}`,
+			instructions: "Complete login in your browser. If the browser is on another machine, paste the final redirect URL here."
+		});
+		const manualPromise = interaction.prompt({
+			type: "manual_code",
+			message: "Complete login in your browser, or paste the authorization code / redirect URL here:",
+			placeholder: REDIRECT_URI,
+			signal: manualAbort.signal
+		}).then((input) => {
+			manualInput = input;
+			server.cancelWait();
+		}).catch((error) => {
+			manualError = error instanceof Error ? error : new Error(String(error));
+			server.cancelWait();
+		});
+		const result = await server.waitForCode();
+		if (manualError) throw manualError;
+		if (result?.code) {
+			code = result.code;
+			state = result.state;
+		} else if (manualInput) {
+			const parsed = parseAuthorizationInput(manualInput);
+			if (parsed.state && parsed.state !== verifier) throw new Error("OAuth state mismatch");
+			code = parsed.code;
+			state = parsed.state ?? verifier;
+		}
+		if (!code) {
+			await manualPromise;
+			if (manualError) throw manualError;
+			if (manualInput) {
+				const parsed = parseAuthorizationInput(manualInput);
+				if (parsed.state && parsed.state !== verifier) throw new Error("OAuth state mismatch");
+				code = parsed.code;
+				state = parsed.state ?? verifier;
+			}
+		}
+		if (!code) throw new Error("Missing authorization code");
+		if (!state) throw new Error("Missing OAuth state");
+		interaction.notify({
+			type: "progress",
+			message: "Exchanging authorization code for tokens..."
+		});
+		return exchangeAuthorizationCode(code, state, verifier, REDIRECT_URI, interaction.signal);
+	} finally {
+		interaction.signal.removeEventListener("abort", onAbort);
+		manualAbort.abort();
+		server.server.close();
+	}
+}
+/**
+* Refresh Anthropic OAuth token
+*/
+async function refreshAnthropicToken(refreshToken, signal) {
+	let responseBody;
+	try {
+		responseBody = await postJson(TOKEN_URL, {
+			grant_type: "refresh_token",
+			client_id: CLIENT_ID$2,
+			refresh_token: refreshToken
+		}, signal);
+	} catch (error) {
+		throw new Error(`Anthropic token refresh request failed. url=${TOKEN_URL}; details=${formatErrorDetails(error)}`);
+	}
+	let data;
+	try {
+		data = JSON.parse(responseBody);
+	} catch (error) {
+		throw new Error(`Anthropic token refresh returned invalid JSON. url=${TOKEN_URL}; body=${responseBody}; details=${formatErrorDetails(error)}`);
+	}
+	return {
+		type: "oauth",
+		refresh: data.refresh_token,
+		access: data.access_token,
+		expires: Date.now() + data.expires_in * 1e3 - 3e5
+	};
+}
+const anthropicOAuth = {
+	name: "Anthropic (Claude Pro/Max)",
+	isSubscription: true,
+	login: loginAnthropic,
+	refresh: (credential, signal) => refreshAnthropicToken(credential.refresh, signal),
+	async toAuth(credential) {
+		return { apiKey: credential.access };
+	}
+};
+//#endregion
+//#region src/compat/vendor/pi-oauth-flows/data/github-copilot.json
+var github_copilot_default = {
+	"anthropic-messages": {
+		"claude-haiku-4.5": {
+			"id": "claude-haiku-4.5",
+			"name": "Claude Haiku 4.5 (latest)",
+			"api": "anthropic-messages",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 1,
+				"output": 5,
+				"cacheRead": .1,
+				"cacheWrite": 1.25
+			},
+			"contextWindow": 2e5,
+			"maxTokens": 64e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"compat": { "supportsEagerToolInputStreaming": false }
+		},
+		"claude-opus-4.5": {
+			"id": "claude-opus-4.5",
+			"name": "Claude Opus 4.5 (latest)",
+			"api": "anthropic-messages",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 5,
+				"output": 25,
+				"cacheRead": .5,
+				"cacheWrite": 6.25
+			},
+			"contextWindow": 2e5,
+			"maxTokens": 32e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			}
+		},
+		"claude-opus-4.6": {
+			"id": "claude-opus-4.6",
+			"name": "Claude Opus 4.6",
+			"api": "anthropic-messages",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 5,
+				"output": 25,
+				"cacheRead": .5,
+				"cacheWrite": 6.25
+			},
+			"contextWindow": 1e6,
+			"maxTokens": 32e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"thinkingLevelMap": { "max": "max" },
+			"compat": { "forceAdaptiveThinking": true }
+		},
+		"claude-opus-4.7": {
+			"id": "claude-opus-4.7",
+			"name": "Claude Opus 4.7",
+			"api": "anthropic-messages",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 5,
+				"output": 25,
+				"cacheRead": .5,
+				"cacheWrite": 6.25
+			},
+			"contextWindow": 1e6,
+			"maxTokens": 32e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"thinkingLevelMap": {
+				"xhigh": "xhigh",
+				"max": "max",
+				"minimal": "low"
+			},
+			"compat": {
+				"forceAdaptiveThinking": true,
+				"supportsTemperature": false
+			}
+		},
+		"claude-opus-4.8": {
+			"id": "claude-opus-4.8",
+			"name": "Claude Opus 4.8",
+			"api": "anthropic-messages",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 5,
+				"output": 25,
+				"cacheRead": .5,
+				"cacheWrite": 6.25
+			},
+			"contextWindow": 1e6,
+			"maxTokens": 64e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"thinkingLevelMap": {
+				"xhigh": "xhigh",
+				"max": "max",
+				"minimal": "low"
+			},
+			"compat": {
+				"forceAdaptiveThinking": true,
+				"supportsTemperature": false
+			}
+		},
+		"claude-opus-5": {
+			"id": "claude-opus-5",
+			"name": "Claude Opus 5",
+			"api": "anthropic-messages",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 5,
+				"output": 25,
+				"cacheRead": .5,
+				"cacheWrite": 6.25
+			},
+			"contextWindow": 1e6,
+			"maxTokens": 64e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"thinkingLevelMap": {
+				"xhigh": "xhigh",
+				"max": "max",
+				"minimal": "low"
+			},
+			"compat": {
+				"forceAdaptiveThinking": true,
+				"supportsTemperature": false
+			}
+		},
+		"claude-sonnet-4": {
+			"id": "claude-sonnet-4",
+			"name": "Claude Sonnet 4 (latest)",
+			"api": "anthropic-messages",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 3,
+				"output": 15,
+				"cacheRead": .3,
+				"cacheWrite": 3.75
+			},
+			"contextWindow": 216e3,
+			"maxTokens": 16e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"compat": { "supportsEagerToolInputStreaming": false }
+		},
+		"claude-sonnet-4.5": {
+			"id": "claude-sonnet-4.5",
+			"name": "Claude Sonnet 4.5 (latest)",
+			"api": "anthropic-messages",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 3,
+				"output": 15,
+				"cacheRead": .3,
+				"cacheWrite": 3.75
+			},
+			"contextWindow": 2e5,
+			"maxTokens": 32e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"compat": { "supportsEagerToolInputStreaming": false }
+		},
+		"claude-sonnet-4.6": {
+			"id": "claude-sonnet-4.6",
+			"name": "Claude Sonnet 4.6",
+			"api": "anthropic-messages",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 3,
+				"output": 15,
+				"cacheRead": .3,
+				"cacheWrite": 3.75
+			},
+			"contextWindow": 1e6,
+			"maxTokens": 32e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"thinkingLevelMap": {
+				"max": "max",
+				"minimal": "low"
+			},
+			"compat": { "forceAdaptiveThinking": true }
+		},
+		"claude-sonnet-5": {
+			"id": "claude-sonnet-5",
+			"name": "Claude Sonnet 5",
+			"api": "anthropic-messages",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 2,
+				"output": 10,
+				"cacheRead": .2,
+				"cacheWrite": 2.5
+			},
+			"contextWindow": 1e6,
+			"maxTokens": 128e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"thinkingLevelMap": {
+				"xhigh": "xhigh",
+				"max": "max"
+			},
+			"compat": { "forceAdaptiveThinking": true }
+		}
+	},
+	"openai-completions": {
+		"claude-fable-5": {
+			"id": "claude-fable-5",
+			"name": "Claude Fable 5",
+			"api": "openai-completions",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 10,
+				"output": 50,
+				"cacheRead": 1,
+				"cacheWrite": 12.5
+			},
+			"contextWindow": 1e6,
+			"maxTokens": 128e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"compat": {
+				"supportsStore": false,
+				"supportsDeveloperRole": false,
+				"supportsReasoningEffort": false
+			},
+			"thinkingLevelMap": {
+				"off": null,
+				"xhigh": "xhigh",
+				"max": "max"
+			}
+		},
+		"gemini-3.1-pro-preview": {
+			"id": "gemini-3.1-pro-preview",
+			"name": "Gemini 3.1 Pro Preview",
+			"api": "openai-completions",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 2,
+				"output": 12,
+				"cacheRead": .2,
+				"cacheWrite": 0,
+				"tiers": [{
+					"inputTokensAbove": 2e5,
+					"input": 4,
+					"output": 18,
+					"cacheRead": .4,
+					"cacheWrite": 0
+				}]
+			},
+			"contextWindow": 1e6,
+			"maxTokens": 64e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"compat": {
+				"supportsStore": false,
+				"supportsDeveloperRole": false,
+				"supportsReasoningEffort": false
+			}
+		},
+		"gemini-3.5-flash": {
+			"id": "gemini-3.5-flash",
+			"name": "Gemini 3.5 Flash",
+			"api": "openai-completions",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 1.5,
+				"output": 9,
+				"cacheRead": .15,
+				"cacheWrite": 0
+			},
+			"contextWindow": 2e5,
+			"maxTokens": 64e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"compat": {
+				"supportsStore": false,
+				"supportsDeveloperRole": false,
+				"supportsReasoningEffort": false
+			}
+		},
+		"gemini-3.6-flash": {
+			"id": "gemini-3.6-flash",
+			"name": "Gemini 3.6 Flash",
+			"api": "openai-completions",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 1.5,
+				"output": 7.5,
+				"cacheRead": .15,
+				"cacheWrite": 0
+			},
+			"contextWindow": 1e6,
+			"maxTokens": 64e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"compat": {
+				"supportsStore": false,
+				"supportsDeveloperRole": false,
+				"supportsReasoningEffort": false
+			}
+		},
+		"gpt-4.1": {
+			"id": "gpt-4.1",
+			"name": "GPT-4.1",
+			"api": "openai-completions",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": false,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 2,
+				"output": 8,
+				"cacheRead": .5,
+				"cacheWrite": 0
+			},
+			"contextWindow": 128e3,
+			"maxTokens": 16384,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"compat": {
+				"supportsStore": false,
+				"supportsDeveloperRole": false,
+				"supportsReasoningEffort": false
+			}
+		},
+		"kimi-k2.7-code": {
+			"id": "kimi-k2.7-code",
+			"name": "Kimi K2.7 Code",
+			"api": "openai-completions",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": .95,
+				"output": 4,
+				"cacheRead": .19,
+				"cacheWrite": 0
+			},
+			"contextWindow": 256e3,
+			"maxTokens": 32e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"compat": {
+				"supportsStore": false,
+				"supportsDeveloperRole": false,
+				"supportsReasoningEffort": false
+			}
+		},
+		"kimi-k3": {
+			"id": "kimi-k3",
+			"name": "Kimi K3",
+			"api": "openai-completions",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": .95,
+				"output": 4,
+				"cacheRead": .19,
+				"cacheWrite": 0
+			},
+			"contextWindow": 1048576,
+			"maxTokens": 131072,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"compat": {
+				"supportsStore": false,
+				"supportsDeveloperRole": false,
+				"supportsReasoningEffort": false
+			}
+		}
+	},
+	"openai-responses": {
+		"gpt-5-mini": {
+			"id": "gpt-5-mini",
+			"name": "GPT-5 Mini",
+			"api": "openai-responses",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": .25,
+				"output": 2,
+				"cacheRead": .025,
+				"cacheWrite": 0
+			},
+			"contextWindow": 264e3,
+			"maxTokens": 64e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"thinkingLevelMap": {
+				"off": null,
+				"minimal": "low",
+				"low": "low",
+				"medium": "medium",
+				"high": "high",
+				"xhigh": null,
+				"max": null
+			},
+			"compat": { "supportsOpenAIGrammarTools": true }
+		},
+		"gpt-5.2": {
+			"id": "gpt-5.2",
+			"name": "GPT-5.2",
+			"api": "openai-responses",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 1.75,
+				"output": 14,
+				"cacheRead": .175,
+				"cacheWrite": 0
+			},
+			"contextWindow": 4e5,
+			"maxTokens": 128e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"thinkingLevelMap": {
+				"off": null,
+				"minimal": "low",
+				"xhigh": "xhigh"
+			},
+			"compat": { "supportsOpenAIGrammarTools": true }
+		},
+		"gpt-5.2-codex": {
+			"id": "gpt-5.2-codex",
+			"name": "GPT-5.2 Codex",
+			"api": "openai-responses",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 1.75,
+				"output": 14,
+				"cacheRead": .175,
+				"cacheWrite": 0
+			},
+			"contextWindow": 4e5,
+			"maxTokens": 128e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"thinkingLevelMap": {
+				"off": null,
+				"minimal": "low",
+				"xhigh": "xhigh"
+			},
+			"compat": { "supportsOpenAIGrammarTools": true }
+		},
+		"gpt-5.3-codex": {
+			"id": "gpt-5.3-codex",
+			"name": "GPT-5.3 Codex",
+			"api": "openai-responses",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 1.75,
+				"output": 14,
+				"cacheRead": .175,
+				"cacheWrite": 0
+			},
+			"contextWindow": 1e6,
+			"maxTokens": 128e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"thinkingLevelMap": {
+				"off": null,
+				"minimal": "low",
+				"low": "low",
+				"medium": "medium",
+				"high": "high",
+				"xhigh": "xhigh",
+				"max": null
+			},
+			"compat": { "supportsOpenAIGrammarTools": true }
+		},
+		"gpt-5.4": {
+			"id": "gpt-5.4",
+			"name": "GPT-5.4",
+			"api": "openai-responses",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 2.5,
+				"output": 15,
+				"cacheRead": .25,
+				"cacheWrite": 0,
+				"tiers": [{
+					"inputTokensAbove": 272e3,
+					"input": 5,
+					"output": 22.5,
+					"cacheRead": .5,
+					"cacheWrite": 0
+				}]
+			},
+			"contextWindow": 1e6,
+			"maxTokens": 128e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"thinkingLevelMap": {
+				"off": null,
+				"minimal": "low",
+				"low": "low",
+				"medium": "medium",
+				"high": "high",
+				"xhigh": "xhigh",
+				"max": null
+			},
+			"compat": { "supportsOpenAIGrammarTools": true }
+		},
+		"gpt-5.4-mini": {
+			"id": "gpt-5.4-mini",
+			"name": "GPT-5.4 mini",
+			"api": "openai-responses",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": .75,
+				"output": 4.5,
+				"cacheRead": .075,
+				"cacheWrite": 0
+			},
+			"contextWindow": 4e5,
+			"maxTokens": 128e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"thinkingLevelMap": {
+				"off": null,
+				"minimal": "low",
+				"low": "low",
+				"medium": "medium",
+				"high": "high",
+				"xhigh": "xhigh",
+				"max": null
+			},
+			"compat": { "supportsOpenAIGrammarTools": true }
+		},
+		"gpt-5.4-nano": {
+			"id": "gpt-5.4-nano",
+			"name": "GPT-5.4 nano",
+			"api": "openai-responses",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": .2,
+				"output": 1.25,
+				"cacheRead": .02,
+				"cacheWrite": 0
+			},
+			"contextWindow": 4e5,
+			"maxTokens": 128e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"thinkingLevelMap": {
+				"off": null,
+				"minimal": "low",
+				"xhigh": "xhigh"
+			},
+			"compat": { "supportsOpenAIGrammarTools": true }
+		},
+		"gpt-5.5": {
+			"id": "gpt-5.5",
+			"name": "GPT-5.5",
+			"api": "openai-responses",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 5,
+				"output": 30,
+				"cacheRead": .5,
+				"cacheWrite": 0,
+				"tiers": [{
+					"inputTokensAbove": 272e3,
+					"input": 10,
+					"output": 45,
+					"cacheRead": 1,
+					"cacheWrite": 0
+				}]
+			},
+			"contextWindow": 1e6,
+			"maxTokens": 128e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"thinkingLevelMap": {
+				"off": null,
+				"minimal": "low",
+				"low": "low",
+				"medium": "medium",
+				"high": "high",
+				"xhigh": "xhigh",
+				"max": null
+			},
+			"compat": { "supportsOpenAIGrammarTools": true }
+		},
+		"gpt-5.6-luna": {
+			"id": "gpt-5.6-luna",
+			"name": "GPT-5.6 Luna",
+			"api": "openai-responses",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": .2,
+				"output": 1.2,
+				"cacheRead": .02,
+				"cacheWrite": 0,
+				"tiers": [{
+					"inputTokensAbove": 2e5,
+					"input": .4,
+					"output": 1.8,
+					"cacheRead": .04,
+					"cacheWrite": 0
+				}]
+			},
+			"contextWindow": 105e4,
+			"maxTokens": 128e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"thinkingLevelMap": {
+				"off": null,
+				"minimal": "low",
+				"low": "low",
+				"medium": "medium",
+				"high": "high",
+				"xhigh": "xhigh",
+				"max": "max"
+			},
+			"compat": { "supportsOpenAIGrammarTools": true }
+		},
+		"gpt-5.6-sol": {
+			"id": "gpt-5.6-sol",
+			"name": "GPT-5.6 Sol",
+			"api": "openai-responses",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 5,
+				"output": 30,
+				"cacheRead": .5,
+				"cacheWrite": 6.25,
+				"tiers": [{
+					"inputTokensAbove": 272e3,
+					"input": 10,
+					"output": 45,
+					"cacheRead": 1,
+					"cacheWrite": 12.5
+				}]
+			},
+			"contextWindow": 105e4,
+			"maxTokens": 128e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"thinkingLevelMap": {
+				"off": null,
+				"minimal": "low",
+				"low": "low",
+				"medium": "medium",
+				"high": "high",
+				"xhigh": "xhigh",
+				"max": "max"
+			},
+			"compat": { "supportsOpenAIGrammarTools": true }
+		},
+		"gpt-5.6-terra": {
+			"id": "gpt-5.6-terra",
+			"name": "GPT-5.6 Terra",
+			"api": "openai-responses",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 2,
+				"output": 12,
+				"cacheRead": .2,
+				"cacheWrite": 0,
+				"tiers": [{
+					"inputTokensAbove": 272e3,
+					"input": 4,
+					"output": 18,
+					"cacheRead": .4,
+					"cacheWrite": 0
+				}]
+			},
+			"contextWindow": 105e4,
+			"maxTokens": 128e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"thinkingLevelMap": {
+				"off": null,
+				"minimal": "low",
+				"low": "low",
+				"medium": "medium",
+				"high": "high",
+				"xhigh": "xhigh",
+				"max": "max"
+			},
+			"compat": { "supportsOpenAIGrammarTools": true }
+		},
+		"grok-4.5": {
+			"id": "grok-4.5",
+			"name": "Grok 4.5",
+			"api": "openai-responses",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text", "image"],
+			"cost": {
+				"input": 2,
+				"output": 6,
+				"cacheRead": .5,
+				"cacheWrite": 0,
+				"tiers": [{
+					"inputTokensAbove": 2e5,
+					"input": 4,
+					"output": 12,
+					"cacheRead": 1,
+					"cacheWrite": 0
+				}]
+			},
+			"contextWindow": 5e5,
+			"maxTokens": 128e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"thinkingLevelMap": {
+				"off": null,
+				"minimal": null,
+				"low": "low",
+				"medium": "medium",
+				"high": "high",
+				"xhigh": null,
+				"max": null
+			}
+		},
+		"mai-code-1-flash-picker": {
+			"id": "mai-code-1-flash-picker",
+			"name": "MAI-Code-1-Flash",
+			"api": "openai-responses",
+			"provider": "github-copilot",
+			"baseUrl": "https://api.individual.githubcopilot.com",
+			"reasoning": true,
+			"input": ["text"],
+			"cost": {
+				"input": .75,
+				"output": 4.5,
+				"cacheRead": .075,
+				"cacheWrite": 0
+			},
+			"contextWindow": 256e3,
+			"maxTokens": 128e3,
+			"headers": {
+				"User-Agent": "GitHubCopilotChat/0.35.0",
+				"Editor-Version": "vscode/1.107.0",
+				"Editor-Plugin-Version": "copilot-chat/0.35.0",
+				"Copilot-Integration-Id": "vscode-chat"
+			},
+			"thinkingLevelMap": {
+				"off": null,
+				"minimal": null,
+				"low": "low",
+				"medium": "medium",
+				"high": "high",
+				"xhigh": null,
+				"max": null
+			}
+		}
+	}
+};
+//#endregion
+//#region src/compat/vendor/pi-oauth-flows/model-catalog.ts
+function flattenModelCatalog(_provider, groups) {
+	return Object.assign({}, ...Object.values(groups));
+}
+//#endregion
+//#region src/compat/vendor/pi-oauth-flows/github-copilot.models.ts
+const GITHUB_COPILOT_MODELS = flattenModelCatalog("github-copilot", github_copilot_default);
+//#endregion
+//#region src/compat/vendor/pi-oauth-flows/github-copilot.ts
+/**
+* GitHub Copilot OAuth flow
+*/
+const decode = (s) => atob(s);
+const CLIENT_ID$1 = decode("SXYxLmI1MDdhMDhjODdlY2ZlOTg=");
+const COPILOT_HEADERS = {
+	"User-Agent": "GitHubCopilotChat/0.35.0",
+	"Editor-Version": "vscode/1.107.0",
+	"Editor-Plugin-Version": "copilot-chat/0.35.0",
+	"Copilot-Integration-Id": "vscode-chat"
+};
+const COPILOT_API_VERSION = "2026-06-01";
+function normalizeDomain(input) {
+	const trimmed = input.trim();
+	if (!trimmed) return null;
+	try {
+		return (trimmed.includes("://") ? new URL(trimmed) : new URL(`https://${trimmed}`)).hostname;
+	} catch {
+		return null;
+	}
+}
+function getUrls(domain) {
+	return {
+		deviceCodeUrl: `https://${domain}/login/device/code`,
+		accessTokenUrl: `https://${domain}/login/oauth/access_token`,
+		copilotTokenUrl: `https://api.${domain}/copilot_internal/v2/token`
+	};
+}
+/**
+* Parse the proxy-ep from a Copilot token and convert to API base URL.
+* Token format: tid=...;exp=...;proxy-ep=proxy.individual.githubcopilot.com;...
+* Returns API URL like https://api.individual.githubcopilot.com
+*/
+function getBaseUrlFromToken(token) {
+	const match = token.match(/proxy-ep=([^;]+)/);
+	if (!match) return null;
+	return `https://${match[1].replace(/^proxy\./, "api.")}`;
+}
+function getGitHubCopilotBaseUrl(token, enterpriseDomain) {
+	if (token) {
+		const urlFromToken = getBaseUrlFromToken(token);
+		if (urlFromToken) return urlFromToken;
+	}
+	if (enterpriseDomain) return `https://copilot-api.${enterpriseDomain}`;
+	return "https://api.individual.githubcopilot.com";
+}
+function asRecord(value) {
+	return value && typeof value === "object" ? value : void 0;
+}
+function parseAvailableCopilotModelIds(raw, allowPolicyFallback) {
+	const data = asRecord(raw)?.data;
+	if (!Array.isArray(data)) throw new Error("Invalid Copilot models response");
+	const pickerIds = [];
+	const policyEnabledIds = [];
+	for (const rawItem of data) {
+		const item = asRecord(rawItem);
+		const id = item?.id;
+		if (!item || typeof id !== "string") continue;
+		if (asRecord(asRecord(item.capabilities)?.supports)?.tool_calls === false) continue;
+		const policy = asRecord(item.policy);
+		if (item.model_picker_enabled === true && policy?.state !== "disabled") pickerIds.push(id);
+		if (policy?.state === "enabled") policyEnabledIds.push(id);
+	}
+	return pickerIds.length > 0 || !allowPolicyFallback ? pickerIds : policyEnabledIds;
+}
+async function fetchAvailableGitHubCopilotModelIds(copilotToken, enterpriseDomain, signal) {
+	const baseUrl = getGitHubCopilotBaseUrl(copilotToken, enterpriseDomain);
+	const allowPolicyFallback = baseUrl === "https://api.individual.githubcopilot.com";
+	return parseAvailableCopilotModelIds(await fetchJson(`${baseUrl}/models`, {
+		headers: {
+			Accept: "application/json",
+			Authorization: `Bearer ${copilotToken}`,
+			...COPILOT_HEADERS,
+			"X-GitHub-Api-Version": COPILOT_API_VERSION
+		},
+		signal: AbortSignal.any([signal, AbortSignal.timeout(5e3)])
+	}), allowPolicyFallback);
+}
+async function fetchJson(url, init) {
+	const response = await fetch(url, init);
+	if (!response.ok) {
+		const text = await response.text();
+		throw new Error(`${response.status} ${response.statusText}: ${text}`);
+	}
+	return response.json();
+}
+async function startDeviceFlow(domain, signal) {
+	const data = await fetchJson(getUrls(domain).deviceCodeUrl, {
+		method: "POST",
+		headers: {
+			Accept: "application/json",
+			"Content-Type": "application/x-www-form-urlencoded",
+			"User-Agent": "GitHubCopilotChat/0.35.0"
+		},
+		body: new URLSearchParams({
+			client_id: CLIENT_ID$1,
+			scope: "read:user"
+		}),
+		signal
+	});
+	if (!data || typeof data !== "object") throw new Error("Invalid device code response");
+	const deviceCode = data.device_code;
+	const userCode = data.user_code;
+	const verificationUri = data.verification_uri;
+	const interval = data.interval;
+	const expiresIn = data.expires_in;
+	if (typeof deviceCode !== "string" || typeof userCode !== "string" || typeof verificationUri !== "string" || interval !== void 0 && typeof interval !== "number" || typeof expiresIn !== "number") throw new Error("Invalid device code response fields");
+	let parsedUri;
+	try {
+		parsedUri = new URL(verificationUri);
+	} catch {
+		throw new Error("Untrusted verification_uri in device code response");
+	}
+	if (parsedUri.protocol !== "https:" && parsedUri.protocol !== "http:") throw new Error("Untrusted verification_uri in device code response");
+	return {
+		device_code: deviceCode,
+		user_code: userCode,
+		verification_uri: parsedUri.href,
+		interval,
+		expires_in: expiresIn
+	};
+}
+async function pollForGitHubAccessToken(domain, device, signal) {
+	const urls = getUrls(domain);
+	return pollOAuthDeviceCodeFlow({
+		intervalSeconds: device.interval,
+		expiresInSeconds: device.expires_in,
+		waitBeforeFirstPoll: true,
+		signal,
+		poll: async () => {
+			const raw = await fetchJson(urls.accessTokenUrl, {
+				method: "POST",
+				headers: {
+					Accept: "application/json",
+					"Content-Type": "application/x-www-form-urlencoded",
+					"User-Agent": "GitHubCopilotChat/0.35.0"
+				},
+				body: new URLSearchParams({
+					client_id: CLIENT_ID$1,
+					device_code: device.device_code,
+					grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+				}),
+				signal
+			});
+			if (raw && typeof raw === "object" && typeof raw.access_token === "string") return {
+				status: "complete",
+				value: raw.access_token
+			};
+			if (raw && typeof raw === "object" && typeof raw.error === "string") {
+				const { error, error_description: description, interval } = raw;
+				if (error === "authorization_pending") return { status: "pending" };
+				if (error === "slow_down") return {
+					status: "slow_down",
+					intervalSeconds: typeof interval === "number" ? interval : void 0
+				};
+				return {
+					status: "failed",
+					message: `Device flow failed: ${error}${description ? `: ${description}` : ""}`
+				};
+			}
+			return {
+				status: "failed",
+				message: "Invalid device token response"
+			};
+		}
+	});
+}
+async function refreshGitHubCopilotAccessToken(refreshToken, enterpriseDomain, signal) {
+	const raw = await fetchJson(getUrls(enterpriseDomain || "github.com").copilotTokenUrl, {
+		headers: {
+			Accept: "application/json",
+			Authorization: `Bearer ${refreshToken}`,
+			...COPILOT_HEADERS
+		},
+		signal
+	});
+	if (!raw || typeof raw !== "object") throw new Error("Invalid Copilot token response");
+	const token = raw.token;
+	const expiresAt = raw.expires_at;
+	if (typeof token !== "string" || typeof expiresAt !== "number") throw new Error("Invalid Copilot token response fields");
+	return {
+		type: "oauth",
+		refresh: refreshToken,
+		access: token,
+		expires: expiresAt * 1e3 - 3e5,
+		enterpriseUrl: enterpriseDomain
+	};
+}
+/**
+* Refresh GitHub Copilot token
+*/
+async function refreshGitHubCopilotToken(refreshToken, enterpriseDomain, signal) {
+	const credentials = await refreshGitHubCopilotAccessToken(refreshToken, enterpriseDomain, signal);
+	return {
+		...credentials,
+		availableModelIds: await fetchAvailableGitHubCopilotModelIds(credentials.access, enterpriseDomain, signal)
+	};
+}
+/**
+* Enable a model for the user's GitHub Copilot account.
+* This is required for some models (like Claude, Grok) before they can be used.
+*/
+async function enableGitHubCopilotModel(token, modelId, enterpriseDomain, signal) {
+	const url = `${getGitHubCopilotBaseUrl(token, enterpriseDomain)}/models/${modelId}/policy`;
+	try {
+		return (await fetch(url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${token}`,
+				...COPILOT_HEADERS,
+				"openai-intent": "chat-policy",
+				"x-interaction-type": "chat-policy"
+			},
+			body: JSON.stringify({ state: "enabled" }),
+			signal
+		})).ok;
+	} catch (error) {
+		if (signal.aborted) throw error;
+		return false;
+	}
+}
+/**
+* Enable all known GitHub Copilot models that may require policy acceptance.
+* Called after successful login to ensure all models are available.
+*/
+async function enableAllGitHubCopilotModels(token, enterpriseDomain, signal) {
+	const models = Object.values(GITHUB_COPILOT_MODELS);
+	await Promise.all(models.map(async (model) => {
+		await enableGitHubCopilotModel(token, model.id, enterpriseDomain, signal);
+	}));
+}
+async function loginGitHubCopilot(interaction) {
+	const input = await interaction.prompt({
+		type: "text",
+		message: "GitHub Enterprise URL/domain (blank for github.com)",
+		placeholder: "company.ghe.com"
+	});
+	if (interaction.signal.aborted) throw new Error("Login cancelled");
+	const trimmed = input.trim();
+	const enterpriseDomain = normalizeDomain(input);
+	if (trimmed && !enterpriseDomain) throw new Error("Invalid GitHub Enterprise URL/domain");
+	const domain = enterpriseDomain || "github.com";
+	const device = await startDeviceFlow(domain, interaction.signal);
+	interaction.notify({
+		type: "device_code",
+		userCode: device.user_code,
+		verificationUri: device.verification_uri,
+		intervalSeconds: device.interval,
+		expiresInSeconds: device.expires_in
+	});
+	const credentials = await refreshGitHubCopilotAccessToken(await pollForGitHubAccessToken(domain, device, interaction.signal), enterpriseDomain ?? void 0, interaction.signal);
+	interaction.notify({
+		type: "progress",
+		message: "Enabling models..."
+	});
+	await enableAllGitHubCopilotModels(credentials.access, enterpriseDomain ?? void 0, interaction.signal);
+	return {
+		...credentials,
+		availableModelIds: await fetchAvailableGitHubCopilotModelIds(credentials.access, enterpriseDomain ?? void 0, interaction.signal)
+	};
+}
+function copilotEnterpriseDomain(credential) {
+	const enterpriseUrl = credential.enterpriseUrl;
+	if (typeof enterpriseUrl !== "string" || !enterpriseUrl) return void 0;
+	return normalizeDomain(enterpriseUrl) ?? void 0;
+}
+const githubCopilotOAuth = {
+	name: "GitHub Copilot",
+	isSubscription: true,
+	login: loginGitHubCopilot,
+	refresh: (credential, signal) => refreshGitHubCopilotToken(credential.refresh, copilotEnterpriseDomain(credential), signal),
+	/** Derive the credential-specific proxy endpoint for each request. */
+	async toAuth(credential) {
+		return {
+			apiKey: credential.access,
+			baseUrl: getGitHubCopilotBaseUrl(credential.access, copilotEnterpriseDomain(credential))
+		};
+	}
+};
+//#endregion
+//#region src/compat/vendor/pi-oauth-flows/kimi-coding.ts
+/**
+* Kimi Code (subscription) OAuth flow
+*
+* RFC 8628 device authorization grant against https://auth.kimi.com with JSON
+* responses. The access token authenticates requests to
+* https://api.kimi.com/coding as an `Authorization: Bearer` header.
+*/
+const CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098";
+const DEFAULT_OAUTH_HOST = "https://auth.kimi.com";
+const DEVICE_CODE_TIMEOUT_SECONDS = 900;
+const DEFAULT_POLL_INTERVAL_SECONDS = 5;
+const REQUEST_TIMEOUT_MS = 3e4;
+const REFRESH_MAX_RETRIES = 3;
+function getOauthHost() {
+	return (getProviderEnvValue("KIMI_CODE_OAUTH_HOST") || getProviderEnvValue("KIMI_OAUTH_HOST") || DEFAULT_OAUTH_HOST).replace(/\/+$/, "");
+}
+function requestSignal(signal) {
+	return AbortSignal.any([AbortSignal.timeout(REQUEST_TIMEOUT_MS), signal]);
+}
+function formUrlEncode(fields) {
+	return new URLSearchParams(fields).toString();
+}
+async function readJson(response) {
+	try {
+		const json = await response.json();
+		return json && typeof json === "object" ? json : null;
+	} catch {
+		return null;
+	}
+}
+/** The verification URI is opened in the user's browser; only http(s) URLs are trusted. */
+function trustedHttpUrl(value) {
+	if (typeof value !== "string" || !value) return null;
+	try {
+		const url = new URL(value);
+		if (url.protocol !== "https:" && url.protocol !== "http:") return null;
+		return url.href;
+	} catch {
+		return null;
+	}
+}
+async function startDeviceAuthorization(oauthHost, signal) {
+	const response = await fetch(`${oauthHost}/api/oauth/device_authorization`, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/x-www-form-urlencoded",
+			Accept: "application/json"
+		},
+		body: formUrlEncode({ client_id: CLIENT_ID }),
+		signal: requestSignal(signal)
+	});
+	if (!response.ok) {
+		const text = await response.text().catch(() => "");
+		throw new Error(`Kimi Code device authorization failed with status ${response.status}${text ? `: ${text}` : ""}`);
+	}
+	const json = await readJson(response);
+	const deviceCode = json?.device_code;
+	const userCode = json?.user_code;
+	const verificationUri = json?.verification_uri;
+	const verificationUriComplete = json?.verification_uri_complete;
+	if (typeof deviceCode !== "string" || typeof userCode !== "string" || typeof verificationUri !== "string" || typeof verificationUriComplete !== "string" || !trustedHttpUrl(verificationUriComplete) || !trustedHttpUrl(verificationUri)) throw new Error(`Invalid Kimi Code device authorization response: ${JSON.stringify(json)}`);
+	const interval = json?.interval;
+	const expiresIn = json?.expires_in;
+	return {
+		deviceCode,
+		userCode,
+		verificationUri,
+		verificationUriComplete,
+		intervalSeconds: typeof interval === "number" && Number.isFinite(interval) && interval > 0 ? interval : DEFAULT_POLL_INTERVAL_SECONDS,
+		expiresInSeconds: typeof expiresIn === "number" && Number.isFinite(expiresIn) && expiresIn > 0 ? expiresIn : DEVICE_CODE_TIMEOUT_SECONDS
+	};
+}
+function parseTokenResponse(json, operation) {
+	const accessToken = json?.access_token;
+	const refreshToken = json?.refresh_token;
+	const expiresIn = json?.expires_in;
+	if (typeof accessToken !== "string" || !accessToken || typeof refreshToken !== "string" || !refreshToken || typeof expiresIn !== "number" || !Number.isFinite(expiresIn) || expiresIn <= 0) throw new Error(`Kimi Code token ${operation} response missing fields: ${JSON.stringify(json)}`);
+	return {
+		access: accessToken,
+		refresh: refreshToken,
+		expires: Date.now() + expiresIn * 1e3
+	};
+}
+async function pollForToken(oauthHost, device, signal) {
+	return pollOAuthDeviceCodeFlow({
+		intervalSeconds: device.intervalSeconds,
+		expiresInSeconds: device.expiresInSeconds,
+		waitBeforeFirstPoll: true,
+		signal,
+		poll: async () => {
+			const response = await fetch(`${oauthHost}/api/oauth/token`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/x-www-form-urlencoded",
+					Accept: "application/json"
+				},
+				body: formUrlEncode({
+					client_id: CLIENT_ID,
+					device_code: device.deviceCode,
+					grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+				}),
+				signal: requestSignal(signal)
+			});
+			if (response.status >= 500) {
+				const text = await response.text().catch(() => "");
+				return {
+					status: "failed",
+					message: `Kimi Code device token request failed with status ${response.status}${text ? `: ${text}` : ""}`
+				};
+			}
+			const json = await readJson(response);
+			if (response.ok && typeof json?.access_token === "string") try {
+				return {
+					status: "complete",
+					value: parseTokenResponse(json, "poll")
+				};
+			} catch (error) {
+				return {
+					status: "failed",
+					message: error instanceof Error ? error.message : String(error)
+				};
+			}
+			const error = json?.error;
+			const description = typeof json?.error_description === "string" ? `: ${json.error_description}` : "";
+			if (error === "authorization_pending") return { status: "pending" };
+			if (error === "slow_down") {
+				const interval = json?.interval;
+				return {
+					status: "slow_down",
+					intervalSeconds: typeof interval === "number" && interval > 0 ? interval : void 0
+				};
+			}
+			if (error === "expired_token") return {
+				status: "failed",
+				message: "Kimi Code device authorization expired. Please restart login."
+			};
+			if (error === "access_denied") return {
+				status: "failed",
+				message: "Kimi Code login was denied."
+			};
+			return {
+				status: "failed",
+				message: `Kimi Code device token request failed (status ${response.status})${typeof error === "string" ? `: ${error}${description}` : ""}`
+			};
+		}
+	});
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		signal.throwIfAborted();
+		const onAbort = () => {
+			clearTimeout(timeout);
+			reject(signal.reason);
+		};
+		const timeout = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function isRetryableRefreshFailure(response) {
+	return response.status === 429 || response.status >= 500;
+}
+async function refreshToken(oauthHost, refreshTokenValue, signal) {
+	let lastError;
+	for (let attempt = 0; attempt <= REFRESH_MAX_RETRIES; attempt++) {
+		if (attempt > 0) await sleep(1e3 * 2 ** (attempt - 1), signal);
+		if (signal.aborted) throw new Error("Kimi Code token refresh aborted");
+		let response;
+		try {
+			response = await fetch(`${oauthHost}/api/oauth/token`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/x-www-form-urlencoded",
+					Accept: "application/json"
+				},
+				body: formUrlEncode({
+					client_id: CLIENT_ID,
+					grant_type: "refresh_token",
+					refresh_token: refreshTokenValue
+				}),
+				signal: requestSignal(signal)
+			});
+		} catch (error) {
+			lastError = error instanceof Error ? error : new Error(String(error));
+			continue;
+		}
+		const json = await readJson(response);
+		if (response.ok) return parseTokenResponse(json, "refresh");
+		if (response.status === 401 || response.status === 403 || json?.error === "invalid_grant") {
+			const description = typeof json?.error_description === "string" ? `: ${json.error_description}` : "";
+			throw new Error(`Kimi Code token refresh unauthorized (status ${response.status})${description}`);
+		}
+		if (isRetryableRefreshFailure(response) && attempt < REFRESH_MAX_RETRIES) {
+			lastError = /* @__PURE__ */ new Error(`Kimi Code token refresh failed with status ${response.status}`);
+			continue;
+		}
+		const text = JSON.stringify(json);
+		throw new Error(`Kimi Code token refresh failed with status ${response.status}${text ? `: ${text}` : ""}`);
+	}
+	throw lastError ?? /* @__PURE__ */ new Error("Kimi Code token refresh failed");
+}
+async function loginKimiCoding(interaction) {
+	const oauthHost = getOauthHost();
+	const device = await startDeviceAuthorization(oauthHost, interaction.signal);
+	interaction.notify({
+		type: "device_code",
+		userCode: device.userCode,
+		verificationUri: device.verificationUriComplete,
+		intervalSeconds: device.intervalSeconds,
+		expiresInSeconds: device.expiresInSeconds
+	});
+	const token = await pollForToken(oauthHost, device, interaction.signal);
+	return {
+		type: "oauth",
+		access: token.access,
+		refresh: token.refresh,
+		expires: token.expires
+	};
+}
+const kimiCodingOAuth = {
+	name: "Kimi Code (subscription)",
+	isSubscription: true,
+	loginLabel: "Sign in with Kimi Code",
+	login: loginKimiCoding,
+	refresh: async (credential, signal) => {
+		const token = await refreshToken(getOauthHost(), credential.refresh, signal);
+		return {
+			type: "oauth",
+			access: token.access,
+			refresh: token.refresh,
+			expires: token.expires
+		};
+	},
+	async toAuth(credential) {
+		return { headers: { Authorization: `Bearer ${credential.access}` } };
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/api/anthropic-messages.lazy.js
+const anthropicMessagesApi = () => lazyApi(() => import("./anthropic-messages-CaYTgvLF.mjs"));
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/api/openai-completions.lazy.js
+const openAICompletionsApi = () => lazyApi(() => import("./openai-completions-DrjrWRdX.mjs"));
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/api/openai-responses.lazy.js
+const openAIResponsesApi = () => lazyApi(() => import("./openai-responses-BRdGpBX6.mjs").then((n) => n.t));
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/api/openai-codex-responses.lazy.js
+const openAICodexResponsesApi = () => lazyApi(() => import("./openai-codex-responses-DedxQjNG.mjs"));
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/api/azure-openai-responses.lazy.js
+const azureOpenAIResponsesApi = () => lazyApi(() => import("./azure-openai-responses-HKWkzl2m.mjs"));
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/api/google-generative-ai.lazy.js
+const googleGenerativeAIApi = () => lazyApi(() => import("./google-generative-ai-2gCFYp-t.mjs"));
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/api/google-vertex.lazy.js
+const googleVertexApi = () => lazyApi(() => import("./google-vertex-Bhyo4z2i.mjs"));
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/api/mistral-conversations.lazy.js
+const mistralConversationsApi = () => lazyApi(() => import("./mistral-conversations-DJyeTo8C.mjs"));
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/api/bedrock-converse-stream.lazy.js
+var __rewriteRelativeImportExtension = function(path, preserveJsx) {
+	if (typeof path === "string" && /^\.\.?\//.test(path)) return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
+		return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
+	});
+	return path;
+};
+/**
+* Loads the bedrock implementation through a variable specifier so bundlers
+* (browser smoke, Bun compile) cannot follow the import into the Node-only
+* AWS SDK. The `.ts`/`.js` rewrite keeps the trick working from both source
+* and built output.
+*/
+const importNodeOnlyApi = (specifier) => {
+	return import(__rewriteRelativeImportExtension(import.meta.url.endsWith(".js") ? specifier.replace(/\.ts$/, ".js") : specifier));
+};
+const bedrockConverseStreamApi = () => lazyApi(async () => await importNodeOnlyApi("./bedrock-converse-stream.ts"));
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/api/pi-messages.lazy.js
+const piMessagesApi = () => lazyApi(() => import("./pi-messages-D61G2tgs.mjs"));
+//#endregion
+//#region src/compat/pi-ai.ts
+/**
+* Pi's standard stored-key → ordered environment fallback auth helper.
+* Semantics copied unchanged from Pi 0.84.1
+* (`packages/ai/src/auth/helpers.ts`, commit
+* 6f707eb36064e82af9c1320a7634f4dfad21049b).
+*/
+function envApiKeyAuth(name, envVars) {
+	return {
+		name,
+		login: async (interaction) => {
+			interaction.signal.throwIfAborted();
+			const key = await interaction.prompt({
+				type: "secret",
+				message: `Enter ${name}`
+			});
+			interaction.signal.throwIfAborted();
+			return {
+				type: "api_key",
+				key
+			};
+		},
+		resolve: async ({ ctx, credential, signal }) => {
+			signal.throwIfAborted();
+			if (credential?.key) return {
+				auth: { apiKey: credential.key },
+				env: credential.env,
+				source: "stored credential"
+			};
+			for (const envVar of envVars) {
+				const value = await ctx.env(envVar);
+				signal.throwIfAborted();
+				if (value) return {
+					auth: { apiKey: value },
+					source: envVar
+				};
+			}
+		}
+	};
+}
+const EXTENDED_THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+function getSupportedThinkingLevels(model) {
+	return EXTENDED_THINKING_LEVELS.filter((level) => {
+		const mapped = model.thinkingLevelMap?.[level];
+		if (mapped === null) return false;
+		if (level === "xhigh" || level === "max") return mapped !== void 0;
+		return true;
+	});
+}
+function clampThinkingLevel(model, level) {
+	const availableLevels = getSupportedThinkingLevels(model);
+	if (availableLevels.includes(level)) return level;
+	const requestedIndex = EXTENDED_THINKING_LEVELS.indexOf(level);
+	if (requestedIndex === -1) return availableLevels[0] ?? "off";
+	for (let i = requestedIndex; i < EXTENDED_THINKING_LEVELS.length; i += 1) {
+		const candidate = EXTENDED_THINKING_LEVELS[i];
+		if (availableLevels.includes(candidate)) return candidate;
+	}
+	for (let i = requestedIndex - 1; i >= 0; i -= 1) {
+		const candidate = EXTENDED_THINKING_LEVELS[i];
+		if (availableLevels.includes(candidate)) return candidate;
+	}
+	return availableLevels[0] ?? "off";
+}
+function modelsAreEqual(a, b) {
+	if (a === null || a === void 0 || b === null || b === void 0) return false;
+	return a.id === b.id && a.provider === b.provider;
+}
+function contentText(content, separator = "\n") {
+	if (typeof content === "string") return content;
+	return content.filter((block) => block.type === "text").map((block) => String(block.text ?? "")).join(separator);
+}
+const globalRegistry = {
+	compatProviders: /* @__PURE__ */ new Map(),
+	apiProviders: /* @__PURE__ */ new Map()
+};
+const scopedRegistry = new AsyncLocalStorage();
+const registry = () => scopedRegistry.getStore() ?? globalRegistry;
+/** Create one isolated copy of Pi's process registries for an Agent runtime. */
+function __createPiAiRuntimeRegistry() {
+	return {
+		compatProviders: /* @__PURE__ */ new Map(),
+		apiProviders: /* @__PURE__ */ new Map()
+	};
+}
+function registerProvider(name, provider) {
+	registry().compatProviders.set(name, provider);
+}
+function getProviders() {
+	return [...registry().compatProviders.keys()];
+}
+function getProvider(name) {
+	return registry().compatProviders.get(name);
+}
+function getModel(_provider, _id) {}
+const getBuiltinModels = (provider) => getModels(provider);
+const getBuiltinModel = (provider, id) => void 0;
+const getBuiltinProviders = () => getProviders();
+function getModels(_provider) {
+	return [];
+}
+function builtinProviders() {
+	const entry = (id, name, baseUrl, oauth) => ({
+		id,
+		name,
+		api: "openai-completions",
+		baseUrl,
+		models: [],
+		auth: { oauth }
+	});
+	return [
+		entry("openai-codex", "OpenAI (ChatGPT Plus/Pro)", "https://chatgpt.com/backend-api/codex", openaiCodexOAuth),
+		entry("anthropic", "Anthropic", "https://api.anthropic.com", anthropicOAuth),
+		entry("github-copilot", "GitHub Copilot", "https://api.githubcopilot.com", githubCopilotOAuth),
+		entry("kimi-coding", "Kimi Code", "https://api.moonshot.ai/anthropic", kimiCodingOAuth)
+	];
+}
+const loadOpenAICodexOAuth = async () => openaiCodexOAuth;
+const loadAnthropicOAuth = async () => anthropicOAuth;
+const loadGitHubCopilotOAuth = async () => githubCopilotOAuth;
+const loadKimiCodingOAuth = async () => kimiCodingOAuth;
+function guardApi(api, fn) {
+	return (model, ...rest) => {
+		const modelApi = model?.api;
+		if (modelApi !== api) throw new Error(`Mismatched api: ${String(modelApi)} expected ${api}`);
+		return fn(model, ...rest);
+	};
+}
+function registerApiProvider(provider, sourceId) {
+	registry().apiProviders.set(provider.api, {
+		provider: {
+			api: provider.api,
+			stream: guardApi(provider.api, provider.stream),
+			streamSimple: guardApi(provider.api, provider.streamSimple)
+		},
+		sourceId
+	});
+}
+function getApiProvider(api) {
+	return registry().apiProviders.get(api)?.provider;
+}
+function getApiProviders() {
+	return Array.from(registry().apiProviders.values(), (entry) => entry.provider);
+}
+function unregisterApiProviders(sourceId) {
+	const providers = registry().apiProviders;
+	for (const [api, entry] of providers.entries()) if (entry.sourceId === sourceId) providers.delete(api);
+}
+let activeLlmBridge;
+const scopedLlmBridge = new AsyncLocalStorage();
+function __setPiAiLlmBridge(bridge) {
+	activeLlmBridge = bridge;
+}
+/** Run extension-owned work with the exact Agent runtime's DSH llm bridge. */
+function __runWithPiAiLlmBridge(bridge, callback) {
+	return scopedLlmBridge.run(bridge, callback);
+}
+/** Bind both designated-model routing and Pi's registries to one Agent runtime. */
+function __runWithPiAiRuntime(bridge, runtimeRegistry, callback) {
+	return scopedRegistry.run(runtimeRegistry, () => scopedLlmBridge.run(bridge, callback));
+}
+function __getPiAiLlmBridge() {
+	return scopedLlmBridge.getStore() ?? activeLlmBridge;
+}
+function requireLlmBridge(api) {
+	const bridge = __getPiAiLlmBridge();
+	if (bridge === void 0) throw new Error(`pi2dsh: pi-ai ${api}() needs a DSH llm service; this composition mounts none, so model calls cannot be routed`);
+	return bridge;
+}
+async function complete(model, context, options) {
+	const result = await requireLlmBridge("complete")(model, context, options).result();
+	if (result instanceof Error) throw result;
+	return result;
+}
+function stream(model, context, options) {
+	return requireLlmBridge("stream")(model, context, options);
+}
+function StringEnum(values, options = {}) {
+	return {
+		type: "string",
+		enum: values,
+		...options.description !== void 0 ? { description: options.description } : {},
+		...options.default !== void 0 ? { default: options.default } : {}
+	};
+}
+//#endregion
+export { isContextOverflow as $, stream as A, openAICompletionsApi as B, loadAnthropicOAuth as C, modelsAreEqual as D, loadOpenAICodexOAuth as E, googleVertexApi as F, openaiCodexOAuth as G, kimiCodingOAuth as H, googleGenerativeAIApi as I, ModelsError as J, generatePKCE as K, azureOpenAIResponsesApi as L, piMessagesApi as M, bedrockConverseStreamApi as N, registerApiProvider as O, mistralConversationsApi as P, AssistantMessageEventStream as Q, openAICodexResponsesApi as R, getSupportedThinkingLevels as S, loadKimiCodingOAuth as T, githubCopilotOAuth as U, anthropicMessagesApi as V, anthropicOAuth as W, lazyApi$1 as X, createProvider as Y, lazyStream$1 as Z, getBuiltinProviders as _, __runWithPiAiLlmBridge as a, getProvider as b, builtinProviders as c, contentText as d, isRecoverableLength as et, envApiKeyAuth as f, getBuiltinModels as g, getBuiltinModel as h, __getPiAiLlmBridge as i, unregisterApiProviders as j, registerProvider as k, clampThinkingLevel as l, getApiProviders as m, Type$1 as n, retryAssistantCall as nt, __runWithPiAiRuntime as o, getApiProvider as p, pollOAuthDeviceCodeFlow as q, __createPiAiRuntimeRegistry as r, uuidv7 as rt, __setPiAiLlmBridge as s, StringEnum as t, isRetryableAssistantError as tt, complete as u, getModel as v, loadGitHubCopilotOAuth as w, getProviders as x, getModels as y, openAIResponsesApi as z };
+
+//# sourceMappingURL=pi-ai-DpqiLdPA.mjs.map