openllmprovider 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1891 @@
+import { t as FileStorage } from "./file-DB-rxfzi.mjs";
+import { t as createLogger } from "./logger-BsHpI_fH.mjs";
+import { n as MemoryStorage, t as createDefaultStorage } from "./auto-CBqNYBXs.mjs";
+import { n as createAuthStore, r as DEFAULT_SCANNERS } from "./resolver-BA7LWSJO.mjs";
+import { getPluginForProvider, getPlugins, loadPluginOptions, registerPlugin } from "./plugin/index.mjs";
+import { z } from "zod";
+import { spawn } from "node:child_process";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { stdin, stdout } from "node:process";
+import { createInterface } from "node:readline/promises";
+import { createServer } from "node:http";
+
+//#region src/catalog/mapper.ts
+const ModelsDevModelSchema = z.object({
+	id: z.string().optional(),
+	name: z.string().optional(),
+	family: z.string().optional(),
+	reasoning: z.boolean().optional(),
+	tool_call: z.boolean().optional(),
+	structured_output: z.boolean().optional(),
+	temperature: z.boolean().optional(),
+	attachment: z.boolean().optional(),
+	streaming: z.boolean().optional(),
+	system_message: z.boolean().optional(),
+	modalities: z.object({
+		input: z.array(z.string()),
+		output: z.array(z.string())
+	}).passthrough(),
+	limit: z.object({
+		context: z.number(),
+		output: z.number(),
+		input_images: z.number().optional()
+	}).passthrough(),
+	cost: z.object({
+		input: z.number(),
+		output: z.number(),
+		cache_read: z.number().optional(),
+		cache_write: z.number().optional()
+	}).passthrough().optional(),
+	status: z.enum([
+		"stable",
+		"beta",
+		"deprecated"
+	]).optional(),
+	knowledge: z.string().optional()
+}).passthrough();
+const ModelsDevProviderSchema = z.object({
+	id: z.string().optional(),
+	name: z.string().optional(),
+	env: z.array(z.string()).optional(),
+	api: z.string().optional(),
+	npm: z.string().optional(),
+	doc: z.string().optional(),
+	models: z.record(z.string(), z.unknown()).optional()
+}).passthrough();
+function mapModelsDevToModelDefinition(modelId, raw, provenance) {
+	const parsed = ModelsDevModelSchema.safeParse(raw);
+	if (!parsed.success) return null;
+	const { id: _id, knowledge, ...rest } = parsed.data;
+	const result = {
+		...rest,
+		modelId
+	};
+	if (knowledge !== void 0) result.knowledgeCutoff = knowledge;
+	if (provenance !== void 0) result.provenance = provenance;
+	return result;
+}
+function mapModelsDevProvider(providerId, raw, provenance) {
+	const parsed = ModelsDevProviderSchema.safeParse(raw);
+	const name = parsed.success ? parsed.data.name ?? providerId : providerId;
+	const rawModels = parsed.success ? parsed.data.models ?? {} : {};
+	const models = [];
+	for (const [modelId, modelRaw] of Object.entries(rawModels)) {
+		const mapped = mapModelsDevToModelDefinition(modelId, modelRaw, provenance);
+		if (mapped) models.push(mapped);
+	}
+	return {
+		provider: {
+			id: providerId,
+			name,
+			...parsed.success && parsed.data.env !== void 0 ? { env: parsed.data.env } : {},
+			...parsed.success && parsed.data.api !== void 0 ? { api: parsed.data.api } : {},
+			...parsed.success && parsed.data.doc !== void 0 ? { doc: parsed.data.doc } : {}
+		},
+		models
+	};
+}
+function mapModelsDevProviderMetadata(providerId, raw) {
+	const parsed = ModelsDevProviderSchema.safeParse(raw);
+	return {
+		id: providerId,
+		name: parsed.success ? parsed.data.name ?? providerId : providerId,
+		...parsed.success && parsed.data.env !== void 0 ? { env: parsed.data.env } : {},
+		...parsed.success && parsed.data.api !== void 0 ? { api: parsed.data.api } : {},
+		...parsed.success && parsed.data.doc !== void 0 ? { doc: parsed.data.doc } : {}
+	};
+}
+
+//#endregion
+//#region src/catalog/merger.ts
+const FIELD_LEVEL_MERGE_KEYS = new Set(["limit", "cost"]);
+const REPLACE_KEYS = new Set(["modalities"]);
+function mergeNestedObject(base, overlay) {
+	if (!overlay) return base ? { ...base } : void 0;
+	if (!base) return { ...overlay };
+	const result = { ...base };
+	for (const key of Object.keys(overlay)) if (overlay[key] !== void 0) result[key] = overlay[key];
+	return result;
+}
+function mergeModelDefinitions(base, overlay) {
+	const result = { ...base };
+	for (const key of Object.keys(overlay)) {
+		if (key === "modelId") continue;
+		const overlayValue = overlay[key];
+		if (overlayValue === void 0) continue;
+		if (FIELD_LEVEL_MERGE_KEYS.has(key)) {
+			const merged = mergeNestedObject(base[key], overlayValue);
+			if (merged !== void 0) result[key] = merged;
+			continue;
+		}
+		if (REPLACE_KEYS.has(key)) {
+			result[key] = overlayValue;
+			continue;
+		}
+		result[key] = overlayValue;
+	}
+	return result;
+}
+function mergeCatalogData(snapshot, remote, overrides) {
+	const allModelIds = new Set([...snapshot.keys(), ...remote.keys()]);
+	const result = /* @__PURE__ */ new Map();
+	for (const modelId of allModelIds) {
+		const snap = snapshot.get(modelId);
+		const rem = remote.get(modelId);
+		const override = overrides.get(modelId);
+		const inSnapshot = snap !== void 0;
+		const inRemote = rem !== void 0;
+		const hasOverride = override !== void 0;
+		let merged;
+		if (inSnapshot && inRemote) merged = mergeModelDefinitions(snap, rem);
+		else if (inRemote) merged = { ...rem };
+		else if (snap) merged = { ...snap };
+		else continue;
+		if (hasOverride) merged = mergeModelDefinitions(merged, override);
+		if (hasOverride) merged.provenance = "user-override";
+		else if (inRemote) merged.provenance = "remote";
+		else merged.provenance = "snapshot";
+		if (inSnapshot && !inRemote) merged.status = "deprecated";
+		result.set(modelId, merged);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/catalog/catalog.ts
+const DEFAULT_REMOTE_URL = "https://models.dev/api.json";
+const DEFAULT_TIMEOUT_MS = 1e4;
+const log$7 = createLogger("catalog");
+var Catalog = class {
+	remoteOptions;
+	snapshotData;
+	remoteData = {};
+	providers = /* @__PURE__ */ new Map();
+	modelsByProvider = /* @__PURE__ */ new Map();
+	refreshInFlight = null;
+	extendedProviders = /* @__PURE__ */ new Map();
+	extendedModels = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		this.snapshotData = options.snapshot ?? {};
+		this.remoteOptions = {
+			url: options.remote?.url ?? DEFAULT_REMOTE_URL,
+			timeoutMs: options.remote?.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+			fetch: options.remote?.fetch
+		};
+		this.applyProviderMetadata(this.snapshotData, {});
+		log$7("initialized with %d providers from snapshot", this.providers.size);
+	}
+	getProvider(id) {
+		return this.providers.get(id);
+	}
+	listProviders() {
+		return [...this.providers.values()];
+	}
+	getModel(providerId, modelId) {
+		this.ensureProviderModelsLoaded(providerId);
+		return this.modelsByProvider.get(providerId)?.get(modelId);
+	}
+	listModels(providerId) {
+		if (providerId !== void 0) {
+			this.ensureProviderModelsLoaded(providerId);
+			return [...this.modelsByProvider.get(providerId)?.values() ?? []];
+		}
+		const results = [];
+		for (const pid of this.providers.keys()) {
+			this.ensureProviderModelsLoaded(pid);
+			const models = this.modelsByProvider.get(pid);
+			if (models) results.push(...models.values());
+		}
+		return results;
+	}
+	enrichModel(providerId, modelId, partial) {
+		const catalogModel = this.getModel(providerId, modelId);
+		const partialWithId = {
+			...partial,
+			modelId
+		};
+		if (!catalogModel) return partialWithId;
+		return mergeModelDefinitions(catalogModel, partialWithId);
+	}
+	extend(config) {
+		if (!config.providers) return;
+		for (const [providerId, providerConfig] of Object.entries(config.providers)) {
+			const existingProvider = this.providers.get(providerId);
+			const provider = {
+				id: providerId,
+				name: providerConfig.name,
+				...providerConfig.env !== void 0 ? { env: providerConfig.env } : {},
+				...existingProvider?.api !== void 0 ? { api: existingProvider.api } : {},
+				...existingProvider?.doc !== void 0 ? { doc: existingProvider.doc } : {},
+				...providerConfig.bundledProvider !== void 0 ? { bundledProvider: providerConfig.bundledProvider } : {},
+				...providerConfig.baseURL !== void 0 ? { baseURL: providerConfig.baseURL } : {},
+				...providerConfig.headers !== void 0 ? { headers: providerConfig.headers } : {},
+				...providerConfig.options !== void 0 ? { options: providerConfig.options } : {}
+			};
+			this.extendedProviders.set(providerId, provider);
+			this.providers.set(providerId, provider);
+			if (providerConfig.models) {
+				const modelOverrides = this.extendedModels.get(providerId) ?? /* @__PURE__ */ new Map();
+				for (const [modelId, modelConfig] of Object.entries(providerConfig.models)) {
+					const partial = { modelId };
+					if (modelConfig.name !== void 0) partial.name = modelConfig.name;
+					if (modelConfig.modalities !== void 0) partial.modalities = modelConfig.modalities;
+					if (modelConfig.limit !== void 0) partial.limit = modelConfig.limit;
+					modelOverrides.set(modelId, partial);
+				}
+				this.extendedModels.set(providerId, modelOverrides);
+			}
+			this.modelsByProvider.delete(providerId);
+		}
+	}
+	refresh() {
+		if (this.refreshInFlight) return this.refreshInFlight;
+		const task = this.refreshInternal().finally(() => {
+			this.refreshInFlight = null;
+		});
+		this.refreshInFlight = task;
+		return task;
+	}
+	async refreshInternal() {
+		try {
+			log$7("refresh: fetching from %s", this.remoteOptions.url);
+			this.remoteData = await this.fetchRemoteData();
+			const { updatedProviders } = this.applyProviderMetadata(this.snapshotData, this.remoteData);
+			this.modelsByProvider.clear();
+			log$7("refresh: updated %d providers", updatedProviders.length);
+			return {
+				success: true,
+				updatedProviders,
+				newModels: 0
+			};
+		} catch (error) {
+			log$7("refresh: failed — %s", error instanceof Error ? error.message : String(error));
+			return {
+				success: false,
+				updatedProviders: [],
+				newModels: 0,
+				error: error instanceof Error ? error : new Error(String(error))
+			};
+		}
+	}
+	async fetchRemoteData() {
+		const fetchFn = this.remoteOptions.fetch ?? this.resolveGlobalFetch();
+		if (!fetchFn) throw new Error("No fetch implementation available");
+		const response = await fetchFn(this.remoteOptions.url);
+		if (!response.ok) throw new Error(`Failed to fetch remote catalog: HTTP ${response.status}`);
+		const payload = await response.json();
+		if (payload && typeof payload === "object") return payload;
+		throw new Error("Invalid remote catalog payload");
+	}
+	resolveGlobalFetch() {
+		const maybeFetch = globalThis.fetch;
+		return typeof maybeFetch === "function" ? maybeFetch : void 0;
+	}
+	applyProviderMetadata(snapshotRaw, remoteRaw) {
+		const snapshotProviders = this.mapProviderMetadata(snapshotRaw);
+		const remoteProviders = this.mapProviderMetadata(remoteRaw);
+		const allProviderIds = new Set([...snapshotProviders.keys(), ...remoteProviders.keys()]);
+		this.providers.clear();
+		for (const providerId of allProviderIds) {
+			const provider = remoteProviders.get(providerId) ?? snapshotProviders.get(providerId);
+			if (provider) this.providers.set(providerId, provider);
+		}
+		for (const [providerId, provider] of this.extendedProviders.entries()) this.providers.set(providerId, provider);
+		return { updatedProviders: [...remoteProviders.keys()] };
+	}
+	mapProviderMetadata(data) {
+		const result = /* @__PURE__ */ new Map();
+		for (const [providerId, rawProvider] of Object.entries(data)) {
+			if (providerId.startsWith("_")) continue;
+			result.set(providerId, mapModelsDevProviderMetadata(providerId, rawProvider));
+		}
+		return result;
+	}
+	providerRaw(data, providerId) {
+		const value = data[providerId];
+		return value && typeof value === "object" ? value : void 0;
+	}
+	mapProviderModelsFromRaw(providerId, raw, provenance) {
+		if (!raw || typeof raw !== "object") return /* @__PURE__ */ new Map();
+		const mapped = mapModelsDevProvider(providerId, raw, provenance);
+		const byId = /* @__PURE__ */ new Map();
+		for (const model of mapped.models) byId.set(model.modelId, model);
+		return byId;
+	}
+	ensureProviderModelsLoaded(providerId) {
+		if (this.modelsByProvider.has(providerId)) return;
+		const snapshotModels = this.mapProviderModelsFromRaw(providerId, this.providerRaw(this.snapshotData, providerId), "snapshot");
+		const remoteModels = this.mapProviderModelsFromRaw(providerId, this.providerRaw(this.remoteData, providerId), "remote");
+		const extendedOverrides = this.extendedModels.get(providerId) ?? /* @__PURE__ */ new Map();
+		const merged = mergeCatalogData(snapshotModels, remoteModels, extendedOverrides);
+		for (const [modelId, partial] of extendedOverrides.entries()) if (!merged.has(modelId)) {
+			const base = {
+				modelId,
+				modalities: {
+					input: ["text"],
+					output: ["text"]
+				},
+				limit: {
+					context: 0,
+					output: 0
+				},
+				provenance: "user-override"
+			};
+			merged.set(modelId, mergeModelDefinitions(base, partial));
+		}
+		this.modelsByProvider.set(providerId, merged);
+	}
+};
+
+//#endregion
+//#region src/plugin/anthropic.ts
+const log$6 = createLogger("plugin:anthropic");
+const CLIENT_ID$1 = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+const AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
+const TOKEN_URL = "https://console.anthropic.com/v1/oauth/token";
+const API_KEY_EXCHANGE_URL = "https://api.anthropic.com/api/oauth/claude_cli/create_api_key";
+const REDIRECT_URI = "https://console.anthropic.com/oauth/code/callback";
+const OAUTH_SCOPES = "org:create_api_key user:profile user:inference";
+const OAUTH_BETA = "oauth-2025-04-20,claude-code-20250219,interleaved-thinking-2025-05-14";
+function isOAuthToken(value) {
+	return value.startsWith("sk-ant-oat") || value.startsWith("sk-ant-ort");
+}
+function looksLikeApiKey(value) {
+	if (isOAuthToken(value)) return false;
+	return value.startsWith("sk-ant-");
+}
+function applyBearerHeaders(headers, token) {
+	headers.delete("x-api-key");
+	headers.delete("authorization");
+	headers.delete("Authorization");
+	headers.set("Authorization", `Bearer ${token}`);
+	headers.set("anthropic-beta", OAUTH_BETA);
+}
+function toBase64Url$2(inputValue) {
+	return inputValue.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function createPkce$1() {
+	const verifier = toBase64Url$2(randomBytes(32));
+	return {
+		verifier,
+		challenge: toBase64Url$2(createHash("sha256").update(verifier).digest())
+	};
+}
+function buildAuthorizationRequest$1() {
+	const { verifier, challenge } = createPkce$1();
+	const state = verifier;
+	const url = new URL(AUTHORIZE_URL);
+	url.searchParams.set("code", "true");
+	url.searchParams.set("client_id", CLIENT_ID$1);
+	url.searchParams.set("response_type", "code");
+	url.searchParams.set("redirect_uri", REDIRECT_URI);
+	url.searchParams.set("scope", OAUTH_SCOPES);
+	url.searchParams.set("code_challenge", challenge);
+	url.searchParams.set("code_challenge_method", "S256");
+	url.searchParams.set("state", state);
+	return {
+		url: url.toString(),
+		verifier,
+		state
+	};
+}
+function openUrlInBrowser$2(url) {
+	const platform = process.platform;
+	const command = platform === "darwin" ? "open" : platform === "win32" ? "rundll32" : "xdg-open";
+	const args = platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
+	try {
+		spawn(command, args, {
+			detached: true,
+			stdio: "ignore"
+		}).unref();
+	} catch {
+		log$6("failed to open browser automatically");
+	}
+}
+async function readCallbackInput$1(question) {
+	const rl = createInterface({
+		input: stdin,
+		output: stdout
+	});
+	try {
+		return (await rl.question(question)).trim();
+	} finally {
+		rl.close();
+	}
+}
+function parseCallbackInput$1(value) {
+	const raw = value.trim();
+	if (raw.length === 0) return {};
+	if (/^https?:\/\//i.test(raw)) try {
+		const u = new URL(raw);
+		return {
+			code: u.searchParams.get("code") ?? void 0,
+			state: u.searchParams.get("state") ?? void 0
+		};
+	} catch {
+		return {};
+	}
+	const maybeQuery = raw.startsWith("?") ? raw.slice(1) : raw;
+	if (maybeQuery.includes("=")) {
+		const params = new URLSearchParams(maybeQuery);
+		const code = params.get("code") ?? void 0;
+		const state = params.get("state") ?? void 0;
+		if (code !== void 0 || state !== void 0) return {
+			code,
+			state
+		};
+	}
+	return { code: raw };
+}
+async function exchangeAuthorizationCode$1(code, verifier, state) {
+	const res = await globalThis.fetch(TOKEN_URL, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Accept: "application/json"
+		},
+		body: JSON.stringify({
+			grant_type: "authorization_code",
+			code,
+			state,
+			client_id: CLIENT_ID$1,
+			redirect_uri: REDIRECT_URI,
+			code_verifier: verifier
+		})
+	});
+	if (!res.ok) {
+		const body = await res.text();
+		throw new Error(`Anthropic token exchange failed: ${res.status} ${res.statusText} ${body}`);
+	}
+	const raw = await res.json();
+	return {
+		access_token: String(raw.access_token ?? ""),
+		refresh_token: typeof raw.refresh_token === "string" ? raw.refresh_token : void 0,
+		expires_in: typeof raw.expires_in === "number" ? raw.expires_in : void 0
+	};
+}
+async function refreshAccessToken$1(refreshToken) {
+	const res = await globalThis.fetch(TOKEN_URL, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Accept: "application/json"
+		},
+		body: JSON.stringify({
+			grant_type: "refresh_token",
+			refresh_token: refreshToken,
+			client_id: CLIENT_ID$1
+		})
+	});
+	if (!res.ok) {
+		const body = await res.text().catch(() => "");
+		throw new Error(`Anthropic token refresh failed: ${res.status} ${res.statusText} ${body}`);
+	}
+	const raw = await res.json();
+	return {
+		access_token: String(raw.access_token ?? ""),
+		refresh_token: typeof raw.refresh_token === "string" ? raw.refresh_token : void 0,
+		expires_in: typeof raw.expires_in === "number" ? raw.expires_in : void 0
+	};
+}
+async function createApiKeyFromOAuthAccessToken(accessToken) {
+	const res = await globalThis.fetch(API_KEY_EXCHANGE_URL, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${accessToken}`,
+			"Content-Type": "application/json",
+			Accept: "application/json"
+		},
+		body: "{}"
+	});
+	if (!res.ok) {
+		const body = await res.text();
+		throw new Error(`Anthropic API key exchange failed: ${res.status} ${res.statusText} ${body}`);
+	}
+	const raw = await res.json();
+	if (typeof raw.raw_key !== "string" || raw.raw_key.length === 0) throw new Error("Anthropic API key exchange returned empty raw_key");
+	return raw.raw_key;
+}
+/**
+* Resolve a fresh OAuth access_token from the credential, refreshing if expired.
+* Used both during loader setup and inside the per-request Bearer fallback fetch.
+* When a refresh occurs and setAuth is provided, the updated credential is persisted.
+*/
+async function resolveOAuthToken(auth, setAuth) {
+	let token = auth.key;
+	if (auth.expires !== void 0 && auth.expires < Date.now() && typeof auth.refresh === "string") try {
+		const refreshed = await refreshAccessToken$1(auth.refresh);
+		token = refreshed.access_token;
+		if (setAuth) await setAuth({
+			...auth,
+			key: refreshed.access_token,
+			refresh: refreshed.refresh_token ?? auth.refresh,
+			expires: refreshed.expires_in !== void 0 ? Date.now() + refreshed.expires_in * 1e3 : void 0
+		}).catch((err) => log$6("failed to persist refreshed credential: %s", err instanceof Error ? err.message : String(err)));
+	} catch (error) {
+		log$6("anthropic token refresh failed: %s", error instanceof Error ? error.message : String(error));
+	}
+	return typeof token === "string" && token.length > 0 ? token : void 0;
+}
+const anthropicPlugin = {
+	provider: "anthropic",
+	async loader(getAuth, _provider, setAuth) {
+		const auth = await getAuth();
+		if (auth.type !== "oauth") return {};
+		const token = await resolveOAuthToken(auth, setAuth);
+		if (token !== void 0) {
+			if (looksLikeApiKey(token)) return { apiKey: token };
+			try {
+				return { apiKey: await createApiKeyFromOAuthAccessToken(token) };
+			} catch (error) {
+				log$6("anthropic api key exchange failed, using oauth bearer fallback: %s", String(error));
+			}
+		}
+		return {
+			headers: { "anthropic-beta": OAUTH_BETA },
+			async fetch(request, init) {
+				const bearerToken = await resolveOAuthToken(await getAuth(), setAuth);
+				const headers = new Headers(init?.headers);
+				applyBearerHeaders(headers, bearerToken ?? "");
+				return globalThis.fetch(request, {
+					...init,
+					headers
+				});
+			}
+		};
+	},
+	methods: [{
+		type: "oauth",
+		label: "Claude Pro/Max (Browser OAuth)",
+		async handler() {
+			const authRequest = buildAuthorizationRequest$1();
+			console.log("Open this URL to continue Claude Pro/Max OAuth:");
+			console.log(authRequest.url);
+			openUrlInBrowser$2(authRequest.url);
+			const parsed = parseCallbackInput$1(await readCallbackInput$1("Paste the callback URL or authorization code: "));
+			if (!parsed.code) throw new Error("Missing authorization code in callback input");
+			if (parsed.state !== void 0 && parsed.state !== authRequest.state) throw new Error("OAuth state mismatch");
+			const tokens = await exchangeAuthorizationCode$1(parsed.code, authRequest.verifier, authRequest.state);
+			return {
+				type: "oauth",
+				key: tokens.access_token,
+				refresh: tokens.refresh_token,
+				expires: tokens.expires_in !== void 0 ? Date.now() + tokens.expires_in * 1e3 : void 0
+			};
+		}
+	}]
+};
+
+//#endregion
+//#region src/plugin/codex.ts
+const log$5 = createLogger("plugin:codex");
+const OAUTH_DUMMY_KEY = "codex-oauth-placeholder";
+const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+const ISSUER = "https://auth.openai.com";
+const OPENAI_AUTHORIZE_URL = `${ISSUER}/oauth/authorize`;
+const OPENAI_TOKEN_URL = `${ISSUER}/oauth/token`;
+const OPENAI_DEVICE_USERCODE_URL = `${ISSUER}/api/accounts/deviceauth/usercode`;
+const OPENAI_DEVICE_TOKEN_URL = `${ISSUER}/api/accounts/deviceauth/token`;
+const OPENAI_DEVICE_VERIFY_URL = `${ISSUER}/codex/device`;
+const CODEX_API_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
+const DEVICE_USER_AGENT = "openllmprovider/codex-auth";
+const OAUTH_CALLBACK_PORT = 1455;
+const OAUTH_CALLBACK_PATH = "/auth/callback";
+const OAUTH_CALLBACK_TIMEOUT_MS = 300 * 1e3;
+function parseTokenResponse(raw) {
+	return {
+		access_token: String(raw.access_token ?? ""),
+		refresh_token: typeof raw.refresh_token === "string" ? raw.refresh_token : void 0,
+		expires_in: Number(raw.expires_in ?? 3600),
+		token_type: String(raw.token_type ?? "Bearer")
+	};
+}
+/**
+* Decode a JWT payload (base64url) and return claims as a plain object.
+* Returns undefined if the token is not a valid JWT.
+*/
+function decodeJwtPayload(token) {
+	const parts = token.split(".");
+	if (parts.length !== 3) return void 0;
+	try {
+		const base64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+		const padded = base64 + "===".slice((base64.length + 3) % 4);
+		const decoded = atob(padded);
+		const parsed = JSON.parse(decoded);
+		if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+	} catch {}
+}
+/**
+* Extract the ChatGPT account ID from an OpenAI OAuth JWT access token.
+* The claim is nested: token["https://api.openai.com/auth"]["chatgpt_account_id"]
+*/
+function extractAccountIdFromJwt(token) {
+	const claims = decodeJwtPayload(token);
+	if (claims === void 0) return void 0;
+	const authClaim = claims["https://api.openai.com/auth"];
+	if (authClaim !== null && typeof authClaim === "object" && !Array.isArray(authClaim)) {
+		const id = authClaim.chatgpt_account_id;
+		if (typeof id === "string" && id.length > 0) return id;
+	}
+}
+function toBase64Url$1(input) {
+	return input.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function createPkcePair() {
+	const verifier = toBase64Url$1(randomBytes(32));
+	return {
+		verifier,
+		challenge: toBase64Url$1(createHash("sha256").update(verifier).digest())
+	};
+}
+function openUrlInBrowser$1(url) {
+	const platform = process.platform;
+	const command = platform === "darwin" ? "open" : platform === "win32" ? "rundll32" : "xdg-open";
+	const args = platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
+	try {
+		spawn(command, args, {
+			detached: true,
+			stdio: "ignore"
+		}).unref();
+	} catch {
+		log$5("failed to open browser automatically");
+	}
+}
+async function startBrowserOAuthFlow() {
+	const { verifier, challenge } = createPkcePair();
+	const state = toBase64Url$1(randomBytes(24));
+	const redirectUri = `http://localhost:${OAUTH_CALLBACK_PORT}${OAUTH_CALLBACK_PATH}`;
+	const authUrl = new URL(OPENAI_AUTHORIZE_URL);
+	authUrl.searchParams.set("response_type", "code");
+	authUrl.searchParams.set("client_id", CLIENT_ID);
+	authUrl.searchParams.set("redirect_uri", redirectUri);
+	authUrl.searchParams.set("scope", "openid profile email offline_access");
+	authUrl.searchParams.set("code_challenge", challenge);
+	authUrl.searchParams.set("code_challenge_method", "S256");
+	authUrl.searchParams.set("state", state);
+	authUrl.searchParams.set("id_token_add_organizations", "true");
+	authUrl.searchParams.set("codex_cli_simplified_flow", "true");
+	authUrl.searchParams.set("originator", "openllmprovider");
+	const successPage = "<!doctype html><html><body style=\"font-family:system-ui;padding:24px\">Authentication complete. You can close this tab.</body></html>";
+	const errorPage = "<!doctype html><html><body style=\"font-family:system-ui;padding:24px\">Authentication failed. Return to terminal.</body></html>";
+	let resolved = false;
+	let rejectAuth = () => {};
+	let closeServer = async () => {};
+	const callbackPromise = new Promise((resolve, reject) => {
+		rejectAuth = reject;
+		const server = createServer((req, res) => {
+			if (!req.url) {
+				res.statusCode = 400;
+				res.end(errorPage);
+				if (!resolved) {
+					resolved = true;
+					reject(/* @__PURE__ */ new Error("OAuth callback request missing URL"));
+				}
+				return;
+			}
+			const callbackUrl = new URL(req.url, `http://localhost:${OAUTH_CALLBACK_PORT}`);
+			if (callbackUrl.pathname !== OAUTH_CALLBACK_PATH) {
+				res.statusCode = 404;
+				res.end("Not Found");
+				return;
+			}
+			const error = callbackUrl.searchParams.get("error");
+			const errorDescription = callbackUrl.searchParams.get("error_description");
+			const code = callbackUrl.searchParams.get("code") ?? void 0;
+			const responseState = callbackUrl.searchParams.get("state") ?? void 0;
+			if (error) {
+				res.statusCode = 400;
+				res.setHeader("Content-Type", "text/html; charset=utf-8");
+				res.end(errorPage);
+				if (!resolved) {
+					resolved = true;
+					reject(new Error(errorDescription ?? error));
+				}
+				return;
+			}
+			if (!code) {
+				res.statusCode = 400;
+				res.setHeader("Content-Type", "text/html; charset=utf-8");
+				res.end(errorPage);
+				if (!resolved) {
+					resolved = true;
+					reject(/* @__PURE__ */ new Error("OAuth callback missing code"));
+				}
+				return;
+			}
+			res.statusCode = 200;
+			res.setHeader("Content-Type", "text/html; charset=utf-8");
+			res.end(successPage);
+			if (!resolved) {
+				resolved = true;
+				resolve({
+					code,
+					state: responseState
+				});
+			}
+		});
+		server.once("error", (error) => {
+			if (!resolved) {
+				resolved = true;
+				reject(error);
+			}
+		});
+		server.listen(OAUTH_CALLBACK_PORT, "127.0.0.1");
+		closeServer = async () => {
+			await new Promise((closeResolve) => {
+				server.close(() => closeResolve());
+			});
+		};
+	});
+	const timeout = setTimeout(() => {
+		if (!resolved) {
+			resolved = true;
+			rejectAuth(/* @__PURE__ */ new Error("Browser OAuth timed out waiting for callback"));
+		}
+	}, OAUTH_CALLBACK_TIMEOUT_MS);
+	const stop = async () => {
+		clearTimeout(timeout);
+		await closeServer();
+	};
+	return {
+		authorizationUrl: authUrl.toString(),
+		callbackPromise,
+		expectedState: state,
+		codeVerifier: verifier,
+		stop
+	};
+}
+function extractApiErrorMessage(rawBody) {
+	try {
+		const parsed = JSON.parse(rawBody);
+		const direct = parsed.message;
+		if (typeof direct === "string" && direct.length > 0) return direct;
+		const nested = parsed.error;
+		if (nested !== null && typeof nested === "object" && !Array.isArray(nested)) {
+			const msg = nested.message;
+			if (typeof msg === "string" && msg.length > 0) return msg;
+		}
+	} catch {
+		return rawBody;
+	}
+	return rawBody;
+}
+function isDeviceAuthSecurityGate(message) {
+	const text = message.toLowerCase();
+	return text.includes("enable device code authorization for codex") || text.includes("chatgpt security settings") || text.includes("device code authorization");
+}
+async function startDeviceAuth() {
+	const res = await globalThis.fetch(OPENAI_DEVICE_USERCODE_URL, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			"User-Agent": DEVICE_USER_AGENT
+		},
+		body: JSON.stringify({ client_id: CLIENT_ID })
+	});
+	if (!res.ok) {
+		const body = await res.text();
+		throw new Error(`Device auth start failed: ${res.status} ${res.statusText} ${body}`);
+	}
+	const raw = await res.json();
+	return {
+		device_auth_id: String(raw.device_auth_id ?? ""),
+		user_code: String(raw.user_code ?? ""),
+		interval: typeof raw.interval === "string" || typeof raw.interval === "number" ? raw.interval : void 0
+	};
+}
+async function pollDeviceAuthorizationCode(deviceAuthId, userCode, intervalSeconds) {
+	const intervalMs = Math.max(intervalSeconds, 1) * 1e3;
+	const maxPolls = 120;
+	for (let i = 0; i < maxPolls; i++) {
+		await new Promise((resolve) => setTimeout(resolve, intervalMs + 3e3));
+		const res = await globalThis.fetch(OPENAI_DEVICE_TOKEN_URL, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				"User-Agent": DEVICE_USER_AGENT
+			},
+			body: JSON.stringify({
+				device_auth_id: deviceAuthId,
+				user_code: userCode
+			})
+		});
+		if (res.ok) {
+			const raw = await res.json();
+			const authorizationCode = String(raw.authorization_code ?? "");
+			const codeVerifier = String(raw.code_verifier ?? "");
+			if (!authorizationCode || !codeVerifier) throw new Error("Device auth token response missing authorization_code/code_verifier");
+			log$5("poll[%d]: authorization code acquired", i + 1);
+			return {
+				authorization_code: authorizationCode,
+				code_verifier: codeVerifier
+			};
+		}
+		if (res.status === 403 || res.status === 404) {
+			if (res.status === 403) {
+				const message = extractApiErrorMessage(await res.text());
+				if (isDeviceAuthSecurityGate(message)) throw new Error(message);
+			}
+			log$5("poll[%d]: pending (%d)", i + 1, res.status);
+			continue;
+		}
+		const body = await res.text();
+		throw new Error(`Device auth poll failed: ${res.status} ${res.statusText} ${body}`);
+	}
+	throw new Error("Device flow timed out after polling limit reached");
+}
+async function exchangeAuthorizationCodeForTokens(authorizationCode, codeVerifier) {
+	const body = new URLSearchParams({
+		grant_type: "authorization_code",
+		code: authorizationCode,
+		redirect_uri: `${ISSUER}/deviceauth/callback`,
+		client_id: CLIENT_ID,
+		code_verifier: codeVerifier
+	});
+	const res = await globalThis.fetch(OPENAI_TOKEN_URL, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: body.toString()
+	});
+	if (!res.ok) {
+		const rawBody = await res.text();
+		throw new Error(`Token exchange failed: ${res.status} ${res.statusText} ${rawBody}`);
+	}
+	return parseTokenResponse(await res.json());
+}
+async function exchangeBrowserAuthorizationCode(code, codeVerifier) {
+	const redirectUri = `http://localhost:${OAUTH_CALLBACK_PORT}${OAUTH_CALLBACK_PATH}`;
+	const body = new URLSearchParams({
+		grant_type: "authorization_code",
+		code,
+		redirect_uri: redirectUri,
+		client_id: CLIENT_ID,
+		code_verifier: codeVerifier
+	});
+	const res = await globalThis.fetch(OPENAI_TOKEN_URL, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: body.toString()
+	});
+	if (!res.ok) {
+		const rawBody = await res.text();
+		throw new Error(`Browser token exchange failed: ${res.status} ${res.statusText} ${rawBody}`);
+	}
+	return parseTokenResponse(await res.json());
+}
+/**
+* Exchange a refresh_token for a new access_token using form-urlencoded POST.
+*/
+async function refreshAccessToken(refreshToken) {
+	log$5("refreshing access token");
+	const body = new URLSearchParams({
+		grant_type: "refresh_token",
+		refresh_token: refreshToken,
+		client_id: CLIENT_ID
+	});
+	const res = await globalThis.fetch(OPENAI_TOKEN_URL, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: body.toString()
+	});
+	if (!res.ok) throw new Error(`Token refresh failed: ${res.status} ${res.statusText}`);
+	return parseTokenResponse(await res.json());
+}
+/**
+* Check if a request URL should be rewritten to the Codex endpoint.
+*/
+function shouldRewriteUrl(input) {
+	let url;
+	try {
+		if (input instanceof Request) url = new URL(input.url);
+		else url = new URL(String(input));
+	} catch {
+		return false;
+	}
+	const pathname = url.pathname;
+	return pathname.includes("/v1/responses") || pathname.includes("/chat/completions");
+}
+/**
+* Buffer a streaming SSE response from the Codex endpoint and extract the
+* final response.completed event into a synthetic Responses API JSON object.
+*/
+async function bufferCodexStream(response) {
+	const lines = (await response.text()).split("\n");
+	let lastResponseData;
+	for (const line of lines) {
+		if (!line.startsWith("data: ")) continue;
+		const jsonStr = line.slice(6);
+		if (jsonStr === "[DONE]") break;
+		try {
+			const event = JSON.parse(jsonStr);
+			if (event !== null && typeof event === "object" && !Array.isArray(event)) {
+				const e = event;
+				if (e.type === "response.completed" || e.type === "response.done") {
+					const resp = e.response;
+					if (resp !== null && typeof resp === "object" && !Array.isArray(resp)) lastResponseData = resp;
+				}
+			}
+		} catch {}
+	}
+	if (lastResponseData !== void 0) return lastResponseData;
+	log$5("bufferCodexStream: no response.completed event found in SSE stream");
+	return { error: { message: "Failed to parse streaming response from Codex endpoint" } };
+}
+/**
+* Built-in auth plugin for OpenAI Codex (OAuth).
+*
+* Only activates for OAuth credentials (`auth.type === 'oauth'`). API key
+* credentials fall through with an empty options object so the standard
+* OpenAI SDK path handles them.
+*
+* When active the plugin:
+*  1. Sets a dummy apiKey so the SDK doesn't reject construction
+*  2. Wraps fetch to auto-refresh expired tokens via refresh_token
+*  3. Injects `Authorization: Bearer <access_token>`
+*  4. Sets `ChatGPT-Account-Id` from stored accountId or JWT claims
+*  5. Rewrites `/v1/responses` and `/chat/completions` URLs to the Codex endpoint
+*/
+const codexPlugin = {
+	provider: "openai",
+	async loader(getAuth, _provider, setAuth) {
+		const auth = await getAuth();
+		if (auth.type !== "oauth") {
+			log$5("codex loader: skipping (type=%s)", auth.type);
+			return {};
+		}
+		log$5("codex loader: activating OAuth fetch wrapper");
+		return {
+			apiKey: OAUTH_DUMMY_KEY,
+			async fetch(request, init) {
+				let currentAuth = await getAuth();
+				if (currentAuth.expires !== void 0 && currentAuth.expires < Date.now() && typeof currentAuth.refresh === "string") {
+					log$5("token expired, attempting refresh...");
+					try {
+						const tokens = await refreshAccessToken(currentAuth.refresh);
+						currentAuth = {
+							...currentAuth,
+							key: tokens.access_token,
+							refresh: tokens.refresh_token ?? currentAuth.refresh,
+							expires: Date.now() + tokens.expires_in * 1e3
+						};
+						await setAuth(currentAuth).catch((err) => log$5("failed to persist refreshed credential: %s", err instanceof Error ? err.message : String(err)));
+						log$5("token refreshed successfully");
+					} catch (err) {
+						log$5("token refresh failed: %s", err instanceof Error ? err.message : String(err));
+					}
+				}
+				const headers = new Headers(init?.headers);
+				headers.delete("Authorization");
+				const token = currentAuth.key ?? "";
+				headers.set("Authorization", `Bearer ${token}`);
+				let accountId = typeof currentAuth.accountId === "string" ? currentAuth.accountId : void 0;
+				if (accountId === void 0 && token.length > 0) accountId = extractAccountIdFromJwt(token);
+				if (typeof accountId === "string" && accountId.length > 0) headers.set("ChatGPT-Account-Id", accountId);
+				const isCodexRewrite = shouldRewriteUrl(request);
+				const rewritten = isCodexRewrite ? CODEX_API_ENDPOINT : request;
+				let patchedInit = init;
+				let needsStreamBuffer = false;
+				if (isCodexRewrite && init?.body) try {
+					const bodyStr = typeof init.body === "string" ? init.body : new TextDecoder().decode(init.body);
+					const parsed = JSON.parse(bodyStr);
+					if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+						const body = parsed;
+						if (body.store !== false) body.store = false;
+						if (typeof body.instructions !== "string" || body.instructions.length === 0) body.instructions = "You are a helpful assistant.";
+						if (body.stream !== true) {
+							body.stream = true;
+							needsStreamBuffer = true;
+						}
+						patchedInit = {
+							...init,
+							body: JSON.stringify(body)
+						};
+					}
+				} catch {}
+				log$5("codex fetch: rewritten=%s, needsStreamBuffer=%s", isCodexRewrite, needsStreamBuffer);
+				const response = await globalThis.fetch(rewritten, {
+					...patchedInit,
+					headers
+				});
+				if (needsStreamBuffer && response.ok && response.body) {
+					const syntheticBody = await bufferCodexStream(response);
+					return new Response(JSON.stringify(syntheticBody), {
+						status: 200,
+						headers: { "Content-Type": "application/json" }
+					});
+				}
+				return response;
+			}
+		};
+	},
+	methods: [{
+		type: "oauth",
+		label: "ChatGPT Pro/Plus (browser)",
+		async handler() {
+			log$5("starting browser OAuth flow");
+			const oauth = await startBrowserOAuthFlow();
+			try {
+				console.log("Open this URL to continue Codex login:");
+				console.log(oauth.authorizationUrl);
+				openUrlInBrowser$1(oauth.authorizationUrl);
+				const callback = await oauth.callbackPromise;
+				if (callback.state !== void 0 && callback.state !== oauth.expectedState) throw new Error("OAuth state mismatch");
+				const tokens = await exchangeBrowserAuthorizationCode(callback.code, oauth.codeVerifier);
+				return {
+					type: "oauth",
+					key: tokens.access_token,
+					refresh: tokens.refresh_token,
+					expires: Date.now() + tokens.expires_in * 1e3
+				};
+			} finally {
+				await oauth.stop();
+			}
+		}
+	}, {
+		type: "device-flow",
+		label: "ChatGPT Pro/Plus (headless)",
+		async handler() {
+			log$5("starting OpenAI device flow");
+			const deviceData = await startDeviceAuth();
+			const interval = Number(deviceData.interval ?? 5);
+			const verificationUri = OPENAI_DEVICE_VERIFY_URL;
+			const userCode = deviceData.user_code;
+			log$5("device flow: user_code=%s", userCode);
+			log$5("device flow: verify at %s", verificationUri);
+			const authCode = await pollDeviceAuthorizationCode(deviceData.device_auth_id, userCode, interval);
+			const tokens = await exchangeAuthorizationCodeForTokens(authCode.authorization_code, authCode.code_verifier);
+			return {
+				type: "oauth",
+				key: tokens.access_token,
+				refresh: tokens.refresh_token,
+				expires: Date.now() + tokens.expires_in * 1e3
+			};
+		}
+	}]
+};
+
+//#endregion
+//#region src/plugin/copilot.ts
+const log$4 = createLogger("plugin:copilot");
+const GITHUB_CLIENT_ID = "Ov23li8tweQw6odWQebz";
+const GITHUB_DEFAULT_DOMAIN = "github.com";
+function normalizeDomain(url) {
+	return url.replace(/^https?:\/\//, "").replace(/\/$/, "");
+}
+function getUrls(domain) {
+	return {
+		deviceCodeUrl: `https://${domain}/login/device/code`,
+		accessTokenUrl: `https://${domain}/login/oauth/access_token`
+	};
+}
+function resolveEnterpriseDomainFromEnv() {
+	const raw = process.env.OPENLLMPROVIDER_COPILOT_ENTERPRISE_URL?.trim();
+	if (!raw) throw new Error("Missing OPENLLMPROVIDER_COPILOT_ENTERPRISE_URL. Example: github.company.com or https://github.company.com");
+	return normalizeDomain(raw);
+}
+async function runDeviceFlow(domain) {
+	const urls = getUrls(domain);
+	const deviceRes = await globalThis.fetch(urls.deviceCodeUrl, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Accept: "application/json"
+		},
+		body: JSON.stringify({
+			client_id: GITHUB_CLIENT_ID,
+			scope: "read:user"
+		})
+	});
+	if (!deviceRes.ok) {
+		const body = await deviceRes.text();
+		throw new Error(`Device flow init failed: ${deviceRes.status} ${deviceRes.statusText} ${body}`);
+	}
+	const deviceData = await deviceRes.json();
+	log$4("device flow: domain=%s user_code=%s verification_uri=%s", domain, deviceData.user_code, deviceData.verification_uri);
+	const token = await pollForToken(urls.accessTokenUrl, deviceData.device_code, deviceData.interval);
+	return {
+		type: "oauth",
+		refresh: token,
+		key: token,
+		expires: 0,
+		...domain !== GITHUB_DEFAULT_DOMAIN ? { enterpriseUrl: domain } : {}
+	};
+}
+const copilotPlugin = {
+	provider: "github-copilot",
+	async loader(getAuth, _provider) {
+		const auth = await getAuth();
+		const enterpriseUrl = typeof auth.enterpriseUrl === "string" ? auth.enterpriseUrl : void 0;
+		return {
+			baseURL: enterpriseUrl ? `https://copilot-api.${normalizeDomain(enterpriseUrl)}` : "https://api.githubcopilot.com",
+			apiKey: "",
+			async fetch(...[request, init]) {
+				const auth = await getAuth();
+				const headers = new Headers(init?.headers);
+				headers.delete("x-api-key");
+				headers.delete("Authorization");
+				headers.set("Authorization", `Bearer ${auth.refresh ?? auth.key ?? ""}`);
+				headers.set("Openai-Intent", "conversation-edits");
+				log$4("copilot fetch: injecting auth headers");
+				return globalThis.fetch(request, {
+					...init,
+					headers
+				});
+			}
+		};
+	},
+	methods: [{
+		type: "oauth",
+		label: "GitHub Copilot (GitHub.com)",
+		async handler() {
+			log$4("starting github.com device flow");
+			return runDeviceFlow(GITHUB_DEFAULT_DOMAIN);
+		}
+	}, {
+		type: "device-flow",
+		label: "GitHub Copilot Enterprise (Device Flow)",
+		async handler() {
+			log$4("starting enterprise device flow");
+			return runDeviceFlow(resolveEnterpriseDomainFromEnv());
+		}
+	}]
+};
+async function pollForToken(accessTokenUrl, deviceCode, interval) {
+	const pollInterval = Math.max(interval, 5) * 1e3;
+	while (true) {
+		await new Promise((resolve) => setTimeout(resolve, pollInterval));
+		const data = await (await globalThis.fetch(accessTokenUrl, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Accept: "application/json"
+			},
+			body: JSON.stringify({
+				client_id: GITHUB_CLIENT_ID,
+				device_code: deviceCode,
+				grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+			})
+		})).json();
+		if (data.access_token) {
+			log$4("device flow: token obtained");
+			return data.access_token;
+		}
+		if (data.error === "authorization_pending") {
+			log$4("device flow: waiting for user authorization...");
+			continue;
+		}
+		if (data.error === "slow_down") {
+			log$4("device flow: slowing down");
+			await new Promise((resolve) => setTimeout(resolve, 5e3));
+			continue;
+		}
+		throw new Error(`Device flow failed: ${data.error ?? "unknown error"}`);
+	}
+}
+
+//#endregion
+//#region src/plugin/google.ts
+const log$3 = createLogger("plugin:google");
+const GEMINI_CLIENT_ID = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com";
+const GEMINI_CLIENT_SECRET = "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";
+const GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
+const GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+const GOOGLE_USERINFO_URL = "https://www.googleapis.com/oauth2/v1/userinfo?alt=json";
+const GEMINI_REDIRECT_URI = "http://localhost:8085/oauth2callback";
+const GEMINI_SCOPES = [
+	"https://www.googleapis.com/auth/cloud-platform",
+	"https://www.googleapis.com/auth/userinfo.email",
+	"https://www.googleapis.com/auth/userinfo.profile"
+];
+const CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
+const CODE_ASSIST_HEADERS = {
+	"User-Agent": "google-api-nodejs-client/9.15.1",
+	"X-Goog-Api-Client": "gl-node/22.17.0",
+	"Client-Metadata": "ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI"
+};
+function resolveProjectId() {
+	const explicit = process.env.OPENLLMPROVIDER_GOOGLE_PROJECT_ID?.trim();
+	if (explicit) return explicit;
+	const gcp = process.env.GOOGLE_CLOUD_PROJECT?.trim() ?? process.env.GOOGLE_CLOUD_PROJECT_ID?.trim();
+	if (gcp) return gcp;
+	return "";
+}
+async function refreshGoogleToken(refreshToken) {
+	log$3("refreshing Google OAuth token");
+	const body = new URLSearchParams({
+		grant_type: "refresh_token",
+		refresh_token: refreshToken,
+		client_id: GEMINI_CLIENT_ID,
+		client_secret: GEMINI_CLIENT_SECRET
+	});
+	const res = await globalThis.fetch(GOOGLE_TOKEN_URL, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: body.toString()
+	});
+	if (!res.ok) throw new Error(`Google token refresh failed: ${res.status} ${res.statusText}`);
+	const raw = await res.json();
+	return {
+		access_token: String(raw.access_token ?? ""),
+		refresh_token: typeof raw.refresh_token === "string" ? raw.refresh_token : void 0,
+		expires_in: Number(raw.expires_in ?? 3600),
+		token_type: String(raw.token_type ?? "Bearer")
+	};
+}
+function toBase64Url(inputValue) {
+	return inputValue.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function createPkce() {
+	const verifier = toBase64Url(randomBytes(32));
+	return {
+		verifier,
+		challenge: toBase64Url(createHash("sha256").update(verifier).digest())
+	};
+}
+function buildAuthorizationRequest() {
+	const { verifier, challenge } = createPkce();
+	const state = toBase64Url(randomBytes(24));
+	const url = new URL(GOOGLE_AUTH_URL);
+	url.searchParams.set("client_id", GEMINI_CLIENT_ID);
+	url.searchParams.set("response_type", "code");
+	url.searchParams.set("redirect_uri", GEMINI_REDIRECT_URI);
+	url.searchParams.set("scope", GEMINI_SCOPES.join(" "));
+	url.searchParams.set("code_challenge", challenge);
+	url.searchParams.set("code_challenge_method", "S256");
+	url.searchParams.set("state", state);
+	url.searchParams.set("access_type", "offline");
+	url.searchParams.set("prompt", "consent");
+	return {
+		url: url.toString(),
+		verifier,
+		state
+	};
+}
+async function readCallbackInput(question) {
+	const rl = createInterface({
+		input: stdin,
+		output: stdout
+	});
+	try {
+		return (await rl.question(question)).trim();
+	} finally {
+		rl.close();
+	}
+}
+function parseCallbackInput(value) {
+	const raw = value.trim();
+	if (raw.length === 0) return {};
+	if (/^https?:\/\//i.test(raw)) try {
+		const u = new URL(raw);
+		return {
+			code: u.searchParams.get("code") ?? void 0,
+			state: u.searchParams.get("state") ?? void 0
+		};
+	} catch {
+		return {};
+	}
+	const maybeQuery = raw.startsWith("?") ? raw.slice(1) : raw;
+	if (maybeQuery.includes("=")) {
+		const params = new URLSearchParams(maybeQuery);
+		const code = params.get("code") ?? void 0;
+		const state = params.get("state") ?? void 0;
+		if (code !== void 0 || state !== void 0) return {
+			code,
+			state
+		};
+	}
+	return { code: raw };
+}
+function openUrlInBrowser(url) {
+	const platform = process.platform;
+	const command = platform === "darwin" ? "open" : platform === "win32" ? "rundll32" : "xdg-open";
+	const args = platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
+	try {
+		spawn(command, args, {
+			detached: true,
+			stdio: "ignore"
+		}).unref();
+	} catch {
+		log$3("failed to open browser automatically");
+	}
+}
+async function exchangeAuthorizationCode(code, verifier) {
+	const body = new URLSearchParams({
+		client_id: GEMINI_CLIENT_ID,
+		client_secret: GEMINI_CLIENT_SECRET,
+		code,
+		grant_type: "authorization_code",
+		redirect_uri: GEMINI_REDIRECT_URI,
+		code_verifier: verifier
+	});
+	const res = await globalThis.fetch(GOOGLE_TOKEN_URL, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: body.toString()
+	});
+	if (!res.ok) {
+		const bodyText = await res.text();
+		throw new Error(`Google token exchange failed: ${res.status} ${res.statusText} ${bodyText}`);
+	}
+	const raw = await res.json();
+	return {
+		access_token: String(raw.access_token ?? ""),
+		refresh_token: typeof raw.refresh_token === "string" ? raw.refresh_token : void 0,
+		expires_in: Number(raw.expires_in ?? 3600),
+		token_type: String(raw.token_type ?? "Bearer")
+	};
+}
+async function fetchGoogleEmail(accessToken) {
+	const res = await globalThis.fetch(GOOGLE_USERINFO_URL, { headers: { Authorization: `Bearer ${accessToken}` } });
+	if (!res.ok) return void 0;
+	const raw = await res.json();
+	return typeof raw.email === "string" ? raw.email : void 0;
+}
+function toRequestUrlString(value) {
+	if (typeof value === "string") return value;
+	if (value instanceof URL) return value.toString();
+	return value.url;
+}
+function parseGenerativeAction(input) {
+	const match = toRequestUrlString(input).match(/\/models\/([^:]+):(\w+)/);
+	if (!match) return void 0;
+	const model = match[1] ?? "";
+	const action = match[2] ?? "";
+	if (!model || !action) return void 0;
+	return {
+		model,
+		action,
+		streaming: action === "streamGenerateContent"
+	};
+}
+function buildCodeAssistUrl(action, streaming) {
+	return `${CODE_ASSIST_ENDPOINT}/v1internal:${action}${streaming ? "?alt=sse" : ""}`;
+}
+function rewriteRequestBody(body, projectId, model) {
+	if (typeof body !== "string" || body.length === 0) return body;
+	try {
+		const parsed = JSON.parse(body);
+		if (typeof parsed.project === "string" && parsed.request !== void 0) {
+			const wrapped = {
+				...parsed,
+				model
+			};
+			return JSON.stringify(wrapped);
+		}
+		const { model: _ignored, ...requestPayload } = parsed;
+		const wrapped = {
+			project: projectId,
+			model,
+			user_prompt_id: randomUUID(),
+			request: requestPayload
+		};
+		return JSON.stringify(wrapped);
+	} catch {
+		return body;
+	}
+}
+function rewriteStreamingLine(line) {
+	if (!line.startsWith("data:")) return line;
+	const payload = line.slice(5).trim();
+	if (!payload || payload === "[DONE]") return line;
+	try {
+		const response = JSON.parse(payload).response;
+		if (response !== void 0) return `data: ${JSON.stringify(response)}`;
+		return line;
+	} catch {
+		return line;
+	}
+}
+function rewriteStreamingBody(stream) {
+	const decoder = new TextDecoder();
+	const encoder = new TextEncoder();
+	let buffer = "";
+	return new ReadableStream({ async start(controller) {
+		const reader = stream.getReader();
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				buffer += decoder.decode(value, { stream: true });
+				let idx = buffer.indexOf("\n");
+				while (idx !== -1) {
+					const line = buffer.slice(0, idx);
+					buffer = buffer.slice(idx + 1);
+					controller.enqueue(encoder.encode(`${rewriteStreamingLine(line)}\n`));
+					idx = buffer.indexOf("\n");
+				}
+			}
+			buffer += decoder.decode();
+			if (buffer.length > 0) controller.enqueue(encoder.encode(rewriteStreamingLine(buffer)));
+			controller.close();
+		} catch (error) {
+			controller.error(error);
+		} finally {
+			reader.releaseLock();
+		}
+	} });
+}
+async function normalizeCodeAssistResponse(response, streaming) {
+	const contentType = response.headers.get("content-type") ?? "";
+	if (streaming && response.ok && contentType.includes("text/event-stream") && response.body) return new Response(rewriteStreamingBody(response.body), {
+		status: response.status,
+		statusText: response.statusText,
+		headers: new Headers(response.headers)
+	});
+	if (!contentType.includes("application/json")) return response;
+	const text = await response.text();
+	try {
+		const next = JSON.parse(text).response;
+		if (next !== void 0) return new Response(JSON.stringify(next), {
+			status: response.status,
+			statusText: response.statusText,
+			headers: new Headers(response.headers)
+		});
+		return new Response(text, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: new Headers(response.headers)
+		});
+	} catch {
+		return new Response(text, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: new Headers(response.headers)
+		});
+	}
+}
+const googlePlugin = {
+	provider: "google",
+	async loader(getAuth, _provider, setAuth) {
+		const initialAuth = await getAuth();
+		if (initialAuth.type !== "oauth") {
+			log$3("google loader: skipping (type=%s)", initialAuth.type);
+			return {};
+		}
+		log$3("google loader: activating OAuth fetch wrapper");
+		return {
+			apiKey: "google-oauth-placeholder",
+			async fetch(inputValue, init) {
+				const currentAuth = await getAuth();
+				if (currentAuth.type !== "oauth") return globalThis.fetch(inputValue, init);
+				let currentToken = currentAuth.key ?? "";
+				if (currentAuth.expires !== void 0 && currentAuth.expires < Date.now() && typeof currentAuth.refresh === "string") {
+					log$3("token expired, attempting refresh...");
+					try {
+						const tokens = await refreshGoogleToken(currentAuth.refresh);
+						currentToken = tokens.access_token;
+						await setAuth({
+							...currentAuth,
+							key: tokens.access_token,
+							refresh: tokens.refresh_token ?? currentAuth.refresh,
+							expires: Date.now() + tokens.expires_in * 1e3
+						}).catch((err) => log$3("failed to persist refreshed credential: %s", err instanceof Error ? err.message : String(err)));
+						log$3("token refreshed successfully, expires in %ds", tokens.expires_in);
+					} catch (err) {
+						log$3("token refresh failed: %s", err instanceof Error ? err.message : String(err));
+					}
+				}
+				const rewritten = parseGenerativeAction(inputValue);
+				if (!rewritten) {
+					const headers = new Headers(init?.headers);
+					headers.delete("x-goog-api-key");
+					headers.delete("x-api-key");
+					headers.set("Authorization", `Bearer ${currentToken}`);
+					return globalThis.fetch(inputValue, {
+						...init,
+						headers
+					});
+				}
+				const projectId = resolveProjectId();
+				if (!projectId) throw new Error("Google OAuth via Code Assist requires project id. Set OPENLLMPROVIDER_GOOGLE_PROJECT_ID (or GOOGLE_CLOUD_PROJECT).");
+				const headers = new Headers(init?.headers);
+				headers.delete("x-goog-api-key");
+				headers.delete("x-api-key");
+				headers.set("Authorization", `Bearer ${currentToken}`);
+				headers.set("User-Agent", CODE_ASSIST_HEADERS["User-Agent"]);
+				headers.set("X-Goog-Api-Client", CODE_ASSIST_HEADERS["X-Goog-Api-Client"]);
+				headers.set("Client-Metadata", CODE_ASSIST_HEADERS["Client-Metadata"]);
+				headers.set("x-activity-request-id", randomUUID());
+				if (rewritten.streaming) headers.set("Accept", "text/event-stream");
+				const requestUrl = buildCodeAssistUrl(rewritten.action, rewritten.streaming);
+				const body = rewriteRequestBody(init?.body, projectId, rewritten.model);
+				return normalizeCodeAssistResponse(await globalThis.fetch(requestUrl, {
+					...init,
+					headers,
+					body
+				}), rewritten.streaming);
+			}
+		};
+	},
+	methods: [{
+		type: "oauth",
+		label: "Google OAuth (Gemini)",
+		async handler() {
+			const authRequest = buildAuthorizationRequest();
+			console.log("Open this URL to continue Google OAuth:");
+			console.log(authRequest.url);
+			openUrlInBrowser(authRequest.url);
+			const parsed = parseCallbackInput(await readCallbackInput("Paste the callback URL or authorization code: "));
+			if (!parsed.code) throw new Error("Missing authorization code in callback input");
+			if (parsed.state !== void 0 && parsed.state !== authRequest.state) throw new Error("OAuth state mismatch");
+			const tokens = await exchangeAuthorizationCode(parsed.code, authRequest.verifier);
+			if (!tokens.refresh_token) throw new Error("Google OAuth did not return a refresh token; retry and grant consent");
+			const email = await fetchGoogleEmail(tokens.access_token);
+			return {
+				type: "oauth",
+				key: tokens.access_token,
+				refresh: tokens.refresh_token,
+				expires: Date.now() + tokens.expires_in * 1e3,
+				email
+			};
+		}
+	}]
+};
+
+//#endregion
+//#region src/provider/bundled.ts
+const log$2 = createLogger("provider:bundled");
+const PROVIDER_LOADERS = {
+	"@ai-sdk/anthropic": () => import("@ai-sdk/anthropic").then((m) => m.createAnthropic),
+	"@ai-sdk/openai": () => import("@ai-sdk/openai").then((m) => m.createOpenAI),
+	"@ai-sdk/google": () => import("@ai-sdk/google").then((m) => m.createGoogleGenerativeAI),
+	"@ai-sdk/google-vertex": () => import("@ai-sdk/google-vertex").then((m) => m.createVertex),
+	"@ai-sdk/amazon-bedrock": () => import("@ai-sdk/amazon-bedrock").then((m) => m.createAmazonBedrock),
+	"@ai-sdk/azure": () => import("@ai-sdk/azure").then((m) => m.createAzure),
+	"@ai-sdk/openai-compatible": () => import("@ai-sdk/openai-compatible").then((m) => m.createOpenAICompatible),
+	"@ai-sdk/xai": () => import("@ai-sdk/xai").then((m) => m.createXai),
+	"@ai-sdk/mistral": () => import("@ai-sdk/mistral").then((m) => m.createMistral),
+	"@ai-sdk/groq": () => import("@ai-sdk/groq").then((m) => m.createGroq),
+	"@openrouter/ai-sdk-provider": () => import("@openrouter/ai-sdk-provider").then((m) => m.createOpenRouter)
+};
+const loadedProviders = /* @__PURE__ */ new Map();
+const unavailableProviders = /* @__PURE__ */ new Set();
+async function loadProvider(packageName) {
+	if (loadedProviders.has(packageName)) return loadedProviders.get(packageName);
+	if (unavailableProviders.has(packageName)) return void 0;
+	const loader = PROVIDER_LOADERS[packageName];
+	if (loader === void 0) return void 0;
+	try {
+		const factory = await loader();
+		loadedProviders.set(packageName, factory);
+		log$2("loaded provider package: %s", packageName);
+		return factory;
+	} catch {
+		unavailableProviders.add(packageName);
+		log$2("provider package not available: %s (not installed)", packageName);
+		return;
+	}
+}
+async function isProviderInstalled(packageName) {
+	return await loadProvider(packageName) !== void 0;
+}
+function getAllProviderPackages() {
+	return Object.keys(PROVIDER_LOADERS);
+}
+
+//#endregion
+//#region src/provider/state.ts
+const log$1 = createLogger("provider:state");
+async function resolveSecretRef(ref) {
+	if (typeof ref === "string") return ref;
+	if (ref.type === "plain") return ref.value;
+	if (ref.type === "env") return process.env[ref.name];
+}
+const GOOGLE_PROVIDERS = new Set(["@ai-sdk/google", "@ai-sdk/google-vertex"]);
+function normalizeProviderBaseURL(providerId, baseURL) {
+	if (providerId !== "openai") return baseURL;
+	try {
+		const parsed = new URL(baseURL);
+		const path = parsed.pathname.replace(/\/+$/, "");
+		if (path === "" || path === "/") parsed.pathname = "/v1";
+		return parsed.toString().replace(/\/$/, "");
+	} catch {
+		return baseURL;
+	}
+}
+function resolveAuthBaseURL(authCred) {
+	if (authCred === void 0) return void 0;
+	if (typeof authCred.baseURL === "string" && authCred.baseURL.trim().length > 0) return authCred.baseURL.trim();
+	if (typeof authCred.apiHost === "string" && authCred.apiHost.trim().length > 0) return authCred.apiHost.trim();
+	if (typeof authCred.host === "string" && authCred.host.trim().length > 0) return authCred.host.trim();
+}
+async function buildProviderState(config) {
+	const { catalog, authStore, userConfig } = config;
+	log$1("building provider state");
+	const allProviders = catalog.listProviders();
+	const authCredentials = await authStore.all();
+	log$1("found %d catalog providers, %d auth entries", allProviders.length, Object.keys(authCredentials).length);
+	const result = {};
+	for (const catalogProvider of allProviders) {
+		const pid = catalogProvider.id;
+		const options = {};
+		let key;
+		let source = "none";
+		let location;
+		if (catalogProvider.baseURL !== void 0) options.baseURL = normalizeProviderBaseURL(pid, catalogProvider.baseURL);
+		if (catalogProvider.headers !== void 0) options.headers = { ...catalogProvider.headers };
+		if (catalogProvider.options !== void 0) Object.assign(options, catalogProvider.options);
+		if (catalogProvider.env !== void 0) for (const envVar of catalogProvider.env) {
+			const val = process.env[envVar];
+			if (val !== void 0) {
+				key = val;
+				source = "env";
+				location = `env:${envVar}`;
+				break;
+			}
+		}
+		const authCred = authCredentials[pid];
+		const authBaseURL = resolveAuthBaseURL(authCred);
+		if (authBaseURL !== void 0) options.baseURL = normalizeProviderBaseURL(pid, authBaseURL);
+		if (authCred?.key !== void 0) {
+			key = authCred.key;
+			source = "auth";
+			location = authCred.location;
+			const bp = catalogProvider.bundledProvider;
+			if (authCred.type === "oauth" && bp !== void 0) {
+				if (GOOGLE_PROVIDERS.has(bp)) {
+					const token = authCred.key;
+					options.fetch = (url, init) => {
+						const h = new Headers(init?.headers);
+						h.delete("x-goog-api-key");
+						h.set("Authorization", `Bearer ${token}`);
+						return globalThis.fetch(url, {
+							...init,
+							headers: h
+						});
+					};
+				}
+			}
+		}
+		const getAuth = async () => {
+			return await authStore.getPreferred?.(pid, "oauth") ?? authCred ?? { type: "api" };
+		};
+		const setAuth = async (credential) => {
+			await authStore.set(pid, credential);
+		};
+		const pluginOpts = await loadPluginOptions(pid, getAuth, {
+			id: pid,
+			name: catalogProvider.name
+		}, setAuth);
+		if (pluginOpts !== void 0) {
+			Object.assign(options, pluginOpts);
+			const pluginKey = pluginOpts.apiKey;
+			if (typeof pluginKey === "string") {
+				key = pluginKey;
+				source = "plugin";
+			}
+			const resolvedAuth = await getAuth();
+			if (resolvedAuth.location) location = resolvedAuth.location;
+		}
+		const userCfg = userConfig?.[pid];
+		if (userCfg !== void 0) {
+			if (userCfg.baseURL !== void 0) options.baseURL = normalizeProviderBaseURL(pid, userCfg.baseURL);
+			if (userCfg.headers !== void 0) {
+				const existingHeaders = options.headers;
+				options.headers = {
+					...existingHeaders !== null && typeof existingHeaders === "object" && !Array.isArray(existingHeaders) ? existingHeaders : {},
+					...userCfg.headers
+				};
+			}
+			if (userCfg.options !== void 0) Object.assign(options, userCfg.options);
+			if (userCfg.apiKey !== void 0) {
+				const resolved = await resolveSecretRef(userCfg.apiKey);
+				if (resolved !== void 0) {
+					key = resolved;
+					source = "config";
+					log$1("%s: resolved key from user config", pid);
+				}
+			}
+		}
+		if (source !== "none") log$1("%s: source=%s, location=%s", pid, source, location ?? "n/a");
+		result[pid] = {
+			id: pid,
+			key,
+			options,
+			source,
+			location
+		};
+	}
+	log$1("provider state built for %d providers", Object.keys(result).length);
+	return result;
+}
+
+//#endregion
+//#region src/provider/index.ts
+const log = createLogger("provider");
+const DEFAULT_PROVIDERS = {
+	anthropic: {
+		name: "Anthropic",
+		env: ["ANTHROPIC_API_KEY"],
+		bundledProvider: "@ai-sdk/anthropic"
+	},
+	openai: {
+		name: "OpenAI",
+		env: ["OPENAI_API_KEY"],
+		bundledProvider: "@ai-sdk/openai"
+	},
+	google: {
+		name: "Google AI",
+		env: ["GOOGLE_GENERATIVE_AI_API_KEY", "GOOGLE_API_KEY"],
+		bundledProvider: "@ai-sdk/google"
+	},
+	"google-vertex": {
+		name: "Google Vertex AI",
+		env: [],
+		bundledProvider: "@ai-sdk/google-vertex"
+	},
+	"amazon-bedrock": {
+		name: "Amazon Bedrock",
+		env: [],
+		bundledProvider: "@ai-sdk/amazon-bedrock"
+	},
+	azure: {
+		name: "Azure OpenAI",
+		env: ["AZURE_API_KEY"],
+		bundledProvider: "@ai-sdk/azure"
+	},
+	xai: {
+		name: "xAI",
+		env: ["XAI_API_KEY"],
+		bundledProvider: "@ai-sdk/xai"
+	},
+	mistral: {
+		name: "Mistral",
+		env: ["MISTRAL_API_KEY"],
+		bundledProvider: "@ai-sdk/mistral"
+	},
+	groq: {
+		name: "Groq",
+		env: ["GROQ_API_KEY"],
+		bundledProvider: "@ai-sdk/groq"
+	},
+	openrouter: {
+		name: "OpenRouter",
+		env: ["OPENROUTER_API_KEY"],
+		bundledProvider: "@openrouter/ai-sdk-provider"
+	},
+	"github-copilot": {
+		name: "GitHub Copilot",
+		env: [],
+		bundledProvider: "@ai-sdk/openai-compatible"
+	}
+};
+function resolveBundledProviderKey(providerId, catalogProvider) {
+	if (catalogProvider?.bundledProvider !== void 0) return catalogProvider.bundledProvider;
+	return DEFAULT_PROVIDERS[providerId]?.bundledProvider;
+}
+function createProviderStore(authStore, config) {
+	const catalog = new Catalog();
+	registerPlugin(copilotPlugin);
+	registerPlugin(codexPlugin);
+	registerPlugin(googlePlugin);
+	registerPlugin(anthropicPlugin);
+	catalog.extend({ providers: Object.fromEntries(Object.entries(DEFAULT_PROVIDERS).map(([id, p]) => [id, {
+		name: p.name,
+		env: p.env,
+		bundledProvider: p.bundledProvider
+	}])) });
+	const userConfig = config?.userConfig;
+	let stateCache = null;
+	let catalogRefreshTask = null;
+	function invalidateState() {
+		stateCache = null;
+	}
+	function getState() {
+		if (stateCache === null) {
+			log("initializing provider state");
+			stateCache = buildProviderState({
+				catalog,
+				authStore,
+				userConfig
+			});
+		}
+		return stateCache;
+	}
+	async function ensureCatalogEnriched() {
+		if (catalogRefreshTask === null) catalogRefreshTask = (async () => {
+			const result = await catalog.refresh();
+			if (!result.success) {
+				log("catalog refresh failed: %s", result.error?.message ?? "unknown error");
+				return;
+			}
+			log("catalog refreshed with %d providers", result.updatedProviders.length);
+			invalidateState();
+		})();
+		await catalogRefreshTask;
+	}
+	function hasProviderAuth(state, providerId) {
+		const providerState = state[providerId];
+		return providerState !== void 0 && providerState.source !== "none";
+	}
+	async function checkProviderUsable(providerId) {
+		const bundledKey = resolveBundledProviderKey(providerId, catalog.getProvider(providerId));
+		if (bundledKey === void 0) return false;
+		return isProviderInstalled(bundledKey);
+	}
+	return {
+		async getLanguageModel(providerId, modelId) {
+			await ensureCatalogEnriched();
+			const providerState = (await getState())[providerId];
+			log("getLanguageModel(%s, %s) — auth: source=%s, location=%s", providerId, modelId, providerState?.source ?? "none", providerState?.location ?? "unknown");
+			if (providerState === void 0) throw new Error(`Provider not found in catalog: ${providerId}`);
+			const bundledKey = resolveBundledProviderKey(providerId, catalog.getProvider(providerId));
+			if (bundledKey === void 0) throw new Error(`No bundled provider mapping found for: ${providerId}. Set bundledProvider in catalog extend() config.`);
+			const factory = await loadProvider(bundledKey);
+			if (factory === void 0) throw new Error(`Provider package not available: ${bundledKey}. Install it with: npm install ${bundledKey}`);
+			log("creating SDK for %s using %s", providerId, bundledKey);
+			const sdkOptions = { ...providerState.options };
+			if (providerState.key !== void 0) sdkOptions.apiKey = providerState.key;
+			if (sdkOptions.authToken !== void 0) sdkOptions.apiKey = void 0;
+			const sdk = factory(sdkOptions);
+			log("calling sdk.languageModel(%s)", modelId);
+			return sdk.languageModel(modelId);
+		},
+		extend(extendConfig) {
+			catalog.extend(extendConfig);
+			invalidateState();
+		},
+		async listProviders(options) {
+			await ensureCatalogEnriched();
+			const allProviders = catalog.listProviders();
+			const installedProviders = (await Promise.all(allProviders.map(async (p) => ({
+				provider: p,
+				usable: await checkProviderUsable(p.id)
+			})))).filter((r) => r.usable).map((r) => r.provider);
+			if (options?.includeUnavailable === true) return installedProviders;
+			const state = await getState();
+			return installedProviders.filter((provider) => hasProviderAuth(state, provider.id));
+		},
+		async listModels(providerId, options) {
+			await ensureCatalogEnriched();
+			if (options?.includeUnavailable === true) return catalog.listModels(providerId);
+			const state = await getState();
+			if (providerId !== void 0) {
+				if (!hasProviderAuth(state, providerId)) return [];
+				return catalog.listModels(providerId);
+			}
+			const allProviders = catalog.listProviders();
+			const usabilityChecks = await Promise.all(allProviders.map(async (p) => ({
+				provider: p,
+				usable: await checkProviderUsable(p.id) && hasProviderAuth(state, p.id)
+			})));
+			const results = [];
+			for (const { provider, usable } of usabilityChecks) if (usable) results.push(...catalog.listModels(provider.id));
+			return results;
+		},
+		async getModel(providerId, modelId, options) {
+			await ensureCatalogEnriched();
+			if (options?.includeUnavailable !== true) {
+				if (!hasProviderAuth(await getState(), providerId)) return;
+			}
+			return catalog.getModel(providerId, modelId);
+		}
+	};
+}
+function getLanguageModel(providerId, modelId, config) {
+	return createProviderStore(createAuthStore(), config).getLanguageModel(providerId, modelId);
+}
+
+//#endregion
+export { DEFAULT_SCANNERS, FileStorage, MemoryStorage, anthropicPlugin, codexPlugin, copilotPlugin, createAuthStore, createDefaultStorage, createLogger, createProviderStore, getAllProviderPackages, getLanguageModel, getPluginForProvider, getPlugins, googlePlugin, isProviderInstalled, loadProvider, registerPlugin };
+//# sourceMappingURL=index.mjs.map