@agimon-ai/model-proxy-mcp 0.2.3 → 0.2.4

package/dist/stdio-C23n_O3v.mjs

@@ -1,4041 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { randomUUID } from "node:crypto";
-import fs$1 from "node:fs/promises";
-import os from "node:os";
-import { parse, stringify } from "yaml";
-import { ZodError, z } from "zod";
-import { serve } from "@hono/node-server";
-import { Hono } from "hono";
-import { ulid } from "ulidx";
-import Database from "better-sqlite3";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-//#region src/constants/defaults.ts
-const DEFAULT_SETTINGS_DIR = path.join(os.homedir(), ".model-proxy");
-const DEFAULT_MODEL_PROVIDER_PATH = path.join(DEFAULT_SETTINGS_DIR, "model-provider.yaml");
-const DEFAULT_MODEL_LIST_PATH = path.join(DEFAULT_SETTINGS_DIR, "model-list.yaml");
-const DEFAULT_SCOPE_SETTINGS_DIR = path.join(DEFAULT_SETTINGS_DIR, "scopes");
-const DEFAULT_HISTORY_DB_PATH = path.join(DEFAULT_SETTINGS_DIR, "history.sqlite");
-const DEFAULT_AUTH_FILE_PATH = path.join(os.homedir(), ".codex", "auth.json");
-const DEFAULT_HTTP_PORT = 43191;
-const DEFAULT_SERVICE_NAME = "model-proxy-mcp-http";
-const DEFAULT_HISTORY_RETENTION_LIMIT = 1e3;
-const DEFAULT_PROVIDER_SETTINGS = {
-	"chatgpt-codex": {
-		type: "chatgpt-codex",
-		endpoint: "https://chatgpt.com/backend-api/codex/responses",
-		authTokenEnvVar: null,
-		apiTimeoutMs: null
-	},
-	"zai-anthropic-compat": {
-		type: "anthropic-compatible",
-		endpoint: "https://api.z.ai/api/anthropic/v1/messages",
-		authTokenEnvVar: "ZAI_ANTHROPIC_AUTH_TOKEN",
-		apiTimeoutMs: 3e6
-	},
-	"google-gemini-direct": {
-		type: "gemini-direct",
-		endpoint: "https://generativelanguage.googleapis.com",
-		authTokenEnvVar: "GEMINI_API_KEY",
-		apiTimeoutMs: 3e5,
-		authMode: "auto",
-		apiKeyEnvVar: "GEMINI_API_KEY",
-		project: null,
-		location: "global",
-		apiVersion: "v1beta"
-	}
-};
-const DEFAULT_MODEL_LIST = [
-	{
-		id: "chatgpt-codex-gpt-5.3-codex",
-		label: "ChatGPT Codex GPT-5.3 Codex",
-		provider: "chatgpt-codex",
-		model: "gpt-5.3-codex",
-		reasoningEffort: "medium",
-		enabled: true
-	},
-	{
-		id: "chatgpt-codex-gpt-5.3-codex-spark",
-		label: "ChatGPT Codex GPT-5.3 Codex Spark",
-		provider: "chatgpt-codex",
-		model: "gpt-5.3-codex-spark",
-		reasoningEffort: "low",
-		enabled: true
-	},
-	{
-		id: "chatgpt-codex-gpt-5.4",
-		label: "ChatGPT Codex GPT-5.4",
-		provider: "chatgpt-codex",
-		model: "gpt-5.4",
-		reasoningEffort: "medium",
-		enabled: true
-	},
-	{
-		id: "chatgpt-codex-gpt-5.2",
-		label: "ChatGPT Codex GPT-5.2",
-		provider: "chatgpt-codex",
-		model: "gpt-5.2",
-		reasoningEffort: "medium",
-		enabled: true
-	},
-	{
-		id: "zai-anthropic-compat-glm-4.7",
-		label: "Z.ai GLM-4.7",
-		provider: "zai-anthropic-compat",
-		model: "GLM-4.7",
-		reasoningEffort: "high",
-		enabled: true
-	},
-	{
-		id: "zai-anthropic-compat-glm-5",
-		label: "Z.ai GLM-5",
-		provider: "zai-anthropic-compat",
-		model: "glm-5",
-		reasoningEffort: "high",
-		enabled: true
-	},
-	{
-		id: "zai-anthropic-compat-glm-4.5-air",
-		label: "Z.ai GLM-4.5-Air",
-		provider: "zai-anthropic-compat",
-		model: "GLM-4.5-Air",
-		reasoningEffort: "medium",
-		enabled: true
-	},
-	{
-		id: "google-gemini-direct-gemini-2.5-flash",
-		label: "Google Gemini 2.5 Flash",
-		provider: "google-gemini-direct",
-		model: "gemini-2.5-flash",
-		reasoningEffort: "medium",
-		enabled: true
-	},
-	{
-		id: "google-gemini-direct-gemini-3-flash-preview",
-		label: "Google Gemini 3 Flash Preview",
-		provider: "google-gemini-direct",
-		model: "gemini-3-flash-preview",
-		reasoningEffort: "medium",
-		enabled: true
-	},
-	{
-		id: "google-gemini-direct-gemini-3.1-pro-preview",
-		label: "Google Gemini 3.1 Pro Preview",
-		provider: "google-gemini-direct",
-		model: "gemini-3.1-pro-preview",
-		reasoningEffort: "high",
-		enabled: true
-	}
-];
-const DEFAULT_SCOPE_SETTINGS = { models: {
-	default: {
-		main: {
-			provider: "chatgpt-codex",
-			model: "gpt-5.4",
-			reasoningEffort: "medium"
-		},
-		fallbacks: [{
-			provider: "chatgpt-codex",
-			model: "gpt-5.4",
-			reasoningEffort: "low"
-		}]
-	},
-	sonnet: {
-		main: {
-			provider: "chatgpt-codex",
-			model: "gpt-5.3-codex",
-			reasoningEffort: "medium"
-		},
-		fallbacks: [{
-			provider: "chatgpt-codex",
-			model: "gpt-5.4",
-			reasoningEffort: "medium"
-		}]
-	},
-	opus: {
-		main: {
-			provider: "chatgpt-codex",
-			model: "gpt-5.4",
-			reasoningEffort: "medium"
-		},
-		fallbacks: [{
-			provider: "chatgpt-codex",
-			model: "gpt-5.4",
-			reasoningEffort: "low"
-		}]
-	},
-	haiku: {
-		main: {
-			provider: "chatgpt-codex",
-			model: "gpt-5.3-codex-spark",
-			reasoningEffort: "low"
-		},
-		fallbacks: [{
-			provider: "chatgpt-codex",
-			model: "gpt-5.4",
-			reasoningEffort: "medium"
-		}]
-	},
-	subagent: {
-		main: {
-			provider: "chatgpt-codex",
-			model: "gpt-5.3-codex-spark",
-			reasoningEffort: "low"
-		},
-		fallbacks: [{
-			provider: "chatgpt-codex",
-			model: "gpt-5.4",
-			reasoningEffort: "medium"
-		}]
-	}
-} };
-
-//#endregion
-//#region src/services/logger.ts
-const consoleLogger = {
-	info: (msg, data) => console.error(msg, data ?? ""),
-	error: (msg, error) => console.error(msg, error ?? ""),
-	debug: () => void 0,
-	warn: (msg, data) => console.error(msg, data ?? "")
-};
-
-//#endregion
-//#region src/services/ProfileStore.ts
-const DEFAULT_SCOPE$2 = "default";
-const DEFAULT_ZAI_PROVIDER_ID = "zai-anthropic-compat";
-const LEGACY_ZAI_AUTH_ENV = "ANTHROPIC_AUTH_TOKEN";
-const DEFAULT_ZAI_AUTH_ENV = "ZAI_ANTHROPIC_AUTH_TOKEN";
-const SETTINGS_EXTENSION = ".yaml";
-const DEFAULT_REASONING_EFFORT = "medium";
-const MODEL_SLOTS$1 = [
-	"default",
-	"sonnet",
-	"opus",
-	"haiku",
-	"subagent"
-];
-const LOG_PREFIX = "[model-proxy-mcp]";
-const FILE_NOT_FOUND_ERROR_CODE = "ENOENT";
-const YAML_INDENT = 2;
-const FILE_ENCODING = "utf8";
-const PROVIDER_TYPES = [
-	"chatgpt-codex",
-	"anthropic-compatible",
-	"gemini-direct"
-];
-const PROFILE_STORE_ERROR_CODES = {
-	profileNotFound: "PROFILE_NOT_FOUND",
-	settingsReadFailed: "SETTINGS_READ_FAILED",
-	settingsWriteFailed: "SETTINGS_WRITE_FAILED"
-};
-const reasoningEffortSchema$1 = z.enum([
-	"minimal",
-	"low",
-	"medium",
-	"high"
-]);
-const providerRuntimeConfigSchema = z.object({
-	type: z.enum(PROVIDER_TYPES),
-	endpoint: z.url(),
-	authTokenEnvVar: z.string().min(1).nullable().optional(),
-	apiTimeoutMs: z.number().int().positive().nullable().optional(),
-	authMode: z.enum([
-		"auto",
-		"api-key",
-		"oauth"
-	]).nullable().optional(),
-	apiKeyEnvVar: z.string().min(1).nullable().optional(),
-	project: z.string().min(1).nullable().optional(),
-	location: z.string().min(1).nullable().optional(),
-	apiVersion: z.string().min(1).nullable().optional()
-});
-const providerRegistrySchema = z.object({ providers: z.record(z.string().min(1), providerRuntimeConfigSchema) });
-const modelConfigSchema = z.object({
-	id: z.string().min(1),
-	label: z.string().min(1),
-	provider: z.string().min(1),
-	model: z.string().min(1),
-	reasoningEffort: reasoningEffortSchema$1.default(DEFAULT_REASONING_EFFORT),
-	enabled: z.boolean().default(true)
-});
-const selectionSchema$1 = z.object({
-	provider: z.string().min(1),
-	model: z.string().min(1),
-	reasoningEffort: reasoningEffortSchema$1.default(DEFAULT_REASONING_EFFORT),
-	thinkingDisabled: z.boolean().optional()
-});
-const slotConfigSchema$1 = z.object({
-	main: selectionSchema$1,
-	fallbacks: z.array(selectionSchema$1).default([])
-});
-const scopeSettingsSchema = z.object({ models: z.object({
-	default: slotConfigSchema$1.optional(),
-	sonnet: slotConfigSchema$1.optional(),
-	opus: slotConfigSchema$1.optional(),
-	haiku: slotConfigSchema$1.optional(),
-	subagent: slotConfigSchema$1.optional()
-}).default({}) });
-const modelListSchema = z.array(modelConfigSchema);
-const adminConfigUpdateSchema$1 = z.object({ models: z.object({
-	default: slotConfigSchema$1.nullable().optional(),
-	sonnet: slotConfigSchema$1.nullable().optional(),
-	opus: slotConfigSchema$1.nullable().optional(),
-	haiku: slotConfigSchema$1.nullable().optional(),
-	subagent: slotConfigSchema$1.nullable().optional()
-}).optional() });
-var ProfileStoreError = class extends Error {
-	constructor(message, code, options) {
-		super(message, options);
-		this.code = code;
-		this.name = "ProfileStoreError";
-	}
-};
-var ProfileStore = class {
-	constructor(providerConfigPath = process.env.MODEL_PROXY_MCP_PROVIDER_PATH || DEFAULT_MODEL_PROVIDER_PATH, modelListPath = process.env.MODEL_PROXY_MCP_MODEL_LIST_PATH || path.join(path.dirname(process.env.MODEL_PROXY_MCP_PROVIDER_PATH || DEFAULT_MODEL_PROVIDER_PATH), path.basename(DEFAULT_MODEL_LIST_PATH)), scopeSettingsDir = process.env.MODEL_PROXY_MCP_SCOPE_DIR || path.join(path.dirname(process.env.MODEL_PROXY_MCP_PROVIDER_PATH || DEFAULT_MODEL_PROVIDER_PATH), path.basename(DEFAULT_SCOPE_SETTINGS_DIR)), logger = consoleLogger) {
-		this.providerConfigPath = providerConfigPath;
-		this.modelListPath = modelListPath;
-		this.scopeSettingsDir = scopeSettingsDir;
-		this.logger = logger;
-	}
-	getConfigPath(scope = DEFAULT_SCOPE$2) {
-		return this.getScopeConfigPath(scope);
-	}
-	async ensureConfig(scope = DEFAULT_SCOPE$2, seedConfigPath) {
-		return this.getConfig(scope, seedConfigPath);
-	}
-	async listScopes() {
-		try {
-			const entries = await fs$1.readdir(this.scopeSettingsDir, { withFileTypes: true });
-			const scopes = new Set([DEFAULT_SCOPE$2]);
-			for (const entry of entries) {
-				if (!entry.isFile() || !entry.name.endsWith(SETTINGS_EXTENSION)) continue;
-				const scopeName = entry.name.slice(0, -5);
-				if (scopeName) scopes.add(scopeName);
-			}
-			return Array.from(scopes).sort();
-		} catch (error) {
-			if (this.isFileNotFoundError(error)) return [DEFAULT_SCOPE$2];
-			this.logger.error(`${LOG_PREFIX} Failed to list scopes`, {
-				scopeSettingsDir: this.scopeSettingsDir,
-				cause: error
-			});
-			throw new ProfileStoreError(`Failed to list scopes in ${this.scopeSettingsDir}`, PROFILE_STORE_ERROR_CODES.settingsReadFailed, { cause: error });
-		}
-	}
-	async getConfig(scope = DEFAULT_SCOPE$2, seedConfigPath) {
-		return this.toProxyConfig(await this.getSettings(scope, seedConfigPath));
-	}
-	async getAdminConfig(scope = DEFAULT_SCOPE$2) {
-		const settings = await this.getSettings(scope);
-		const profiles = this.toProfiles(settings);
-		const slots = Object.fromEntries(MODEL_SLOTS$1.map((slot) => [slot, this.resolveSlotConfig(settings, profiles, slot)]));
-		return {
-			scope,
-			providerConfigPath: this.providerConfigPath,
-			modelListPath: this.modelListPath,
-			scopeConfigPath: this.getScopeConfigPath(scope),
-			providers: settings.providers,
-			models: profiles,
-			scopeModels: settings.scope.models,
-			slots
-		};
-	}
-	async listProfiles(scope = DEFAULT_SCOPE$2) {
-		return (await this.getAdminConfig(scope)).models;
-	}
-	async getActiveProfile(scope = DEFAULT_SCOPE$2, slot = DEFAULT_SCOPE$2) {
-		const config = await this.getAdminConfig(scope);
-		const resolvedSlot = config.slots[slot];
-		return config.models.find((profile) => profile.id === resolvedSlot.profileId && profile.enabled) ?? null;
-	}
-	async getResolvedSlotConfig(scope = DEFAULT_SCOPE$2, slot = DEFAULT_SCOPE$2) {
-		return (await this.getAdminConfig(scope)).slots[slot];
-	}
-	async setActiveProfile(profileId, scope = DEFAULT_SCOPE$2, slot = DEFAULT_SCOPE$2) {
-		const settings = await this.getSettings(scope);
-		const profile = this.toProfiles(settings).find((item) => item.id === profileId && item.enabled);
-		if (!profile) throw new ProfileStoreError(`Profile not found or disabled: ${profileId}`, PROFILE_STORE_ERROR_CODES.profileNotFound, { cause: {
-			profileId,
-			scope,
-			slot
-		} });
-		return this.updateConfig({ models: { [slot]: {
-			main: {
-				provider: profile.provider,
-				model: profile.model,
-				reasoningEffort: profile.reasoningEffort,
-				thinkingDisabled: settings.scope.models[slot]?.main.thinkingDisabled ?? false
-			},
-			fallbacks: settings.scope.models[slot]?.fallbacks ?? []
-		} } }, scope);
-	}
-	async upsertProfile(profile, scope = DEFAULT_SCOPE$2) {
-		const nextProfile = modelConfigSchema.parse({
-			id: profile.id,
-			label: profile.label,
-			provider: profile.provider,
-			model: profile.model,
-			reasoningEffort: profile.reasoningEffort,
-			enabled: profile.enabled
-		});
-		const settings = await this.getSettings(scope);
-		const models = settings.models.filter((item) => item.id !== nextProfile.id);
-		models.push(nextProfile);
-		const nextSettings = this.normalizeSettings({
-			providers: settings.providers,
-			models,
-			scope: settings.scope
-		});
-		await this.saveSettings(nextSettings, scope);
-		return this.toProxyConfig(nextSettings);
-	}
-	async updateConfig(update, scope = DEFAULT_SCOPE$2) {
-		const parsedUpdate = adminConfigUpdateSchema$1.parse(update);
-		const settings = await this.getSettings(scope);
-		const nextScopeModels = { ...settings.scope.models };
-		for (const slot of MODEL_SLOTS$1) {
-			const selection = parsedUpdate.models?.[slot];
-			if (selection === void 0) continue;
-			if (selection === null) {
-				delete nextScopeModels[slot];
-				continue;
-			}
-			nextScopeModels[slot] = selection;
-		}
-		const nextSettings = this.normalizeSettings({
-			providers: settings.providers,
-			models: settings.models,
-			scope: { models: nextScopeModels }
-		});
-		await this.saveSettings(nextSettings, scope);
-		return this.toProxyConfig(nextSettings);
-	}
-	getScopeConfigPath(scope) {
-		return path.join(this.scopeSettingsDir, `${this.sanitizeScope(scope)}${SETTINGS_EXTENSION}`);
-	}
-	sanitizeScope(scope) {
-		return scope.replace(/[^a-zA-Z0-9._-]/g, "-").replace(/--+/g, "-").replace(/^-|-$/g, "") || DEFAULT_SCOPE$2;
-	}
-	async getSettings(scope, seedConfigPath) {
-		const settings = await this.readSettings(scope, seedConfigPath);
-		const normalized = this.normalizeSettings(settings);
-		if (JSON.stringify(normalized) !== JSON.stringify(settings)) await this.saveSettings(normalized, scope);
-		return normalized;
-	}
-	async readSettings(scope, seedConfigPath) {
-		const scopeConfigPath = this.getScopeConfigPath(scope);
-		const [providerResult, modelListResult, scopeResult] = await Promise.allSettled([
-			fs$1.readFile(this.providerConfigPath, FILE_ENCODING),
-			fs$1.readFile(this.modelListPath, FILE_ENCODING),
-			fs$1.readFile(scopeConfigPath, FILE_ENCODING)
-		]);
-		try {
-			const providerRaw = providerResult.status === "fulfilled" ? providerResult.value : null;
-			const modelListRaw = modelListResult.status === "fulfilled" ? modelListResult.value : null;
-			const scopeRaw = scopeResult.status === "fulfilled" ? scopeResult.value : null;
-			const providerMissing = providerResult.status === "rejected" && this.isFileNotFoundError(providerResult.reason);
-			const modelListMissing = modelListResult.status === "rejected" && this.isFileNotFoundError(modelListResult.reason);
-			const scopeMissing = scopeResult.status === "rejected" && this.isFileNotFoundError(scopeResult.reason);
-			if (!providerRaw && providerResult.status === "rejected" && !providerMissing) throw providerResult.reason;
-			if (!modelListRaw && modelListResult.status === "rejected" && !modelListMissing) throw modelListResult.reason;
-			if (!scopeRaw && scopeResult.status === "rejected" && !scopeMissing) throw scopeResult.reason;
-			const scopeSettings = scopeRaw ? scopeSettingsSchema.parse(parse(scopeRaw)) : await this.loadScopeSeedSettings(scope, seedConfigPath);
-			const settings = this.normalizeSettings({
-				providers: providerRaw ? providerRegistrySchema.parse(parse(providerRaw)).providers : structuredClone(DEFAULT_PROVIDER_SETTINGS),
-				models: modelListRaw ? modelListSchema.parse(parse(modelListRaw)) : structuredClone(DEFAULT_MODEL_LIST),
-				scope: scopeSettings
-			});
-			if (providerMissing || modelListMissing || scopeMissing) await this.saveSettings(settings, scope);
-			return settings;
-		} catch (error) {
-			this.logger.error(`${LOG_PREFIX} Failed to read settings`, {
-				scope,
-				providerConfigPath: this.providerConfigPath,
-				modelListPath: this.modelListPath,
-				scopeConfigPath,
-				code: PROFILE_STORE_ERROR_CODES.settingsReadFailed,
-				cause: error
-			});
-			throw new ProfileStoreError(`Failed to read settings from ${this.providerConfigPath}, ${this.modelListPath}, and ${scopeConfigPath}`, PROFILE_STORE_ERROR_CODES.settingsReadFailed, { cause: error });
-		}
-	}
-	isFileNotFoundError(error) {
-		return error?.code === FILE_NOT_FOUND_ERROR_CODE;
-	}
-	async loadScopeSeedSettings(scope, seedConfigPath) {
-		const candidatePaths = [seedConfigPath, this.getDefaultScopeSeedPath(scope)].filter((candidate) => Boolean(candidate));
-		for (const candidatePath of candidatePaths) try {
-			const raw = await fs$1.readFile(candidatePath, FILE_ENCODING);
-			return scopeSettingsSchema.parse(parse(raw));
-		} catch (error) {
-			if (this.isFileNotFoundError(error)) continue;
-			this.logger.error(`${LOG_PREFIX} Failed to read scope seed settings`, {
-				scope,
-				seedConfigPath: candidatePath,
-				cause: error
-			});
-			throw error;
-		}
-		return structuredClone(DEFAULT_SCOPE_SETTINGS);
-	}
-	getDefaultScopeSeedPath(scope) {
-		const defaultScopePath = this.getScopeConfigPath(DEFAULT_SCOPE$2);
-		return scope === DEFAULT_SCOPE$2 ? null : defaultScopePath;
-	}
-	normalizeSettings(settings) {
-		const providers = this.normalizeProviders(Object.keys(settings.providers).length > 0 ? settings.providers : structuredClone(DEFAULT_PROVIDER_SETTINGS));
-		const models = settings.models.map((model) => modelConfigSchema.parse(model));
-		const defaultSelection = this.normalizeSlotSelection(settings.scope.models.default?.main ?? null, models, providers, this.getDefaultSelection(models, providers));
-		const normalizedScopeModels = { default: defaultSelection ? {
-			main: defaultSelection,
-			fallbacks: this.normalizeFallbacks(settings.scope.models.default?.fallbacks ?? [], defaultSelection, models, providers)
-		} : void 0 };
-		for (const slot of MODEL_SLOTS$1) {
-			if (slot === DEFAULT_SCOPE$2) continue;
-			const fallback = defaultSelection ?? this.getDefaultSelection(models, providers);
-			const selection = this.normalizeSlotSelection(settings.scope.models[slot]?.main ?? null, models, providers, fallback);
-			normalizedScopeModels[slot] = selection ? {
-				main: selection,
-				fallbacks: this.normalizeFallbacks(settings.scope.models[slot]?.fallbacks ?? [], selection, models, providers)
-			} : void 0;
-		}
-		return {
-			providers,
-			models,
-			scope: { models: normalizedScopeModels }
-		};
-	}
-	normalizeProviders(providers) {
-		const normalizedProviders = { ...providers };
-		const zaiProvider = normalizedProviders[DEFAULT_ZAI_PROVIDER_ID];
-		if (zaiProvider?.type === "anthropic-compatible" && zaiProvider.authTokenEnvVar === LEGACY_ZAI_AUTH_ENV) normalizedProviders[DEFAULT_ZAI_PROVIDER_ID] = {
-			...zaiProvider,
-			authTokenEnvVar: DEFAULT_ZAI_AUTH_ENV
-		};
-		return normalizedProviders;
-	}
-	getDefaultSelection(models, providers) {
-		const fallbackModel = models.find((model) => model.enabled && providers[model.provider]);
-		if (!fallbackModel) return null;
-		return {
-			provider: fallbackModel.provider,
-			model: fallbackModel.model,
-			reasoningEffort: fallbackModel.reasoningEffort,
-			thinkingDisabled: false
-		};
-	}
-	normalizeSlotSelection(selection, models, providers, fallback) {
-		if (!selection) return fallback ? { ...fallback } : null;
-		const provider = providers[selection.provider] ? selection.provider : fallback?.provider ?? null;
-		if (!provider) return null;
-		if (provider !== selection.provider) return fallback && providers[fallback.provider] ? { ...fallback } : null;
-		const catalogEntry = models.find((model) => model.enabled && model.provider === provider && model.model === selection.model);
-		return {
-			provider,
-			model: catalogEntry?.model ?? selection.model,
-			reasoningEffort: selection.reasoningEffort ?? catalogEntry?.reasoningEffort ?? DEFAULT_REASONING_EFFORT,
-			thinkingDisabled: selection.thinkingDisabled ?? false
-		};
-	}
-	normalizeFallbacks(fallbacks, main, models, providers) {
-		const normalized = [];
-		const seen = new Set([`${main.provider}:${main.model}:${main.reasoningEffort}:${main.thinkingDisabled ? "off" : "on"}`]);
-		for (const fallback of fallbacks) {
-			const nextFallback = this.normalizeSlotSelection(fallback, models, providers, null);
-			if (!nextFallback) continue;
-			const key = `${nextFallback.provider}:${nextFallback.model}:${nextFallback.reasoningEffort}:${nextFallback.thinkingDisabled ? "off" : "on"}`;
-			if (seen.has(key)) continue;
-			seen.add(key);
-			normalized.push(nextFallback);
-		}
-		return normalized;
-	}
-	toProxyConfig(settings) {
-		const profiles = this.toProfiles(settings);
-		const slotProfileIds = Object.fromEntries(MODEL_SLOTS$1.map((slot) => {
-			return [slot, this.resolveSlotConfig(settings, profiles, slot).profileId];
-		}));
-		return {
-			activeProfileId: slotProfileIds.default ?? null,
-			slotProfileIds,
-			providers: settings.providers,
-			profiles,
-			scope: settings.scope
-		};
-	}
-	resolveSlotConfig(settings, profiles, slot) {
-		const slotConfig = settings.scope.models[slot] ?? settings.scope.models.default;
-		const selection = slotConfig?.main ?? null;
-		const profile = selection ? profiles.find((item) => item.provider === selection.provider && item.model === selection.model && item.enabled) : void 0;
-		const provider = selection?.provider ? settings.providers[selection.provider] : void 0;
-		return {
-			slot,
-			profileId: profile?.id ?? null,
-			label: profile?.label ?? null,
-			provider: selection?.provider ?? null,
-			providerType: provider?.type ?? null,
-			endpoint: provider?.endpoint ?? null,
-			model: selection?.model ?? null,
-			reasoningEffort: selection?.reasoningEffort ?? profile?.reasoningEffort ?? DEFAULT_REASONING_EFFORT,
-			thinkingDisabled: selection?.thinkingDisabled ?? false,
-			fallbacks: slotConfig?.fallbacks ?? []
-		};
-	}
-	toProfiles(settings) {
-		return settings.models.map((model) => ({
-			id: model.id,
-			label: model.label,
-			provider: model.provider,
-			providerType: settings.providers[model.provider]?.type ?? null,
-			model: model.model,
-			endpoint: settings.providers[model.provider]?.endpoint ?? null,
-			reasoningEffort: model.reasoningEffort,
-			enabled: model.enabled
-		}));
-	}
-	async saveSettings(settings, scope = DEFAULT_SCOPE$2) {
-		const scopeConfigPath = this.getScopeConfigPath(scope);
-		try {
-			const directories = new Set([
-				path.dirname(this.providerConfigPath),
-				path.dirname(this.modelListPath),
-				path.dirname(scopeConfigPath)
-			]);
-			await Promise.all(Array.from(directories, (directory) => fs$1.mkdir(directory, { recursive: true })));
-			await Promise.all([
-				fs$1.writeFile(this.providerConfigPath, stringify(providerRegistrySchema.parse({ providers: settings.providers }), { indent: YAML_INDENT }), FILE_ENCODING),
-				fs$1.writeFile(this.modelListPath, stringify(modelListSchema.parse(settings.models), { indent: YAML_INDENT }), FILE_ENCODING),
-				fs$1.writeFile(scopeConfigPath, stringify(scopeSettingsSchema.parse(settings.scope), { indent: YAML_INDENT }), FILE_ENCODING)
-			]);
-		} catch (error) {
-			this.logger.error(`${LOG_PREFIX} Failed to write settings`, {
-				scope,
-				providerConfigPath: this.providerConfigPath,
-				modelListPath: this.modelListPath,
-				scopeConfigPath,
-				code: PROFILE_STORE_ERROR_CODES.settingsWriteFailed,
-				cause: error
-			});
-			throw new ProfileStoreError(`Failed to write settings to ${this.providerConfigPath}, ${this.modelListPath}, and ${scopeConfigPath}`, PROFILE_STORE_ERROR_CODES.settingsWriteFailed, { cause: error });
-		}
-	}
-};
-
-//#endregion
-//#region src/adapters/codex/ClaudeToOpenAITransformer.ts
-/**
-* Claude to OpenAI Request Transformer
-*
-* Converts Anthropic Claude Messages API requests to OpenAI Responses API format.
-* Handles message structure, system prompts, streaming, and other parameters.
-*/
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-var ClaudeToOpenAITransformer = class {
-	config;
-	codexAuth;
-	codexInstructions;
-	constructor(config, codexAuth) {
-		this.config = config;
-		this.codexAuth = codexAuth;
-		this.codexInstructions = this.loadCodexInstructions();
-	}
-	/**
-	* Load the complete Codex CLI system prompt from codex.md
-	*/
-	loadCodexInstructions() {
-		const codexMdPath = path.join(__dirname, "codex.md");
-		try {
-			return fs.readFileSync(codexMdPath, "utf-8");
-		} catch (error) {
-			console.warn(`Warning: Could not load codex.md from ${codexMdPath}`);
-			return "";
-		}
-	}
-	async transform(_url, requestBody) {
-		try {
-			const claudeRequest = JSON.parse(requestBody);
-			this.config.logger?.debug("[ClaudeToOpenAI] ===== ORIGINAL CLAUDE REQUEST =====");
-			this.config.logger?.debug("[ClaudeToOpenAI] Original body", { body: JSON.stringify(claudeRequest, null, 2) });
-			const conversationId = randomUUID();
-			const sessionId = conversationId;
-			const sessionReasoningEffort = this.config.sessionReasoningEffort;
-			const isHaikuModel = claudeRequest.model && claudeRequest.model.toLowerCase().includes("haiku");
-			const reasoningEffort = sessionReasoningEffort || (isHaikuModel ? "minimal" : "medium");
-			this.config.logger?.debug("[ClaudeToOpenAI] Model detection and reasoning effort", {
-				originalModel: claudeRequest.model,
-				isHaikuModel,
-				sessionReasoningEffort: sessionReasoningEffort || "none",
-				finalReasoningEffort: reasoningEffort,
-				source: sessionReasoningEffort ? "session override" : "model-based"
-			});
-			const responsesRequest = {
-				model: this.config.toModel || "gpt-5",
-				stream: true,
-				store: false,
-				tool_choice: "auto",
-				parallel_tool_calls: false,
-				prompt_cache_key: conversationId
-			};
-			if (!this.config.thinkingDisabled) {
-				responsesRequest.reasoning = {
-					effort: reasoningEffort,
-					summary: "auto"
-				};
-				responsesRequest.include = ["reasoning.encrypted_content"];
-			}
-			this.config.logger?.debug("[ClaudeToOpenAI] Thinking mode", { thinkingDisabled: this.config.thinkingDisabled ?? false });
-			responsesRequest.instructions = this.adaptInstructionsForChatGPT(this.codexInstructions);
-			const input = [];
-			let claudeSystemPrompt = "";
-			if (claudeRequest.system) {
-				const systemMessages = this.extractSystemMessages(claudeRequest.system);
-				if (systemMessages && Array.isArray(systemMessages) && systemMessages.length > 0) claudeSystemPrompt = systemMessages.map((msg) => msg.content).join("\n\n");
-			}
-			claudeSystemPrompt = this.removeClaudeCodeInstructions(claudeSystemPrompt);
-			if (claudeSystemPrompt) input.push({
-				type: "message",
-				role: "user",
-				content: [{
-					type: "input_text",
-					text: claudeSystemPrompt
-				}]
-			});
-			if (claudeRequest.messages && Array.isArray(claudeRequest.messages)) for (const msg of claudeRequest.messages) {
-				const converted = this.convertMessageToInput(msg);
-				if (Array.isArray(converted)) input.push(...converted);
-				else if (converted) input.push(converted);
-			}
-			responsesRequest.input = input;
-			if (claudeRequest.tools && Array.isArray(claudeRequest.tools)) {
-				this.config.logger?.debug("[ClaudeToOpenAI] Original Claude tools", { tools: JSON.stringify(claudeRequest.tools, null, 2) });
-				const convertedTools = this.convertTools(claudeRequest.tools);
-				this.config.logger?.debug("[ClaudeToOpenAI] Converted tools", { tools: JSON.stringify(convertedTools, null, 2) });
-				if (convertedTools.length > 0) {
-					responsesRequest.tools = convertedTools;
-					this.config.logger?.debug("[ClaudeToOpenAI] Added tools to responsesRequest", { toolCount: convertedTools.length });
-					this.config.logger?.debug("[ClaudeToOpenAI] Verify responsesRequest.tools exists", {
-						hasTools: !!responsesRequest.tools,
-						toolsLength: responsesRequest.tools?.length,
-						keys: Object.keys(responsesRequest)
-					});
-				} else this.config.logger?.warn("[ClaudeToOpenAI] No valid tools after conversion, omitting tools field");
-			} else this.config.logger?.debug("[ClaudeToOpenAI] No tools in Claude request", {
-				hasTools: !!claudeRequest.tools,
-				isArray: Array.isArray(claudeRequest.tools)
-			});
-			const targetUrl = this.config.toEndpoint || "https://chatgpt.com/backend-api/codex/responses";
-			const headers = {
-				version: "0.46.0",
-				"openai-beta": "responses=experimental",
-				conversation_id: conversationId,
-				session_id: sessionId,
-				accept: "text/event-stream",
-				"content-type": "application/json",
-				"user-agent": "codex_cli_rs/0.46.0 (Mac OS 15.6.0; arm64) iTerm.app/3.6.2",
-				originator: "codex_cli_rs"
-			};
-			if (this.codexAuth) {
-				const accessToken = await this.codexAuth.getAccessToken();
-				this.config.logger?.debug("[ClaudeToOpenAI] Raw access token", { token: accessToken?.substring(0, 30) + "..." });
-				if (accessToken) if (accessToken.startsWith("Bearer ")) {
-					headers.authorization = accessToken;
-					this.config.logger?.debug("[ClaudeToOpenAI] Token already has Bearer prefix, using as-is");
-				} else {
-					headers.authorization = `Bearer ${accessToken}`;
-					this.config.logger?.debug("[ClaudeToOpenAI] Added Bearer prefix to token");
-				}
-				const accountId = await this.codexAuth.getAccountId();
-				if (accountId) headers["chatgpt-account-id"] = accountId;
-			} else if (this.config.toApiKey) headers.authorization = `Bearer ${this.config.toApiKey}`;
-			this.config.logger?.debug("[ClaudeToOpenAI] ===== REQUEST DETAILS =====");
-			this.config.logger?.debug("[ClaudeToOpenAI] Target URL", { targetUrl });
-			this.config.logger?.debug("[ClaudeToOpenAI] Headers", { headers: {
-				...headers,
-				authorization: headers.authorization ? `${headers.authorization.substring(0, 30)}...` : void 0
-			} });
-			this.config.logger?.debug("[ClaudeToOpenAI] Body", { body: JSON.stringify(responsesRequest, null, 2) });
-			this.config.logger?.debug("[ClaudeToOpenAI] ===============================");
-			this.config.logger?.debug("[ClaudeToOpenAI] ===== FINAL TRANSFORMED REQUEST =====");
-			this.config.logger?.debug("[ClaudeToOpenAI] Pre-final check - responsesRequest.tools", {
-				hasTools: !!responsesRequest.tools,
-				toolsLength: responsesRequest.tools?.length,
-				keys: Object.keys(responsesRequest)
-			});
-			this.config.logger?.debug("[ClaudeToOpenAI] Final body", { body: JSON.stringify(responsesRequest, null, 2) });
-			this.config.logger?.debug("[ClaudeToOpenAI] ===== END FINAL TRANSFORMED REQUEST =====");
-			return {
-				url: targetUrl,
-				body: JSON.stringify(responsesRequest),
-				headers
-			};
-		} catch (error) {
-			throw new Error(`Failed to transform Claude request to OpenAI: ${error}`);
-		}
-	}
-	/**
-	* Adapt Codex instructions for ChatGPT by replacing Claude-specific model information
-	*/
-	adaptInstructionsForChatGPT(instructions) {
-		let adapted = instructions;
-		adapted = adapted.replace(/You are powered by the model named Sonnet 4\.5\. The exact model ID is claude-sonnet-4-5-\d+\./g, "You are powered by ChatGPT (GPT-5 reasoning model).");
-		adapted = adapted.replace(/Assistant knowledge cutoff is January 2025/g, "Assistant knowledge cutoff is October 2023");
-		adapted = adapted.replace(/\bClaude\b/g, "ChatGPT");
-		adapted = adapted.replace(/\bAnthropic\b/g, "OpenAI");
-		return adapted;
-	}
-	/**
-	* Remove Claude Code-specific instructions from system messages
-	* These should not be sent to ChatGPT as user messages
-	*/
-	removeClaudeCodeInstructions(text) {
-		const claudeCodePatterns = [/You are Claude Code, Anthropic's official CLI for Claude\.[\s\S]*?claude_code_docs_map\.md/, /You are Claude Code[\s\S]*?using Claude Code\n/];
-		let filtered = text;
-		for (const pattern of claudeCodePatterns) filtered = filtered.replace(pattern, "");
-		filtered = filtered.replace(/\n{3,}/g, "\n\n").trim();
-		return filtered;
-	}
-	/**
-	* Extract and convert system messages from Claude format
-	*/
-	extractSystemMessages(system) {
-		const messages = [];
-		if (typeof system === "string") messages.push({
-			role: "system",
-			content: system
-		});
-		else if (Array.isArray(system)) {
-			for (const item of system) if (typeof item === "string") messages.push({
-				role: "system",
-				content: item
-			});
-			else if (item.type === "text" && item.text) messages.push({
-				role: "system",
-				content: item.text
-			});
-		} else if (system.type === "text" && system.text) messages.push({
-			role: "system",
-			content: system.text
-		});
-		return messages;
-	}
-	/**
-	* Convert a single Claude message to Responses API input format
-	* Returns a single message or array of messages (for tool results)
-	*/
-	convertMessageToInput(msg) {
-		if (!msg.role || !msg.content) return null;
-		const textType = msg.role === "assistant" ? "output_text" : "input_text";
-		if (Array.isArray(msg.content)) {
-			const toolResults = [];
-			const toolCalls = [];
-			const textContent = [];
-			for (const block of msg.content) if (block.type === "tool_result") {
-				const resultText = typeof block.content === "string" ? block.content : JSON.stringify(block.content);
-				toolResults.push({
-					type: "function_call_output",
-					call_id: block.tool_use_id,
-					output: resultText
-				});
-			} else if (block.type === "text") textContent.push({
-				type: textType,
-				text: block.text || ""
-			});
-			else if (block.type === "image") if (block.source && block.source.type === "base64" && block.source.data) {
-				const mediaType = block.source.media_type || "image/jpeg";
-				const imageUrl = `data:${mediaType};base64,${block.source.data}`;
-				textContent.push({
-					type: "input_image",
-					image_url: imageUrl
-				});
-				this.config.logger?.debug("[ClaudeToOpenAI] Converted image block", {
-					mediaType,
-					dataLength: block.source.data.length
-				});
-			} else this.config.logger?.warn("[ClaudeToOpenAI] Unsupported image format", { source: block.source });
-			else if (block.type === "tool_use") toolCalls.push({
-				type: "function_call",
-				call_id: block.id,
-				name: block.name,
-				arguments: JSON.stringify(block.input || {})
-			});
-			const result = [];
-			if (textContent.length > 0) result.push({
-				type: "message",
-				role: msg.role,
-				content: textContent
-			});
-			if (toolCalls.length > 0) result.push(...toolCalls);
-			if (toolResults.length > 0) result.push(...toolResults);
-			if (result.length > 1) return result;
-			else if (result.length === 1) return result[0];
-			return null;
-		} else if (typeof msg.content === "string") return {
-			type: "message",
-			role: msg.role,
-			content: [{
-				type: textType,
-				text: msg.content
-			}]
-		};
-		return null;
-	}
-	/**
-	* Convert Claude tools to ChatGPT Responses API format
-	*
-	* The Responses API uses a flat structure with type at the top level:
-	* { type: "function", name: "...", description: "...", parameters: {...} }
-	*/
-	convertTools(tools) {
-		if (!tools || !Array.isArray(tools)) return [];
-		return tools.filter((tool) => {
-			if (!tool || typeof tool !== "object") return false;
-			if (!tool.name) return false;
-			return true;
-		}).map((tool) => {
-			return {
-				type: "function",
-				name: tool.name,
-				description: tool.description || "",
-				parameters: tool.input_schema || tool.parameters || {}
-			};
-		});
-	}
-};
-
-//#endregion
-//#region src/adapters/codex/CodexAuth.ts
-var CodexAuth = class CodexAuth {
-	static TOKEN_REFRESH_URL = "https://auth.openai.com/oauth/token";
-	static CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
-	constructor(logger = consoleLogger, authFilePath = path.join(process.env.HOME || "", ".codex", "auth.json")) {
-		this.logger = logger;
-		this.authFilePath = authFilePath;
-	}
-	getAuthFilePath() {
-		return this.authFilePath;
-	}
-	async getAuthStatus() {
-		const authData = this.readAuthFile();
-		return {
-			configured: Boolean(authData?.tokens?.refresh_token),
-			accountId: authData?.tokens?.account_id ?? null,
-			authFilePath: this.authFilePath,
-			lastRefresh: authData?.last_refresh ?? null
-		};
-	}
-	async getAccountId() {
-		return this.readAuthFile()?.tokens?.account_id ?? null;
-	}
-	async getAccessToken() {
-		const authData = this.readAuthFile();
-		if (!authData?.tokens) {
-			this.logger.warn("[CodexAuth] No tokens found in auth file");
-			return null;
-		}
-		let accessToken = authData.tokens.access_token;
-		if (accessToken.startsWith("Bearer ")) accessToken = accessToken.slice(7);
-		if (!this.isTokenExpired(accessToken)) return accessToken;
-		const refreshed = await this.refreshAccessToken(authData.tokens.refresh_token);
-		if (!refreshed) return null;
-		this.saveTokens(refreshed);
-		return refreshed.access_token;
-	}
-	readAuthFile() {
-		try {
-			if (!fs.existsSync(this.authFilePath)) return null;
-			return JSON.parse(fs.readFileSync(this.authFilePath, "utf8"));
-		} catch (error) {
-			this.logger.error("[CodexAuth] Failed to read auth file", error);
-			return null;
-		}
-	}
-	isTokenExpired(token) {
-		const payload = this.decodeJWT(token);
-		if (!payload?.exp) return true;
-		return payload.exp * 1e3 - Date.now() < 300 * 1e3;
-	}
-	decodeJWT(token) {
-		try {
-			const [, payload] = token.split(".");
-			if (!payload) return null;
-			return JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
-		} catch (error) {
-			this.logger.error("[CodexAuth] Failed to decode JWT", error);
-			return null;
-		}
-	}
-	async refreshAccessToken(refreshToken) {
-		try {
-			const response = await fetch(CodexAuth.TOKEN_REFRESH_URL, {
-				method: "POST",
-				headers: { "content-type": "application/x-www-form-urlencoded" },
-				body: new URLSearchParams({
-					grant_type: "refresh_token",
-					refresh_token: refreshToken,
-					client_id: CodexAuth.CLIENT_ID
-				})
-			});
-			if (!response.ok) {
-				this.logger.error("[CodexAuth] Token refresh failed", await response.text());
-				return null;
-			}
-			const data = await response.json();
-			return {
-				id_token: data.id_token ?? "",
-				access_token: (data.access_token ?? "").replace(/^Bearer\s+/i, ""),
-				refresh_token: data.refresh_token || refreshToken,
-				account_id: data.account_id ?? ""
-			};
-		} catch (error) {
-			this.logger.error("[CodexAuth] Failed to refresh token", error);
-			return null;
-		}
-	}
-	saveTokens(tokens) {
-		try {
-			const authData = this.readAuthFile();
-			if (!authData) return;
-			authData.tokens = tokens;
-			authData.last_refresh = (/* @__PURE__ */ new Date()).toISOString();
-			fs.writeFileSync(this.authFilePath, JSON.stringify(authData, null, 2), "utf8");
-		} catch (error) {
-			this.logger.error("[CodexAuth] Failed to save tokens", error);
-		}
-	}
-};
-
-//#endregion
-//#region src/adapters/codex/OpenAIToClaudeTransformer.ts
-/**
-* OpenAI to Claude Response Transformer
-*
-* Converts OpenAI Chat Completions API streaming responses (SSE format)
-* to Anthropic Claude Messages API streaming format.
-*
-* OpenAI SSE events: data: {"choices":[{"delta":{"content":"text"}}]}
-* Claude SSE events: event: content_block_delta\ndata: {"delta":{"type":"text","text":"text"}}
-*/
-var OpenAIToClaudeTransformer = class {
-	logger;
-	thinkingDisabled;
-	constructor(logger, thinkingDisabled = false) {
-		this.logger = logger;
-		this.thinkingDisabled = thinkingDisabled;
-	}
-	transform(responseBody) {
-		try {
-			if (!responseBody || responseBody.trim() === "") return this.createEmptyClaudeResponse();
-			if (!responseBody.includes("data:")) return this.convertNonStreamingResponse(responseBody);
-			return this.convertStreamingResponse(responseBody);
-		} catch (error) {
-			this.logger?.error("[OpenAIToClaude] ERROR in transform", error);
-			return this.createEmptyClaudeResponse();
-		}
-	}
-	/**
-	* Create a valid empty Claude streaming response to prevent parsing errors
-	*/
-	createEmptyClaudeResponse() {
-		const messageId = `msg_${ulid()}`;
-		const events = [];
-		events.push("event: message_start");
-		events.push(`data: ${JSON.stringify({
-			type: "message_start",
-			message: {
-				id: messageId,
-				type: "message",
-				role: "assistant",
-				content: [],
-				model: "gpt-5",
-				stop_reason: null,
-				stop_sequence: null,
-				usage: {
-					input_tokens: 0,
-					output_tokens: 0
-				}
-			}
-		})}`);
-		events.push("");
-		events.push("event: message_stop");
-		events.push("data: {\"type\":\"message_stop\"}");
-		events.push("");
-		return events.join("\n");
-	}
-	convertStreamingResponse(sseText) {
-		const parsed = this.parseOpenAIStream(sseText);
-		const claudeStream = this.createClaudeStreamFromParsed(parsed);
-		const fallbackMessage = parsed.errorMessage || "Empty streaming response from provider";
-		return this.ensureValidClaudeStream(claudeStream, fallbackMessage);
-	}
-	parseOpenAIStream(sseText) {
-		const parsed = {
-			textSegments: [],
-			thinkingSegments: [],
-			toolCalls: /* @__PURE__ */ new Map(),
-			model: "gpt-5",
-			inputTokens: 0,
-			outputTokens: 0,
-			cachedTokens: 0,
-			reasoningTokens: 0,
-			reasoningEffort: void 0,
-			stopReason: void 0,
-			errorMessage: void 0
-		};
-		const lines = sseText.split("\n");
-		let currentEvent = "";
-		const isResponsesApi = /event:\s*response\./i.test(sseText) || /"type"\s*:\s*"response\./i.test(sseText) || /"response"\s*:\s*\{/i.test(sseText);
-		for (const rawLine of lines) {
-			const line = rawLine.trim();
-			if (!line) continue;
-			if (line.startsWith("event:")) {
-				currentEvent = line.slice(6).trim();
-				continue;
-			}
-			if (!line.startsWith("data:")) continue;
-			const dataContent = line.slice(5).trim();
-			if (!dataContent || dataContent === "[DONE]") continue;
-			let data;
-			try {
-				data = JSON.parse(dataContent);
-			} catch {
-				continue;
-			}
-			if (data?.error) {
-				parsed.errorMessage = data.error?.message || data.error?.error || (typeof data.error === "string" ? data.error : "Unexpected API error");
-				break;
-			}
-			if (isResponsesApi || currentEvent.startsWith("response.")) this.handleResponsesEvent(currentEvent, data, parsed);
-			else this.handleChatCompletionChunk(data, parsed);
-		}
-		return parsed;
-	}
-	handleResponsesEvent(eventName, data, parsed) {
-		const eventType = typeof data?.type === "string" ? data.type : eventName;
-		if (data?.model && typeof data.model === "string") parsed.model = data.model;
-		if (data?.usage) {
-			parsed.inputTokens = data.usage.input_tokens ?? data.usage.prompt_tokens ?? parsed.inputTokens;
-			parsed.outputTokens = data.usage.output_tokens ?? data.usage.completion_tokens ?? parsed.outputTokens;
-		}
-		switch (eventType) {
-			case "response.created":
-				if (data?.response?.model) parsed.model = data.response.model;
-				break;
-			case "response.reasoning.delta":
-			case "response.reasoning_summary_text.delta":
-			case "response.function_call_arguments.delta":
-			case "response.function_call_arguments.done":
-			case "response.in_progress":
-			case "response.output_item.added":
-			case "response.output_item.done":
-			case "response.content_part.added":
-			case "response.content_part.done":
-			case "response.reasoning_summary_part.added":
-			case "response.reasoning_summary_part.done":
-			case "response.reasoning_summary_text.done": break;
-			case "response.output_text.delta":
-			case "response.delta":
-				if (data?.delta?.tool_calls) {}
-				break;
-			case "response.output_text.done": break;
-			case "response.completed":
-				if (data?.response?.model) parsed.model = data.response.model;
-				if (data?.response?.usage) {
-					parsed.inputTokens = data.response.usage.input_tokens ?? data.response.usage.prompt_tokens ?? parsed.inputTokens;
-					parsed.outputTokens = data.response.usage.output_tokens ?? data.response.usage.completion_tokens ?? parsed.outputTokens;
-					if (data.response.usage.input_tokens_details?.cached_tokens) parsed.cachedTokens = data.response.usage.input_tokens_details.cached_tokens;
-					if (data.response.usage.output_tokens_details?.reasoning_tokens) parsed.reasoningTokens = data.response.usage.output_tokens_details.reasoning_tokens;
-				}
-				if (data?.response?.reasoning?.effort) parsed.reasoningEffort = data.response.reasoning.effort;
-				if (Array.isArray(data?.response?.tool_calls)) this.collectToolCalls(data.response.tool_calls, parsed.toolCalls);
-				if (Array.isArray(data?.response?.output)) {
-					for (const output of data.response.output) if (output?.type === "reasoning") {
-						if (Array.isArray(output?.summary)) {
-							for (const summaryItem of output.summary) if (summaryItem?.type === "summary_text" && summaryItem?.text) parsed.thinkingSegments.push(summaryItem.text);
-						}
-					} else if (output?.type === "message") {
-						if (Array.isArray(output?.content)) {
-							for (const contentItem of output.content) if ((contentItem?.type === "output_text" || contentItem?.type === "text") && contentItem?.text) parsed.textSegments.push(contentItem.text);
-						}
-					} else if (output?.type === "function_call") {
-						const toolCallData = {
-							index: parsed.toolCalls.size,
-							id: output.id || `tool_${ulid()}`,
-							function: {
-								name: output.name,
-								arguments: output.arguments
-							}
-						};
-						this.collectToolCalls([toolCallData], parsed.toolCalls);
-					}
-				}
-				if (data?.response?.output_text) this.collectTextFromNode(data.response.output_text, parsed.textSegments);
-				parsed.stopReason = this.mapResponseStatusToStopReason(data?.response?.status);
-				break;
-			case "response.error":
-				parsed.errorMessage = data?.error?.message || data?.message || "Unexpected API error";
-				break;
-			default:
-				if (data?.delta) {
-					this.collectTextFromNode(data.delta, parsed.textSegments);
-					if (data.delta.tool_calls) this.collectToolCalls(data.delta.tool_calls, parsed.toolCalls);
-				}
-				break;
-		}
-	}
-	handleChatCompletionChunk(chunk, parsed) {
-		if (!chunk) return;
-		if (chunk.model && typeof chunk.model === "string") parsed.model = chunk.model;
-		if (chunk.usage) {
-			parsed.inputTokens = chunk.usage.prompt_tokens ?? parsed.inputTokens;
-			parsed.outputTokens = chunk.usage.completion_tokens ?? parsed.outputTokens;
-		}
-		if (!Array.isArray(chunk.choices)) return;
-		for (const choice of chunk.choices) {
-			if (choice?.delta) {
-				this.collectTextFromNode(choice.delta, parsed.textSegments);
-				if (choice.delta.tool_calls) this.collectToolCalls(choice.delta.tool_calls, parsed.toolCalls);
-			}
-			if (choice?.message?.content) this.collectTextFromNode(choice.message.content, parsed.textSegments);
-			if (choice?.finish_reason) parsed.stopReason = this.mapFinishReason(choice.finish_reason);
-		}
-	}
-	collectTextFromNode(node, collector) {
-		if (node == null) return;
-		if (typeof node === "string") {
-			if (node.length > 0) collector.push(node);
-			return;
-		}
-		if (Array.isArray(node)) {
-			for (const item of node) this.collectTextFromNode(item, collector);
-			return;
-		}
-		if (typeof node !== "object") return;
-		if (typeof node.text === "string") collector.push(node.text);
-		if (typeof node.output_text === "string") collector.push(node.output_text);
-		if (typeof node.value === "string") collector.push(node.value);
-		if (typeof node.delta === "string") collector.push(node.delta);
-		else if (node.delta) this.collectTextFromNode(node.delta, collector);
-		if (node.token && typeof node.token.text === "string") collector.push(node.token.text);
-		for (const key of [
-			"content",
-			"output",
-			"output_text",
-			"message",
-			"choices",
-			"segments"
-		]) if (node[key] !== void 0) if (key === "choices" && Array.isArray(node[key])) for (const choice of node[key]) {
-			if (choice?.message?.content) this.collectTextFromNode(choice.message.content, collector);
-			if (choice?.delta) this.collectTextFromNode(choice.delta, collector);
-		}
-		else this.collectTextFromNode(node[key], collector);
-	}
-	collectToolCalls(rawToolCalls, toolCallMap) {
-		if (!rawToolCalls) return;
-		const callsArray = Array.isArray(rawToolCalls) ? rawToolCalls : [rawToolCalls];
-		for (const call of callsArray) {
-			if (!call) continue;
-			const index = typeof call.index === "number" ? call.index : toolCallMap.size;
-			const existing = toolCallMap.get(index) || {
-				id: "",
-				name: "",
-				argumentChunks: []
-			};
-			if (typeof call.id === "string" && !existing.id) existing.id = call.id;
-			const functionName = call.function?.name;
-			if (typeof functionName === "string" && functionName.length > 0) existing.name = functionName;
-			const functionArgs = call.function?.arguments;
-			if (typeof functionArgs === "string" && functionArgs.length > 0) existing.argumentChunks.push(functionArgs);
-			toolCallMap.set(index, existing);
-		}
-	}
-	createClaudeStreamFromParsed(parsed) {
-		if (parsed.errorMessage) return this.createClaudeErrorStream(parsed.errorMessage);
-		const thinkingSegments = this.thinkingDisabled ? [] : this.mergeAndChunkSegments(parsed.thinkingSegments);
-		const textSegments = this.mergeAndChunkSegments(parsed.textSegments);
-		const toolCalls = Array.from(parsed.toolCalls.entries()).sort((a, b) => a[0] - b[0]).map(([index, value]) => ({
-			index,
-			id: value.id,
-			name: value.name,
-			arguments: value.argumentChunks.join("")
-		})).filter((call) => call.name);
-		if (thinkingSegments.length === 0 && textSegments.length === 0 && toolCalls.length === 0) return this.createClaudeErrorStream("Empty streaming response from provider");
-		const messageId = `msg_${ulid()}`;
-		const model = parsed.model || "gpt-5";
-		const events = [];
-		events.push("event: message_start");
-		events.push(`data: ${JSON.stringify({
-			type: "message_start",
-			message: {
-				id: messageId,
-				type: "message",
-				role: "assistant",
-				content: [],
-				model,
-				stop_reason: null,
-				stop_sequence: null,
-				usage: {
-					input_tokens: parsed.inputTokens ?? 0,
-					output_tokens: 0
-				}
-			}
-		})}`);
-		events.push("");
-		let blockIndex = 0;
-		if (thinkingSegments.length > 0) {
-			events.push("event: content_block_start");
-			events.push(`data: ${JSON.stringify({
-				type: "content_block_start",
-				index: blockIndex,
-				content_block: {
-					type: "thinking",
-					thinking: ""
-				}
-			})}`);
-			events.push("");
-			for (const chunk of thinkingSegments) {
-				if (!chunk) continue;
-				events.push("event: content_block_delta");
-				events.push(`data: ${JSON.stringify({
-					type: "content_block_delta",
-					index: blockIndex,
-					delta: {
-						type: "thinking_delta",
-						thinking: chunk
-					}
-				})}`);
-				events.push("");
-			}
-			events.push("event: content_block_stop");
-			events.push(`data: ${JSON.stringify({
-				type: "content_block_stop",
-				index: blockIndex
-			})}`);
-			events.push("");
-			blockIndex += 1;
-		}
-		if (textSegments.length > 0) {
-			events.push("event: content_block_start");
-			events.push(`data: ${JSON.stringify({
-				type: "content_block_start",
-				index: blockIndex,
-				content_block: {
-					type: "text",
-					text: ""
-				}
-			})}`);
-			events.push("");
-			for (const chunk of textSegments) {
-				if (!chunk) continue;
-				events.push("event: content_block_delta");
-				events.push(`data: ${JSON.stringify({
-					type: "content_block_delta",
-					index: blockIndex,
-					delta: {
-						type: "text_delta",
-						text: chunk
-					}
-				})}`);
-				events.push("");
-			}
-			events.push("event: content_block_stop");
-			events.push(`data: ${JSON.stringify({
-				type: "content_block_stop",
-				index: blockIndex
-			})}`);
-			events.push("");
-			blockIndex += 1;
-		}
-		for (const toolCall of toolCalls) {
-			const toolIndex = blockIndex + toolCall.index;
-			const toolId = toolCall.id || `tool_${ulid()}`;
-			events.push("event: content_block_start");
-			events.push(`data: ${JSON.stringify({
-				type: "content_block_start",
-				index: toolIndex,
-				content_block: {
-					type: "tool_use",
-					id: toolId,
-					name: toolCall.name,
-					input: {}
-				}
-			})}`);
-			events.push("");
-			if (toolCall.arguments) {
-				events.push("event: content_block_delta");
-				events.push(`data: ${JSON.stringify({
-					type: "content_block_delta",
-					index: toolIndex,
-					delta: {
-						type: "input_json_delta",
-						partial_json: toolCall.arguments
-					}
-				})}`);
-				events.push("");
-			}
-			events.push("event: content_block_stop");
-			events.push(`data: ${JSON.stringify({
-				type: "content_block_stop",
-				index: toolIndex
-			})}`);
-			events.push("");
-		}
-		const stopReason = parsed.stopReason || "end_turn";
-		const usageDetails = { output_tokens: parsed.outputTokens ?? 0 };
-		if (parsed.cachedTokens || parsed.reasoningTokens || parsed.reasoningEffort) {
-			usageDetails.metadata = {};
-			if (parsed.cachedTokens) usageDetails.metadata.cached_tokens = parsed.cachedTokens;
-			if (parsed.reasoningTokens) usageDetails.metadata.reasoning_tokens = parsed.reasoningTokens;
-			if (parsed.reasoningEffort) usageDetails.metadata.reasoning_effort = parsed.reasoningEffort;
-		}
-		events.push("event: message_delta");
-		events.push(`data: ${JSON.stringify({
-			type: "message_delta",
-			delta: {
-				stop_reason: stopReason,
-				stop_sequence: null
-			},
-			usage: usageDetails
-		})}`);
-		events.push("");
-		events.push("event: message_stop");
-		events.push("data: {\"type\":\"message_stop\"}");
-		events.push("");
-		return events.join("\n");
-	}
-	mergeAndChunkSegments(segments, chunkSize = 2e3) {
-		if (!segments || segments.length === 0) return [];
-		const combined = segments.join("");
-		if (!combined) return [];
-		const result = [];
-		for (let i = 0; i < combined.length; i += chunkSize) result.push(combined.slice(i, i + chunkSize));
-		return result;
-	}
-	mapResponseStatusToStopReason(status) {
-		if (!status) return "end_turn";
-		return {
-			completed: "end_turn",
-			completed_with_error: "error",
-			completed_with_streaming_error: "error",
-			cancelled: "error",
-			errored: "error"
-		}[status] || "end_turn";
-	}
-	/**
-	* Convert non-streaming OpenAI response to Claude format
-	*/
-	convertNonStreamingResponse(responseBody) {
-		try {
-			const openAIResponse = JSON.parse(responseBody);
-			if (openAIResponse?.error) {
-				const errorMessage = openAIResponse.error?.message || openAIResponse.error?.error || (typeof openAIResponse.error === "string" ? openAIResponse.error : "Unexpected API error");
-				return this.createClaudeErrorResponse(errorMessage);
-			}
-			const choice = openAIResponse.choices?.[0];
-			if (!choice) return responseBody;
-			const claudeResponse = {
-				id: `msg_${ulid()}`,
-				type: "message",
-				role: "assistant",
-				content: [{
-					type: "text",
-					text: choice.message?.content || ""
-				}],
-				model: openAIResponse.model || "gpt-4-turbo",
-				stop_reason: this.mapFinishReason(choice.finish_reason),
-				stop_sequence: null,
-				usage: {
-					input_tokens: openAIResponse.usage?.prompt_tokens || 0,
-					output_tokens: openAIResponse.usage?.completion_tokens || 0
-				}
-			};
-			return JSON.stringify(claudeResponse);
-		} catch (error) {
-			this.logger?.error("Failed to transform OpenAI response to Claude format", error);
-			const fallbackMessage = typeof responseBody === "string" && responseBody.trim() ? responseBody.trim() : "Unexpected API error";
-			return this.createClaudeErrorResponse(fallbackMessage);
-		}
-	}
-	/**
-	* Map OpenAI finish_reason to Claude stop_reason
-	*/
-	mapFinishReason(finishReason) {
-		if (!finishReason) return null;
-		return {
-			stop: "end_turn",
-			length: "max_tokens",
-			function_call: "tool_use",
-			tool_calls: "tool_use",
-			content_filter: "stop_sequence"
-		}[finishReason] || "end_turn";
-	}
-	createClaudeErrorResponse(message) {
-		const messageId = `msg_${ulid()}`;
-		const text = message || "Unexpected API error";
-		return JSON.stringify({
-			id: messageId,
-			type: "message",
-			role: "assistant",
-			content: [{
-				type: "text",
-				text
-			}],
-			model: "gpt-5",
-			stop_reason: "error",
-			stop_sequence: null,
-			usage: {
-				input_tokens: 0,
-				output_tokens: 0
-			}
-		});
-	}
-	createClaudeErrorStream(message) {
-		const messageId = `msg_${ulid()}`;
-		const text = message || "Unexpected API error";
-		const events = [];
-		events.push("event: message_start");
-		events.push(`data: ${JSON.stringify({
-			type: "message_start",
-			message: {
-				id: messageId,
-				type: "message",
-				role: "assistant",
-				content: [],
-				model: "gpt-5",
-				stop_reason: null,
-				stop_sequence: null,
-				usage: {
-					input_tokens: 0,
-					output_tokens: 0
-				}
-			}
-		})}`);
-		events.push("");
-		events.push("event: content_block_start");
-		events.push(`data: ${JSON.stringify({
-			type: "content_block_start",
-			index: 0,
-			content_block: {
-				type: "text",
-				text: ""
-			}
-		})}`);
-		events.push("");
-		events.push("event: content_block_delta");
-		events.push(`data: ${JSON.stringify({
-			type: "content_block_delta",
-			index: 0,
-			delta: {
-				type: "text_delta",
-				text
-			}
-		})}`);
-		events.push("");
-		events.push("event: content_block_stop");
-		events.push(`data: ${JSON.stringify({
-			type: "content_block_stop",
-			index: 0
-		})}`);
-		events.push("");
-		events.push("event: message_delta");
-		events.push(`data: ${JSON.stringify({
-			type: "message_delta",
-			delta: {
-				stop_reason: "error",
-				stop_sequence: null
-			},
-			usage: { output_tokens: 0 }
-		})}`);
-		events.push("");
-		events.push("event: message_stop");
-		events.push("data: {\"type\":\"message_stop\"}");
-		events.push("");
-		return events.join("\n");
-	}
-	ensureValidClaudeStream(stream, errorMessage) {
-		if (!stream || !stream.includes("event: message_start")) return this.createClaudeErrorStream(errorMessage);
-		return stream;
-	}
-};
-
-//#endregion
-//#region src/adapters/gemini/types.ts
-const GEMINI_API_KEY_ENV_FALLBACK = "GEMINI_API_KEY";
-const GEMINI_CLI_HOME_ENV = "GEMINI_CLI_HOME";
-const GEMINI_DEFAULT_API_VERSION = "v1beta";
-const GEMINI_DEFAULT_AUTH_MODE = "auto";
-const GEMINI_PERSONAL_OAUTH_AUTH_TYPE = "oauth-personal";
-const GEMINI_CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
-const GEMINI_CODE_ASSIST_API_VERSION = "v1internal";
-const GEMINI_SETTINGS_FILE = "settings.json";
-const GEMINI_OAUTH_FILE = "oauth_creds.json";
-const GEMINI_STREAM_QUERY_PARAM = "alt=sse";
-const GEMINI_USER_ROLE = "user";
-const GEMINI_MODEL_ROLE = "model";
-const GEMINI_MODEL_PREFIX = "models/";
-
-//#endregion
-//#region src/adapters/gemini/ClaudeToGeminiTransformer.ts
-const DEFAULT_MAX_OUTPUT_TOKENS = 4096;
-const MINIMAL_REASONING_MAX_OUTPUT_TOKENS = 2048;
-const TOOL_MODE_AUTO = "AUTO";
-const TOOL_MODE_NONE = "NONE";
-const GEMINI_SUPPORTED_SCHEMA_KEYS = new Set([
-	"type",
-	"format",
-	"description",
-	"nullable",
-	"enum",
-	"items",
-	"maxItems",
-	"minItems",
-	"properties",
-	"required",
-	"propertyOrdering",
-	"maxProperties",
-	"minProperties",
-	"minimum",
-	"maximum",
-	"minLength",
-	"maxLength",
-	"pattern",
-	"example",
-	"anyOf",
-	"title"
-]);
-var ClaudeToGeminiTransformer = class {
-	transform(request, resolvedModel, reasoningEffort, thinkingDisabled = false) {
-		const contents = this.toGeminiContents(request.messages);
-		const systemInstruction = this.toSystemInstruction(request.system);
-		const tools = this.toGeminiTools(request.tools);
-		return {
-			modelPath: this.toGeminiModelPath(resolvedModel),
-			body: {
-				contents,
-				system_instruction: systemInstruction,
-				tools,
-				tool_config: { function_calling_config: { mode: tools.length > 0 ? TOOL_MODE_AUTO : TOOL_MODE_NONE } },
-				generationConfig: { maxOutputTokens: this.resolveMaxOutputTokens(request.max_tokens, reasoningEffort, thinkingDisabled) }
-			}
-		};
-	}
-	toGeminiModelPath(model) {
-		return model.startsWith(GEMINI_MODEL_PREFIX) ? model : `${GEMINI_MODEL_PREFIX}${model}`;
-	}
-	toSystemInstruction(system) {
-		const texts = this.extractTextParts(system);
-		if (texts.length === 0) return;
-		return { parts: texts.map((text) => ({ text })) };
-	}
-	toGeminiContents(messages) {
-		const contents = [];
-		for (const message of messages) {
-			const parts = this.toGeminiParts(message.content);
-			if (parts.length === 0) continue;
-			contents.push({
-				role: message.role === "assistant" ? GEMINI_MODEL_ROLE : GEMINI_USER_ROLE,
-				parts
-			});
-		}
-		return contents;
-	}
-	toGeminiParts(content) {
-		if (typeof content === "string") return content.trim() ? [{ text: content }] : [];
-		if (!Array.isArray(content)) return [];
-		const parts = [];
-		for (const block of content) {
-			if (block.type === "text" && block.text) parts.push({ text: block.text });
-			if (block.type === "tool_use") parts.push({ functionCall: {
-				name: block.name,
-				args: block.input
-			} });
-			if (block.type === "tool_result") parts.push({ functionResponse: {
-				name: block.tool_use_id,
-				response: { content: typeof block.content === "string" ? block.content : JSON.stringify(block.content ?? {}) }
-			} });
-		}
-		return parts;
-	}
-	toGeminiTools(tools) {
-		if (!tools || tools.length === 0) return [];
-		return [{ function_declarations: tools.map((tool) => ({
-			name: tool.name,
-			description: tool.description,
-			parameters: this.toGeminiParameters(tool.input_schema)
-		})) }];
-	}
-	toGeminiParameters(schema) {
-		if (!schema) return;
-		return this.sanitizeGeminiSchema(schema);
-	}
-	sanitizeGeminiSchema(value) {
-		if (Array.isArray(value)) return value.map((item) => this.sanitizeGeminiSchema(item));
-		if (!value || typeof value !== "object") return value;
-		const sanitizedEntries = Object.entries(value).flatMap(([key, nestedValue]) => {
-			if (!GEMINI_SUPPORTED_SCHEMA_KEYS.has(key)) return [];
-			if (key === "properties" && nestedValue && typeof nestedValue === "object" && !Array.isArray(nestedValue)) {
-				const propertyEntries = Object.entries(nestedValue).map(([propertyName, propertySchema]) => [propertyName, this.sanitizeGeminiSchema(propertySchema)]);
-				return [[key, Object.fromEntries(propertyEntries)]];
-			}
-			return [[key, this.sanitizeGeminiSchema(nestedValue)]];
-		});
-		return Object.fromEntries(sanitizedEntries);
-	}
-	extractTextParts(value) {
-		if (typeof value === "string") return value.trim() ? [value] : [];
-		if (!Array.isArray(value)) return [];
-		return value.map((item) => {
-			if (typeof item === "string") return item;
-			if (item && typeof item === "object" && "text" in item && typeof item.text === "string") return item.text;
-			return null;
-		}).filter((item) => Boolean(item?.trim()));
-	}
-	resolveMaxOutputTokens(maxTokens, reasoningEffort, thinkingDisabled) {
-		if (typeof maxTokens === "number" && maxTokens > 0) return maxTokens;
-		if (thinkingDisabled) return MINIMAL_REASONING_MAX_OUTPUT_TOKENS;
-		return reasoningEffort === "minimal" ? MINIMAL_REASONING_MAX_OUTPUT_TOKENS : DEFAULT_MAX_OUTPUT_TOKENS;
-	}
-};
-
-//#endregion
-//#region src/adapters/gemini/GeminiAuth.ts
-const GEMINI_CONFIG_DIRECTORY = ".gemini";
-const AUTHORIZATION_HEADER$1 = "Authorization";
-const API_KEY_HEADER = "x-goog-api-key";
-const BEARER_PREFIX = "Bearer ";
-const GEMINI_AUTH_CONFIG_ERROR = "GEMINI_AUTH_CONFIG_ERROR";
-const OAUTH_REFRESH_ENDPOINT = "https://oauth2.googleapis.com/token";
-const OAUTH_REFRESH_GRANT_TYPE = "refresh_token";
-const OAUTH_CLIENT_ID = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com";
-const OAUTH_CLIENT_SECRET = "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";
-const OAUTH_EXPIRY_SKEW_MS = 6e4;
-var GeminiAuthError = class extends Error {
-	constructor(message, code) {
-		super(message);
-		this.code = code;
-		this.name = "GeminiAuthError";
-	}
-};
-var GeminiAuth = class {
-	constructor(logger = consoleLogger, env = process.env) {
-		this.logger = logger;
-		this.env = env;
-	}
-	async resolveHeaders(provider) {
-		const authMode = provider.authMode ?? GEMINI_DEFAULT_AUTH_MODE;
-		if (authMode === "api-key") return this.resolveApiKeyHeaders(provider);
-		if (authMode === "oauth") return this.resolveOAuthHeaders();
-		return await this.tryResolveApiKeyHeaders(provider) ?? this.resolveOAuthHeaders();
-	}
-	getGeminiDirectory() {
-		const homeDirectory = this.env[GEMINI_CLI_HOME_ENV] || os.homedir();
-		return path.join(homeDirectory, GEMINI_CONFIG_DIRECTORY);
-	}
-	getSettingsPath() {
-		return path.join(this.getGeminiDirectory(), GEMINI_SETTINGS_FILE);
-	}
-	getOAuthPath() {
-		return path.join(this.getGeminiDirectory(), GEMINI_OAUTH_FILE);
-	}
-	async tryResolveApiKeyHeaders(provider) {
-		try {
-			return await this.resolveApiKeyHeaders(provider);
-		} catch {
-			return null;
-		}
-	}
-	async resolveApiKeyHeaders(provider) {
-		const apiKeyEnvVar = provider.apiKeyEnvVar ?? provider.authTokenEnvVar ?? GEMINI_API_KEY_ENV_FALLBACK;
-		const apiKey = this.env[apiKeyEnvVar]?.trim();
-		if (!apiKey) throw new GeminiAuthError(`Missing Gemini API key. Set ${apiKeyEnvVar}.`, GEMINI_AUTH_CONFIG_ERROR);
-		return {
-			headers: { [API_KEY_HEADER]: apiKey },
-			authMode: "api-key",
-			authSource: "env"
-		};
-	}
-	async resolveOAuthHeaders() {
-		const settings = await this.readSettings();
-		const credentials = await this.readOAuthCredentials();
-		const resolvedCredentials = await this.refreshOAuthCredentialsIfNeeded(credentials);
-		const selectedType = settings?.security?.auth?.selectedType ?? null;
-		const resolvedAccessToken = resolvedCredentials.access_token?.trim();
-		if (!resolvedAccessToken) throw new GeminiAuthError(`Missing Gemini OAuth credentials. Expected ${this.getOAuthPath()} or ${GEMINI_API_KEY_ENV_FALLBACK}.`, GEMINI_AUTH_CONFIG_ERROR);
-		return {
-			headers: { [AUTHORIZATION_HEADER$1]: `${BEARER_PREFIX}${resolvedAccessToken}` },
-			authMode: "oauth",
-			authSource: "gemini-home",
-			authType: selectedType
-		};
-	}
-	async readOAuthCredentials() {
-		try {
-			const raw = await fs$1.readFile(this.getOAuthPath(), "utf8");
-			return JSON.parse(raw);
-		} catch (error) {
-			this.logger.warn("[GeminiAuth] Failed to read oauth credentials", {
-				oauthPath: this.getOAuthPath(),
-				cause: error
-			});
-			throw new GeminiAuthError(`Unable to read Gemini OAuth credentials from ${this.getOAuthPath()}.`, GEMINI_AUTH_CONFIG_ERROR);
-		}
-	}
-	async readSettings() {
-		try {
-			const raw = await fs$1.readFile(this.getSettingsPath(), "utf8");
-			return JSON.parse(raw);
-		} catch (error) {
-			if (error?.code === "ENOENT") return null;
-			this.logger.warn("[GeminiAuth] Failed to read settings", {
-				settingsPath: this.getSettingsPath(),
-				cause: error
-			});
-			return null;
-		}
-	}
-	async refreshOAuthCredentialsIfNeeded(credentials) {
-		if (!this.shouldRefreshCredentials(credentials)) return credentials;
-		const refreshToken = credentials.refresh_token?.trim();
-		if (!refreshToken) return credentials;
-		const body = new URLSearchParams({
-			client_id: OAUTH_CLIENT_ID,
-			client_secret: OAUTH_CLIENT_SECRET,
-			grant_type: OAUTH_REFRESH_GRANT_TYPE,
-			refresh_token: refreshToken
-		});
-		const response = await fetch(OAUTH_REFRESH_ENDPOINT, {
-			method: "POST",
-			headers: { "content-type": "application/x-www-form-urlencoded" },
-			body
-		});
-		if (!response.ok) {
-			this.logger.warn("[GeminiAuth] Failed to refresh oauth credentials", {
-				status: response.status,
-				oauthPath: this.getOAuthPath()
-			});
-			return credentials;
-		}
-		const payload = await response.json();
-		const nextCredentials = {
-			...credentials,
-			access_token: payload.access_token ?? credentials.access_token,
-			token_type: payload.token_type ?? credentials.token_type,
-			scope: payload.scope ?? credentials.scope,
-			expiry_date: typeof payload.expires_in === "number" ? Date.now() + payload.expires_in * 1e3 : credentials.expiry_date
-		};
-		await fs$1.writeFile(this.getOAuthPath(), `${JSON.stringify(nextCredentials, null, 2)}\n`, "utf8");
-		return nextCredentials;
-	}
-	shouldRefreshCredentials(credentials) {
-		const accessToken = credentials.access_token?.trim();
-		const expiryDate = credentials.expiry_date;
-		if (!accessToken) return true;
-		if (typeof expiryDate !== "number") return false;
-		return expiryDate <= Date.now() + OAUTH_EXPIRY_SKEW_MS;
-	}
-};
-
-//#endregion
-//#region src/adapters/gemini/GeminiToClaudeTransformer.ts
-const SSE_EVENT_PREFIX = "event: ";
-const SSE_DATA_PREFIX = "data: ";
-const MESSAGE_START_EVENT = "message_start";
-const CONTENT_BLOCK_START_EVENT = "content_block_start";
-const CONTENT_BLOCK_DELTA_EVENT = "content_block_delta";
-const CONTENT_BLOCK_STOP_EVENT = "content_block_stop";
-const MESSAGE_DELTA_EVENT = "message_delta";
-const MESSAGE_STOP_EVENT = "message_stop";
-const CONTENT_BLOCK_TYPE = "text";
-const TEXT_DELTA_TYPE = "text_delta";
-const STOP_REASON_END_TURN = "end_turn";
-const STOP_REASON_TOOL_USE = "tool_use";
-const DONE_SENTINEL = "[DONE]";
-var GeminiToClaudeTransformer = class {
-	transformBuffered(responseBody, model) {
-		const parsed = JSON.parse(responseBody);
-		return this.toClaudeStream([parsed], model);
-	}
-	transformStreaming(responseBody, model) {
-		const payloads = [];
-		for (const chunk of responseBody.split("\n\n")) {
-			const dataLine = chunk.split("\n").find((line) => line.startsWith(SSE_DATA_PREFIX))?.slice(6).trim();
-			if (!dataLine || dataLine === DONE_SENTINEL) continue;
-			payloads.push(JSON.parse(dataLine));
-		}
-		return this.toClaudeStream(payloads, model);
-	}
-	toClaudeStream(payloads, model) {
-		const text = payloads.flatMap((payload) => payload.candidates ?? []).flatMap((candidate) => candidate.content?.parts ?? []).map((part) => "text" in part && typeof part.text === "string" ? part.text : "").join("");
-		const finishReason = payloads.map((payload) => payload.candidates?.[0]?.finishReason).find((value) => typeof value === "string");
-		const usage = payloads.find((payload) => payload.usageMetadata)?.usageMetadata;
-		const messageId = `msg_${ulid()}`;
-		const events = [];
-		events.push(`${SSE_EVENT_PREFIX}${MESSAGE_START_EVENT}`);
-		events.push(`${SSE_DATA_PREFIX}${JSON.stringify({
-			type: MESSAGE_START_EVENT,
-			message: {
-				id: messageId,
-				type: "message",
-				role: "assistant",
-				content: [],
-				model,
-				stop_reason: null,
-				stop_sequence: null,
-				usage: {
-					input_tokens: usage?.promptTokenCount ?? 0,
-					output_tokens: 0
-				}
-			}
-		})}`);
-		events.push("");
-		events.push(`${SSE_EVENT_PREFIX}${CONTENT_BLOCK_START_EVENT}`);
-		events.push(`${SSE_DATA_PREFIX}${JSON.stringify({
-			type: CONTENT_BLOCK_START_EVENT,
-			index: 0,
-			content_block: {
-				type: CONTENT_BLOCK_TYPE,
-				text: ""
-			}
-		})}`);
-		events.push("");
-		if (text) {
-			events.push(`${SSE_EVENT_PREFIX}${CONTENT_BLOCK_DELTA_EVENT}`);
-			events.push(`${SSE_DATA_PREFIX}${JSON.stringify({
-				type: CONTENT_BLOCK_DELTA_EVENT,
-				index: 0,
-				delta: {
-					type: TEXT_DELTA_TYPE,
-					text
-				}
-			})}`);
-			events.push("");
-		}
-		events.push(`${SSE_EVENT_PREFIX}${CONTENT_BLOCK_STOP_EVENT}`);
-		events.push(`${SSE_DATA_PREFIX}${JSON.stringify({
-			type: CONTENT_BLOCK_STOP_EVENT,
-			index: 0
-		})}`);
-		events.push("");
-		events.push(`${SSE_EVENT_PREFIX}${MESSAGE_DELTA_EVENT}`);
-		events.push(`${SSE_DATA_PREFIX}${JSON.stringify({
-			type: MESSAGE_DELTA_EVENT,
-			delta: {
-				stop_reason: this.mapStopReason(finishReason),
-				stop_sequence: null
-			},
-			usage: { output_tokens: usage?.candidatesTokenCount ?? 0 }
-		})}`);
-		events.push("");
-		events.push(`${SSE_EVENT_PREFIX}${MESSAGE_STOP_EVENT}`);
-		events.push(`${SSE_DATA_PREFIX}${JSON.stringify({ type: MESSAGE_STOP_EVENT })}`);
-		events.push("");
-		return events.join("\n");
-	}
-	mapStopReason(finishReason) {
-		if (!finishReason) return STOP_REASON_END_TURN;
-		return finishReason === "STOP" ? STOP_REASON_END_TURN : STOP_REASON_TOOL_USE;
-	}
-};
-
-//#endregion
-//#region src/services/ConversationHistoryService.ts
-const DEFAULT_HISTORY_PAGE_SIZE$1 = 50;
-const MIN_HISTORY_PAGE_SIZE = 1;
-const MAX_HISTORY_PAGE_SIZE = 200;
-const HISTORY_TABLE = "conversation_history";
-const HISTORY_SCOPE_SEQUENCE_INDEX = "conversation_history_scope_sequence_idx";
-const HISTORY_SCOPE_REQUEST_INDEX = "conversation_history_scope_request_idx";
-const HISTORY_ERROR_CODES = {
-	appendFailed: "HISTORY_APPEND_FAILED",
-	listFailed: "HISTORY_LIST_FAILED",
-	clearFailed: "HISTORY_CLEAR_FAILED",
-	statsFailed: "HISTORY_STATS_FAILED",
-	initFailed: "HISTORY_INIT_FAILED"
-};
-const historyCursorSchema = z.string().transform((value) => Number(value)).refine((value) => Number.isInteger(value) && value > 0, "Cursor must be a positive integer");
-/**
-* Error raised for conversation history persistence failures.
-*/
-var ConversationHistoryServiceError = class extends Error {
-	constructor(message, code, options) {
-		super(message, options);
-		this.code = code;
-		this.name = "ConversationHistoryServiceError";
-	}
-};
-/**
-* Persists scoped conversation history using SQLite and enforces bounded retention.
-*
-* Environment variables:
-* - `MODEL_PROXY_MCP_DB_PATH`
-*/
-var ConversationHistoryService = class {
-	sqlite = null;
-	/**
-	* Creates a SQLite-backed history store.
-	*
-	* `dbPath` defaults to `MODEL_PROXY_MCP_DB_PATH` or `~/.model-proxy/history.sqlite`.
-	* `retentionLimit` is enforced per scope after each insert batch.
-	* `logger` receives structured operational failures.
-	*/
-	constructor(dbPath = process.env.MODEL_PROXY_MCP_DB_PATH || DEFAULT_HISTORY_DB_PATH, retentionLimit = DEFAULT_HISTORY_RETENTION_LIMIT, logger = consoleLogger) {
-		this.dbPath = dbPath;
-		this.retentionLimit = retentionLimit;
-		this.logger = logger;
-	}
-	/**
-	* Eagerly initializes the SQLite database and schema.
-	*/
-	async ensureInitialized() {
-		await this.getDb();
-	}
-	/**
-	* Inserts normalized history entries and prunes overflow per scope.
-	*/
-	async appendEntries(entries) {
-		if (entries.length === 0) return;
-		try {
-			const db = await this.getDb();
-			const insert = db.prepare(`
-        INSERT INTO conversation_history (
-          id, scope, request_id, direction, role, message_type, model, slot, payload_json, created_at
-        ) VALUES (
-          @id, @scope, @request_id, @direction, @role, @message_type, @model, @slot, @payload_json, @created_at
-        )
-      `);
-			const transaction = db.transaction((scopeEntries) => {
-				for (const entry of scopeEntries) insert.run({
-					id: entry.id ?? ulid(),
-					scope: entry.scope,
-					request_id: entry.requestId,
-					direction: entry.direction,
-					role: entry.role,
-					message_type: entry.messageType,
-					model: entry.model,
-					slot: entry.slot,
-					payload_json: entry.payloadJson,
-					created_at: entry.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
-				});
-			});
-			const entriesByScope = /* @__PURE__ */ new Map();
-			for (const entry of entries) {
-				const bucket = entriesByScope.get(entry.scope) ?? [];
-				bucket.push(entry);
-				entriesByScope.set(entry.scope, bucket);
-			}
-			for (const scopeEntries of entriesByScope.values()) transaction(scopeEntries);
-			for (const scope of entriesByScope.keys()) await this.pruneScope(scope);
-		} catch (error) {
-			this.logger.error("[model-proxy-mcp] Failed to append history", {
-				code: HISTORY_ERROR_CODES.appendFailed,
-				dbPath: this.dbPath,
-				cause: error
-			});
-			throw new ConversationHistoryServiceError("Failed to append conversation history", HISTORY_ERROR_CODES.appendFailed, { cause: error });
-		}
-	}
-	/**
-	* Lists conversation history for a scope ordered from newest to oldest.
-	*/
-	async listHistory(scope, limit = DEFAULT_HISTORY_PAGE_SIZE$1, cursor) {
-		try {
-			const db = await this.getDb();
-			const parsedCursor = cursor ? historyCursorSchema.parse(cursor) : void 0;
-			const boundedLimit = Math.max(MIN_HISTORY_PAGE_SIZE, Math.min(limit, MAX_HISTORY_PAGE_SIZE));
-			const rows = parsedCursor ? db.prepare(`
-                SELECT sequence, id, scope, request_id, direction, role, message_type, model, slot, payload_json, created_at
-                FROM ${HISTORY_TABLE}
-                WHERE scope = ? AND sequence < ?
-                ORDER BY sequence DESC
-                LIMIT ?
-              `).all(scope, parsedCursor, boundedLimit + 1) : db.prepare(`
-                SELECT sequence, id, scope, request_id, direction, role, message_type, model, slot, payload_json, created_at
-                FROM ${HISTORY_TABLE}
-                WHERE scope = ?
-                ORDER BY sequence DESC
-                LIMIT ?
-              `).all(scope, boundedLimit + 1);
-			const total = Number(db.prepare(`SELECT COUNT(*) as count FROM ${HISTORY_TABLE} WHERE scope = ?`).get(scope).count);
-			const nextRow = rows.length > boundedLimit ? rows.pop() : void 0;
-			return {
-				items: rows.map((row) => this.toEntry(row)),
-				nextCursor: nextRow ? String(nextRow.sequence) : null,
-				total
-			};
-		} catch (error) {
-			this.logger.error("[model-proxy-mcp] Failed to list history", {
-				code: HISTORY_ERROR_CODES.listFailed,
-				scope,
-				cause: error
-			});
-			throw new ConversationHistoryServiceError("Failed to list conversation history", HISTORY_ERROR_CODES.listFailed, { cause: error });
-		}
-	}
-	/**
-	* Clears all history rows for a single scope and returns the deleted count.
-	*/
-	async clearScope(scope) {
-		try {
-			return (await this.getDb()).prepare(`DELETE FROM ${HISTORY_TABLE} WHERE scope = ?`).run(scope).changes;
-		} catch (error) {
-			this.logger.error("[model-proxy-mcp] Failed to clear history", {
-				code: HISTORY_ERROR_CODES.clearFailed,
-				scope,
-				cause: error
-			});
-			throw new ConversationHistoryServiceError("Failed to clear conversation history", HISTORY_ERROR_CODES.clearFailed, { cause: error });
-		}
-	}
-	/**
-	* Returns retention stats for a scope.
-	*/
-	async getStats(scope) {
-		try {
-			const row = (await this.getDb()).prepare(`
-            SELECT COUNT(*) as count, MIN(created_at) as oldest, MAX(created_at) as newest
-            FROM ${HISTORY_TABLE}
-            WHERE scope = ?
-          `).get(scope);
-			return {
-				scope,
-				retentionLimit: this.retentionLimit,
-				totalMessages: Number(row.count),
-				oldestCreatedAt: row.oldest,
-				newestCreatedAt: row.newest
-			};
-		} catch (error) {
-			this.logger.error("[model-proxy-mcp] Failed to read history stats", {
-				code: HISTORY_ERROR_CODES.statsFailed,
-				scope,
-				cause: error
-			});
-			throw new ConversationHistoryServiceError("Failed to read history stats", HISTORY_ERROR_CODES.statsFailed, { cause: error });
-		}
-	}
-	/**
-	* Lists known scopes discovered from stored conversation history.
-	*/
-	async listScopes() {
-		try {
-			return (await this.getDb()).prepare(`SELECT DISTINCT scope FROM ${HISTORY_TABLE} ORDER BY scope ASC`).all().map((row) => row.scope);
-		} catch (error) {
-			this.logger.error("[model-proxy-mcp] Failed to list history scopes", {
-				code: HISTORY_ERROR_CODES.listFailed,
-				cause: error
-			});
-			return [];
-		}
-	}
-	/**
-	* Removes the oldest rows for a scope when it exceeds retention.
-	*/
-	async pruneScope(scope) {
-		const db = await this.getDb();
-		const row = db.prepare(`SELECT COUNT(*) as count FROM ${HISTORY_TABLE} WHERE scope = ?`).get(scope);
-		const overflow = Number(row.count) - this.retentionLimit;
-		if (overflow <= 0) return;
-		db.prepare(`
-        DELETE FROM ${HISTORY_TABLE}
-        WHERE sequence IN (
-          SELECT sequence
-          FROM ${HISTORY_TABLE}
-          WHERE scope = ?
-          ORDER BY sequence ASC
-          LIMIT ?
-        )
-      `).run(scope, overflow);
-	}
-	/**
-	* Lazily initializes the SQLite connection and schema.
-	*/
-	async getDb() {
-		if (this.sqlite) return this.sqlite;
-		try {
-			await fs$1.mkdir(path.dirname(this.dbPath), { recursive: true });
-			this.sqlite = new Database(this.dbPath);
-			this.sqlite.pragma("journal_mode = WAL");
-			this.sqlite.exec(`
-        CREATE TABLE IF NOT EXISTS ${HISTORY_TABLE} (
-          sequence INTEGER PRIMARY KEY AUTOINCREMENT,
-          id TEXT NOT NULL UNIQUE,
-          scope TEXT NOT NULL,
-          request_id TEXT NOT NULL,
-          direction TEXT NOT NULL,
-          role TEXT,
-          message_type TEXT NOT NULL,
-          model TEXT,
-          slot TEXT NOT NULL,
-          payload_json TEXT NOT NULL,
-          created_at TEXT NOT NULL
-        )
-      `);
-			this.sqlite.exec(`CREATE INDEX IF NOT EXISTS ${HISTORY_SCOPE_SEQUENCE_INDEX} ON ${HISTORY_TABLE} (scope, sequence DESC)`);
-			this.sqlite.exec(`CREATE INDEX IF NOT EXISTS ${HISTORY_SCOPE_REQUEST_INDEX} ON ${HISTORY_TABLE} (scope, request_id)`);
-			return this.sqlite;
-		} catch (error) {
-			this.logger.error("[model-proxy-mcp] Failed to initialize history database", {
-				code: HISTORY_ERROR_CODES.initFailed,
-				dbPath: this.dbPath,
-				cause: error
-			});
-			throw new ConversationHistoryServiceError("Failed to initialize history database", HISTORY_ERROR_CODES.initFailed, { cause: error });
-		}
-	}
-	/**
-	* Maps a SQLite row into the public history DTO.
-	*/
-	toEntry(row) {
-		return {
-			id: row.id,
-			scope: row.scope,
-			requestId: row.request_id,
-			direction: row.direction,
-			role: row.role,
-			messageType: row.message_type,
-			model: row.model,
-			slot: row.slot,
-			payloadJson: row.payload_json,
-			createdAt: row.created_at
-		};
-	}
-};
-
-//#endregion
-//#region src/services/GatewayService.ts
-const MODEL_SLOT_BY_NAME = {
-	"ccproxy-default": "default",
-	"ccproxy-sonnet": "sonnet",
-	"ccproxy-opus": "opus",
-	"ccproxy-haiku": "haiku",
-	"ccproxy-subagent": "subagent"
-};
-const DEFAULT_SCOPE$1 = "default";
-const DEFAULT_SLOT$1 = "default";
-const DEFAULT_HISTORY_PAGE_SIZE = 50;
-const MODEL_SLOTS = [
-	"default",
-	"sonnet",
-	"opus",
-	"haiku",
-	"subagent"
-];
-const CLAUDE_MESSAGES_ENDPOINT = "https://api.anthropic.com/v1/messages";
-const DEFAULT_ANTHROPIC_VERSION = "2023-06-01";
-const ANTHROPIC_COMPATIBLE_PROVIDER = "anthropic-compatible";
-const CHATGPT_CODEX_PROVIDER = "chatgpt-codex";
-const GEMINI_DIRECT_PROVIDER = "gemini-direct";
-const DEFAULT_UPSTREAM_AUTH_ENV = "ANTHROPIC_AUTH_TOKEN";
-const FALLBACK_UPSTREAM_AUTH_ENV = "MODEL_PROXY_MCP_UPSTREAM_AUTH_TOKEN";
-const FALLBACK_UPSTREAM_TIMEOUT_ENV = "MODEL_PROXY_MCP_UPSTREAM_TIMEOUT_MS";
-const CONFIGURED_UPSTREAM_AUTH_ENV_NAME = "MODEL_PROXY_MCP_UPSTREAM_AUTH_ENV";
-const DEFAULT_API_TIMEOUT_ENV = "API_TIMEOUT_MS";
-const ERROR_RESPONSE_CONTENT_TYPE = "application/json; charset=utf-8";
-const JSON_CONTENT_TYPE = "application/json";
-const SSE_CONTENT_TYPE = "text/event-stream; charset=utf-8";
-const RESPONSE_CONTENT_TYPE_HEADER = "content-type";
-const RESPONSE_CACHE_CONTROL_HEADER = "cache-control";
-const RESPONSE_CONNECTION_HEADER = "connection";
-const AUTHORIZATION_HEADER = "authorization";
-const X_API_KEY_HEADER = "x-api-key";
-const ACCEPT_HEADER = "accept";
-const ANTHROPIC_VERSION_HEADER = "anthropic-version";
-const ANTHROPIC_BETA_HEADER = "anthropic-beta";
-const HEADER_NO_CACHE = "no-cache";
-const HEADER_KEEP_ALIVE = "keep-alive";
-const API_ERROR_TYPE = "api_error";
-const RAW_REQUEST_MESSAGE_TYPE = "raw-request";
-const RESPONSE_STREAM_MESSAGE_TYPE = "response-stream";
-const ERROR_MESSAGE_TYPE = "error";
-const REQUEST_DIRECTION = "request";
-const RESPONSE_DIRECTION = "response";
-const ERROR_DIRECTION = "error";
-const SYSTEM_ROLE = "system";
-const ASSISTANT_ROLE = "assistant";
-const MESSAGE_MESSAGE_TYPE = "message";
-const RESPONSE_ITEM_MESSAGE_TYPE = "response-item";
-const MODEL_NOT_FOUND = "MODEL_NOT_FOUND";
-const REQUEST_FORWARD_FAILED = "REQUEST_FORWARD_FAILED";
-const REQUEST_VALIDATION_FAILED = "REQUEST_VALIDATION_FAILED";
-const REQUEST_PAYLOAD_PREVIEW_LIMIT = 240;
-const HTTP_STATUS_OK = 200;
-const GEMINI_GENERATE_CONTENT_METHOD = "generateContent";
-const GEMINI_STREAM_GENERATE_CONTENT_METHOD = "streamGenerateContent";
-const CODE_ASSIST_LOAD_METHOD = "loadCodeAssist";
-const CODE_ASSIST_IDE_TYPE = "IDE_UNSPECIFIED";
-const CODE_ASSIST_PLATFORM = "PLATFORM_UNSPECIFIED";
-const CODE_ASSIST_PLUGIN_TYPE = "GEMINI";
-const CLAUDE_REQUEST_SCHEMA = z.object({
-	model: z.string().optional(),
-	system: z.unknown().optional(),
-	messages: z.array(z.unknown()).default([]),
-	tools: z.array(z.unknown()).optional(),
-	max_tokens: z.number().int().positive().optional(),
-	stream: z.boolean().optional()
-});
-/**
-* Base error type for gateway operations with HTTP status and domain code metadata.
-*/
-var GatewayServiceError = class extends Error {
-	constructor(message, code, status, options) {
-		super(message, options);
-		this.code = code;
-		this.status = status;
-		this.name = new.target.name;
-	}
-};
-/**
-* Raised when an inbound Claude request payload is invalid.
-*/
-var GatewayValidationError = class extends GatewayServiceError {};
-/**
-* Raised when the active proxy configuration cannot satisfy a request.
-*/
-var GatewayConfigError = class extends GatewayServiceError {};
-/**
-* Raised when upstream authentication is missing or invalid.
-*/
-var GatewayAuthError = class extends GatewayServiceError {};
-/**
-* Raised when an upstream request fails in a way that might be recoverable by trying fallbacks.
-*/
-var GatewayUpstreamError = class extends GatewayServiceError {
-	constructor(message, status, upstreamBody, attemptLabel, options) {
-		super(message, REQUEST_FORWARD_FAILED, status, options);
-		this.upstreamBody = upstreamBody;
-		this.attemptLabel = attemptLabel;
-	}
-};
-const HTTP_STATUS_INTERNAL_SERVER_ERROR = 500;
-const RECOVERABLE_UPSTREAM_STATUSES = new Set([
-	408,
-	429,
-	500,
-	502,
-	503,
-	504
-]);
-/**
-* Coordinates settings-backed model selection, request forwarding, and scoped history persistence.
-*/
-var GatewayService = class {
-	constructor(profileStore = new ProfileStore(), codexAuth = new CodexAuth(consoleLogger, DEFAULT_AUTH_FILE_PATH), logger = consoleLogger, fetchImpl = fetch, historyService = new ConversationHistoryService()) {
-		this.profileStore = profileStore;
-		this.codexAuth = codexAuth;
-		this.logger = logger;
-		this.fetchImpl = fetchImpl;
-		this.historyService = historyService;
-	}
-	/**
-	* Lists all configured profiles for the given scope.
-	*/
-	async listProfiles(scope = DEFAULT_SCOPE$1) {
-		return this.profileStore.listProfiles(scope);
-	}
-	/**
-	* Eagerly seeds the scoped settings file so startup always has a backing config.
-	*/
-	async ensureConfig(scope = DEFAULT_SCOPE$1) {
-		await this.historyService.ensureInitialized();
-		return this.profileStore.ensureConfig(scope);
-	}
-	/**
-	* Returns the resolved admin config used by the live HTTP server and UI.
-	*/
-	async getAdminConfig(scope = DEFAULT_SCOPE$1) {
-		return this.profileStore.getAdminConfig(scope);
-	}
-	/**
-	* Updates the resolved admin config.
-	*/
-	async updateAdminConfig(update, scope = DEFAULT_SCOPE$1) {
-		await this.profileStore.updateConfig(update, scope);
-		return this.profileStore.getAdminConfig(scope);
-	}
-	/**
-	* Returns the currently selected profile for a scope/slot pair.
-	*/
-	async getActiveProfile(scope = DEFAULT_SCOPE$1, slot = DEFAULT_SLOT$1) {
-		return this.profileStore.getActiveProfile(scope, slot);
-	}
-	/**
-	* Creates or updates a profile in the scoped settings file.
-	*/
-	async upsertProfile(profile, scope = DEFAULT_SCOPE$1) {
-		return this.profileStore.upsertProfile(profile, scope);
-	}
-	/**
-	* Selects the active profile by profile id for the requested slot.
-	*/
-	async setActiveProfile(profileId, scope = DEFAULT_SCOPE$1, slot = DEFAULT_SLOT$1) {
-		return this.profileStore.setActiveProfile(profileId, scope, slot);
-	}
-	/**
-	* Returns the active profile currently used for routing requests.
-	*/
-	async getCurrentModel(scope = DEFAULT_SCOPE$1, slot = DEFAULT_SLOT$1) {
-		return this.profileStore.getActiveProfile(scope, slot);
-	}
-	/**
-	* Switches the selected model by model name.
-	*/
-	async switchModel(model, scope = DEFAULT_SCOPE$1, slot = DEFAULT_SLOT$1) {
-		const profiles = await this.profileStore.listProfiles(scope);
-		const current = await this.profileStore.getResolvedSlotConfig(scope, slot);
-		const profile = profiles.find((item) => item.model === model && item.provider === current.provider && item.enabled) ?? profiles.find((item) => item.model === model && item.enabled);
-		if (!profile) throw new GatewayConfigError(`Model not found or disabled: ${model}`, MODEL_NOT_FOUND, 400, { cause: {
-			model,
-			scope,
-			slot
-		} });
-		return this.profileStore.updateConfig({ models: { [slot]: {
-			main: {
-				provider: profile.provider,
-				model: profile.model,
-				reasoningEffort: profile.reasoningEffort
-			},
-			fallbacks: (await this.profileStore.getAdminConfig(scope)).scopeModels[slot]?.fallbacks ?? []
-		} } }, scope);
-	}
-	/**
-	* Lists persisted history for a scope.
-	*/
-	async listHistory(scope = DEFAULT_SCOPE$1, limit = DEFAULT_HISTORY_PAGE_SIZE, cursor) {
-		return this.historyService.listHistory(scope, limit, cursor);
-	}
-	/**
-	* Clears persisted history for a scope.
-	*/
-	async clearHistory(scope = DEFAULT_SCOPE$1) {
-		return { deleted: await this.historyService.clearScope(scope) };
-	}
-	/**
-	* Lists known scopes from config files and stored history.
-	*/
-	async listScopes() {
-		const [configScopes, historyScopes] = await Promise.all([this.profileStore.listScopes(), this.historyService.listScopes()]);
-		return Array.from(new Set([
-			...configScopes,
-			...historyScopes,
-			DEFAULT_SCOPE$1
-		])).sort();
-	}
-	/**
-	* Returns persisted history stats for a scope.
-	*/
-	async getHistoryStats(scope = DEFAULT_SCOPE$1) {
-		return this.historyService.getStats(scope);
-	}
-	/**
-	* Returns the current gateway status, auth state, and active slot routing.
-	*/
-	async getStatus(scope = DEFAULT_SCOPE$1, port, pid) {
-		const config = await this.profileStore.getConfig(scope);
-		const activeSlot = await this.profileStore.getResolvedSlotConfig(scope, DEFAULT_SLOT$1);
-		const authStatus = await this.codexAuth.getAuthStatus();
-		const slotModels = Object.fromEntries(await Promise.all(MODEL_SLOTS.map(async (slot) => {
-			const resolved = await this.profileStore.getResolvedSlotConfig(scope, slot);
-			return [slot, {
-				profileId: resolved.profileId,
-				provider: resolved.provider,
-				model: resolved.model,
-				reasoningEffort: resolved.reasoningEffort,
-				thinkingDisabled: resolved.thinkingDisabled ?? false
-			}];
-		})));
-		return {
-			running: true,
-			port,
-			pid,
-			scope,
-			activeProfileId: config.activeProfileId,
-			activeModel: activeSlot.model ?? void 0,
-			activeReasoningEffort: activeSlot.reasoningEffort,
-			slotModels,
-			auth: authStatus,
-			profiles: config.profiles
-		};
-	}
-	/**
-	* Returns the OpenAI-compatible model listing served by the proxy.
-	*/
-	async getModels(scope = DEFAULT_SCOPE$1) {
-		return {
-			object: "list",
-			data: (await this.profileStore.listProfiles(scope)).map((profile) => ({
-				id: profile.model,
-				object: "model",
-				created: 0,
-				owned_by: `${profile.provider}:${profile.id}`,
-				metadata: {
-					profileId: profile.id,
-					reasoningEffort: profile.reasoningEffort
-				}
-			}))
-		};
-	}
-	/**
-	* Forwards a Claude-compatible request to the configured upstream Codex endpoint.
-	*/
-	async forwardClaudeRequest(requestBody, scope = DEFAULT_SCOPE$1, requestHeaders = new Headers()) {
-		const requestId = ulid();
-		let slot = DEFAULT_SLOT$1;
-		let resolved = null;
-		try {
-			const parsed = this.parseClaudeRequest(requestBody);
-			const adminConfig = await this.profileStore.getAdminConfig(scope);
-			slot = this.resolveSlot(parsed.model, adminConfig);
-			resolved = this.resolveRequestedModel(parsed.model, adminConfig, slot);
-			if (!resolved.model) {
-				const message$1 = `No active model configured for scope '${scope}' and slot '${slot}'`;
-				await this.recordError(scope, slot, resolved, requestId, message$1, requestBody);
-				return this.createErrorResponse(400, message$1);
-			}
-			const attemptTargets = this.buildAttemptTargets(adminConfig, resolved, slot);
-			if (attemptTargets.length === 0) {
-				const message$1 = `No provider configured for scope '${scope}' and slot '${slot}'`;
-				await this.recordError(scope, slot, resolved, requestId, message$1, requestBody);
-				return this.createErrorResponse(400, message$1);
-			}
-			await this.recordRequest(scope, slot, attemptTargets[0].resolved, requestId, parsed, requestBody);
-			let lastRecoverableFailure = null;
-			for (const target of attemptTargets) {
-				const result = await this.forwardSingleAttempt(target, parsed, requestBody, scope, slot, requestHeaders);
-				if (result.ok) {
-					await this.recordResponse(scope, slot, target.resolved, requestId, result.success.upstreamText, result.success.claudeBody);
-					return result.success.response;
-				}
-				const { error, payloadForHistory } = result.failure;
-				if (!this.isRecoverableUpstreamError(error)) {
-					this.logger.error("[model-proxy-mcp] Non-recoverable model attempt failed", {
-						scope,
-						slot,
-						model: target.resolved.model,
-						code: error.code,
-						status: error.status,
-						message: error.message
-					});
-					await this.recordError(scope, slot, target.resolved, requestId, error.message, payloadForHistory);
-					return this.createErrorResponse(error.status, error.message);
-				}
-				lastRecoverableFailure = result.failure;
-				this.logger.warn("[model-proxy-mcp] Recoverable model attempt failed; trying fallback", {
-					scope,
-					slot,
-					model: target.resolved.model,
-					code: error.code,
-					status: error.status,
-					message: error.message
-				});
-				await this.recordError(scope, slot, target.resolved, requestId, `Attempt failed for ${target.label}: ${error.message}`, payloadForHistory);
-			}
-			if (lastRecoverableFailure) {
-				await this.recordError(scope, slot, resolved, requestId, lastRecoverableFailure.error.message, lastRecoverableFailure.payloadForHistory);
-				return this.createErrorResponse(lastRecoverableFailure.error.status, lastRecoverableFailure.error.message);
-			}
-			const message = "No model attempt could be executed";
-			await this.recordError(scope, slot, resolved, requestId, message, requestBody);
-			return this.createErrorResponse(HTTP_STATUS_INTERNAL_SERVER_ERROR, message);
-		} catch (error) {
-			const gatewayError = error instanceof GatewayServiceError ? error : new GatewayServiceError("Failed to process Claude proxy request", REQUEST_FORWARD_FAILED, 500, { cause: error });
-			this.logger.error("[model-proxy-mcp] Request forwarding failed", {
-				scope,
-				slot,
-				code: gatewayError.code,
-				message: gatewayError.message,
-				cause: gatewayError.cause
-			});
-			await this.recordError(scope, slot, resolved, requestId, gatewayError.message, requestBody);
-			return this.createErrorResponse(gatewayError.status, gatewayError.message);
-		}
-	}
-	buildAttemptTargets(adminConfig, primary, slot) {
-		const targets = [];
-		const dedupe = /* @__PURE__ */ new Set();
-		const candidates = [primary, ...primary.fallbacks.map((fallback) => ({
-			...primary,
-			...fallback,
-			slot
-		}))];
-		for (const candidate of candidates) {
-			const providerId = candidate.provider;
-			const modelId = candidate.model;
-			if (!providerId || !modelId) continue;
-			const provider = adminConfig.providers[providerId];
-			if (!provider) continue;
-			const key = `${providerId}:${modelId}:${candidate.reasoningEffort}:${candidate.thinkingDisabled ? "off" : "on"}`;
-			if (dedupe.has(key)) continue;
-			dedupe.add(key);
-			targets.push({
-				resolved: {
-					...candidate,
-					slot,
-					provider: providerId,
-					model: modelId,
-					providerType: provider.type,
-					endpoint: provider.endpoint,
-					reasoningEffort: candidate.reasoningEffort,
-					thinkingDisabled: candidate.thinkingDisabled ?? false,
-					fallbacks: []
-				},
-				provider,
-				label: `${providerId}/${modelId}`
-			});
-		}
-		return targets;
-	}
-	async forwardSingleAttempt(target, parsedRequest, requestBody, scope, slot, requestHeaders) {
-		try {
-			if (target.resolved.providerType === ANTHROPIC_COMPATIBLE_PROVIDER) return {
-				ok: true,
-				success: await this.forwardAnthropicCompatibleRequest(requestBody, scope, slot, target.resolved, target.provider, requestHeaders)
-			};
-			if (target.resolved.providerType === GEMINI_DIRECT_PROVIDER) return {
-				ok: true,
-				success: await this.forwardGeminiDirectRequest(parsedRequest, scope, slot, target.resolved, target.provider, requestHeaders)
-			};
-			return {
-				ok: true,
-				success: await this.forwardCodexRequest(requestBody, scope, slot, target.resolved)
-			};
-		} catch (error) {
-			return {
-				ok: false,
-				failure: {
-					error: error instanceof GatewayServiceError ? error : new GatewayServiceError("Failed to process Claude proxy request", REQUEST_FORWARD_FAILED, 500, { cause: error }),
-					payloadForHistory: error instanceof GatewayUpstreamError ? error.upstreamBody : requestBody
-				}
-			};
-		}
-	}
-	isRecoverableUpstreamError(error) {
-		return error instanceof GatewayUpstreamError && RECOVERABLE_UPSTREAM_STATUSES.has(error.status);
-	}
-	async forwardCodexRequest(requestBody, scope, slot, resolved) {
-		const resolvedModel = resolved.model;
-		if (!resolvedModel) throw new GatewayConfigError(`No active model configured for slot '${slot}'`, MODEL_NOT_FOUND, 400);
-		if (!await this.codexAuth.getAccessToken()) throw new GatewayAuthError("Missing Codex auth. Sign in with the official Codex CLI first.", "AUTH_MISSING", 401);
-		const transformer = new ClaudeToOpenAITransformer({
-			toProvider: CHATGPT_CODEX_PROVIDER,
-			toModel: resolvedModel,
-			toEndpoint: resolved.endpoint ?? CLAUDE_MESSAGES_ENDPOINT,
-			sessionReasoningEffort: resolved.reasoningEffort,
-			thinkingDisabled: resolved.thinkingDisabled ?? false,
-			logger: this.logger
-		}, this.codexAuth);
-		const responseTransformer = new OpenAIToClaudeTransformer(this.logger, resolved.thinkingDisabled ?? false);
-		const transformed = await transformer.transform(CLAUDE_MESSAGES_ENDPOINT, requestBody);
-		const upstreamResponse = await this.fetchImpl(transformed.url, {
-			method: "POST",
-			headers: transformed.headers,
-			body: transformed.body
-		});
-		const upstreamText = await upstreamResponse.text();
-		if (!upstreamResponse.ok) {
-			this.logger.error("[model-proxy-mcp] Upstream request failed", {
-				scope,
-				slot,
-				profileId: resolved.profileId,
-				model: resolved.model,
-				status: upstreamResponse.status,
-				body: upstreamText
-			});
-			throw new GatewayUpstreamError(upstreamText || "Codex upstream request failed", upstreamResponse.status, upstreamText, `${resolved.provider}/${resolved.model}`);
-		}
-		const body = responseTransformer.transform(upstreamText);
-		return {
-			response: {
-				status: HTTP_STATUS_OK,
-				body,
-				headers: this.createSuccessHeaders(scope, slot)
-			},
-			upstreamText,
-			claudeBody: body
-		};
-	}
-	/**
-	* Forwards a Claude-compatible request to the Gemini GenerateContent REST API and translates the result back to Claude SSE.
-	*/
-	async forwardGeminiDirectRequest(parsedRequest, scope, slot, resolved, provider, requestHeaders) {
-		try {
-			const resolvedModel = resolved.model;
-			if (!resolvedModel) throw new GatewayConfigError(`No active Gemini model configured for scope '${scope}' and slot '${slot}'`, MODEL_NOT_FOUND, 400);
-			const authHeaders = await new GeminiAuth(this.logger).resolveHeaders(provider);
-			const requestTransformer = new ClaudeToGeminiTransformer();
-			const responseTransformer = new GeminiToClaudeTransformer();
-			const geminiRequest = {
-				model: parsedRequest.model,
-				system: parsedRequest.system,
-				messages: parsedRequest.messages,
-				tools: parsedRequest.tools,
-				max_tokens: parsedRequest.max_tokens
-			};
-			const transformed = requestTransformer.transform(geminiRequest, resolvedModel, resolved.reasoningEffort, resolved.thinkingDisabled ?? false);
-			if (authHeaders.authType === GEMINI_PERSONAL_OAUTH_AUTH_TYPE) return await this.forwardGeminiCodeAssistRequest(transformed.body, parsedRequest, scope, slot, resolved, authHeaders, responseTransformer);
-			const method = parsedRequest.stream === false ? GEMINI_GENERATE_CONTENT_METHOD : GEMINI_STREAM_GENERATE_CONTENT_METHOD;
-			const url = this.createGeminiRequestUrl(provider, transformed.modelPath, method, parsedRequest.stream !== false);
-			const headers = new Headers(authHeaders.headers);
-			headers.set(RESPONSE_CONTENT_TYPE_HEADER, JSON_CONTENT_TYPE);
-			headers.set(ACCEPT_HEADER, requestHeaders.get(ACCEPT_HEADER) ?? SSE_CONTENT_TYPE);
-			const timeoutMs = provider.apiTimeoutMs ?? this.resolveUpstreamTimeoutMs();
-			const upstreamResponse = await this.fetchImpl(url, {
-				method: "POST",
-				headers,
-				body: JSON.stringify(transformed.body),
-				signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : void 0
-			});
-			const upstreamText = await upstreamResponse.text();
-			if (!upstreamResponse.ok) {
-				this.logger.error("[model-proxy-mcp] Gemini upstream request failed", {
-					scope,
-					slot,
-					profileId: resolved.profileId,
-					model: resolved.model,
-					status: upstreamResponse.status,
-					body: upstreamText,
-					authMode: authHeaders.authMode,
-					authSource: authHeaders.authSource
-				});
-				throw new GatewayUpstreamError(upstreamText || "Gemini upstream request failed", upstreamResponse.status, upstreamText, `${resolved.provider}/${resolved.model}`);
-			}
-			const body = parsedRequest.stream === false ? responseTransformer.transformBuffered(upstreamText, resolvedModel) : responseTransformer.transformStreaming(upstreamText, resolvedModel);
-			return {
-				response: {
-					status: HTTP_STATUS_OK,
-					body,
-					headers: this.createSuccessHeaders(scope, slot)
-				},
-				upstreamText,
-				claudeBody: body
-			};
-		} catch (error) {
-			if (error instanceof GeminiAuthError) throw new GatewayAuthError(error.message, error.code, 401, { cause: error });
-			throw error;
-		}
-	}
-	async forwardGeminiCodeAssistRequest(transformedBody, parsedRequest, scope, slot, resolved, authHeaders, responseTransformer) {
-		const projectId = await this.resolveCodeAssistProjectId(authHeaders);
-		const url = this.createCodeAssistUrl(parsedRequest.stream === false ? GEMINI_GENERATE_CONTENT_METHOD : GEMINI_STREAM_GENERATE_CONTENT_METHOD, parsedRequest.stream !== false);
-		const headers = new Headers(authHeaders.headers);
-		headers.set(RESPONSE_CONTENT_TYPE_HEADER, JSON_CONTENT_TYPE);
-		headers.set(ACCEPT_HEADER, SSE_CONTENT_TYPE);
-		const requestBody = {
-			model: resolved.model,
-			project: projectId,
-			user_prompt_id: ulid(),
-			request: this.toCodeAssistGenerateContentRequest(transformedBody)
-		};
-		const upstreamResponse = await this.fetchImpl(url, {
-			method: "POST",
-			headers,
-			body: JSON.stringify(requestBody)
-		});
-		const upstreamText = await upstreamResponse.text();
-		if (!upstreamResponse.ok) {
-			this.logger.error("[model-proxy-mcp] Gemini Code Assist request failed", {
-				scope,
-				slot,
-				profileId: resolved.profileId,
-				model: resolved.model,
-				status: upstreamResponse.status,
-				body: upstreamText,
-				authMode: authHeaders.authMode,
-				authSource: authHeaders.authSource,
-				authType: authHeaders.authType
-			});
-			throw new GatewayUpstreamError(upstreamText || "Gemini Code Assist request failed", upstreamResponse.status, upstreamText, `${resolved.provider}/${resolved.model}`);
-		}
-		const normalizedResponse = parsedRequest.stream === false ? this.normalizeCodeAssistBufferedResponse(upstreamText) : this.normalizeCodeAssistStreamingResponse(upstreamText);
-		const body = parsedRequest.stream === false ? responseTransformer.transformBuffered(normalizedResponse, resolved.model ?? "gemini") : responseTransformer.transformStreaming(normalizedResponse, resolved.model ?? "gemini");
-		return {
-			response: {
-				status: HTTP_STATUS_OK,
-				body,
-				headers: this.createSuccessHeaders(scope, slot)
-			},
-			upstreamText,
-			claudeBody: body
-		};
-	}
-	/**
-	* Builds response headers shared by successful SSE responses.
-	*/
-	createSuccessHeaders(scope, slot) {
-		return {
-			[RESPONSE_CONTENT_TYPE_HEADER]: SSE_CONTENT_TYPE,
-			[RESPONSE_CACHE_CONTROL_HEADER]: HEADER_NO_CACHE,
-			[RESPONSE_CONNECTION_HEADER]: HEADER_KEEP_ALIVE,
-			"x-model-proxy-service": DEFAULT_SERVICE_NAME,
-			"x-model-proxy-scope": scope,
-			"x-model-proxy-slot": slot
-		};
-	}
-	/**
-	* Builds the target Gemini REST endpoint for buffered or streaming requests.
-	*/
-	createGeminiRequestUrl(provider, modelPath, method, streaming) {
-		const baseUrl = provider.endpoint.replace(/\/$/, "");
-		const apiVersion = provider.apiVersion ?? GEMINI_DEFAULT_API_VERSION;
-		const url = new URL(`${baseUrl}/${apiVersion}/${modelPath}:${method}`);
-		if (streaming) {
-			const [key, value] = GEMINI_STREAM_QUERY_PARAM.split("=");
-			if (key && value) url.searchParams.set(key, value);
-		}
-		return url.toString();
-	}
-	createCodeAssistUrl(method, streaming = false) {
-		const url = new URL(`${GEMINI_CODE_ASSIST_ENDPOINT}/${GEMINI_CODE_ASSIST_API_VERSION}:${method}`);
-		if (streaming) {
-			const [key, value] = GEMINI_STREAM_QUERY_PARAM.split("=");
-			if (key && value) url.searchParams.set(key, value);
-		}
-		return url.toString();
-	}
-	async resolveCodeAssistProjectId(authHeaders) {
-		const headers = new Headers(authHeaders.headers);
-		headers.set(RESPONSE_CONTENT_TYPE_HEADER, JSON_CONTENT_TYPE);
-		const configuredProject = process.env.GOOGLE_CLOUD_PROJECT || process.env.GOOGLE_CLOUD_PROJECT_ID || void 0;
-		const response = await this.fetchImpl(this.createCodeAssistUrl(CODE_ASSIST_LOAD_METHOD), {
-			method: "POST",
-			headers,
-			body: JSON.stringify({
-				cloudaicompanionProject: configuredProject,
-				metadata: {
-					ideType: CODE_ASSIST_IDE_TYPE,
-					platform: CODE_ASSIST_PLATFORM,
-					pluginType: CODE_ASSIST_PLUGIN_TYPE,
-					duetProject: configuredProject
-				}
-			})
-		});
-		const responseText = await response.text();
-		if (!response.ok) throw new GatewayUpstreamError(responseText || "Failed to load Gemini Code Assist project context", response.status, responseText, "google-gemini-direct/loadCodeAssist");
-		const projectId = JSON.parse(responseText).cloudaicompanionProject || configuredProject;
-		if (!projectId) throw new GatewayAuthError("Gemini Code Assist did not return a usable project ID.", "GEMINI_PROJECT_MISSING", 401);
-		return projectId;
-	}
-	toCodeAssistGenerateContentRequest(body) {
-		return {
-			contents: body.contents,
-			systemInstruction: body.system_instruction,
-			tools: body.tools,
-			toolConfig: body.tool_config,
-			generationConfig: body.generationConfig,
-			session_id: ulid()
-		};
-	}
-	normalizeCodeAssistBufferedResponse(responseBody) {
-		const parsed = JSON.parse(responseBody);
-		return JSON.stringify(this.extractCodeAssistResponse(parsed));
-	}
-	normalizeCodeAssistStreamingResponse(responseBody) {
-		const chunks = [];
-		for (const event of responseBody.split("\n\n")) {
-			const dataLine = event.split("\n").find((line) => line.startsWith("data:"))?.slice(5).trim();
-			if (!dataLine || dataLine === "[DONE]") continue;
-			const parsed = JSON.parse(dataLine);
-			chunks.push(`data: ${JSON.stringify(this.extractCodeAssistResponse(parsed))}`);
-			chunks.push("");
-		}
-		return chunks.join("\n");
-	}
-	extractCodeAssistResponse(payload) {
-		return {
-			candidates: payload.response?.candidates ?? [],
-			usageMetadata: payload.response?.usageMetadata,
-			modelVersion: payload.response?.modelVersion
-		};
-	}
-	/**
-	* Resolves the logical slot from a Claude model name or configured model mapping.
-	*/
-	resolveSlot(model, adminConfig) {
-		if (!model) return DEFAULT_SLOT$1;
-		const mappedSlot = MODEL_SLOT_BY_NAME[model];
-		if (mappedSlot) return mappedSlot;
-		for (const slot of MODEL_SLOTS) if (adminConfig.slots[slot].model === model) return slot;
-		return DEFAULT_SLOT$1;
-	}
-	/**
-	* Reconciles a request-specified concrete model with the resolved slot configuration.
-	*/
-	resolveRequestedModel(model, adminConfig, slot) {
-		const resolved = adminConfig.slots[slot];
-		if (!model || MODEL_SLOT_BY_NAME[model]) return resolved;
-		const profile = adminConfig.models.find((item) => item.model === model && item.provider === resolved.provider && item.enabled) ?? adminConfig.models.find((item) => item.model === model && item.enabled);
-		if (!profile && resolved.model !== model) throw new GatewayConfigError(`Model not found or disabled: ${model}`, MODEL_NOT_FOUND, 400, { cause: {
-			model,
-			slot,
-			scope: adminConfig.scope
-		} });
-		return {
-			...resolved,
-			profileId: profile?.id ?? null,
-			label: profile?.label ?? null,
-			provider: profile?.provider ?? resolved.provider,
-			providerType: profile?.providerType ?? resolved.providerType,
-			endpoint: profile?.endpoint ?? resolved.endpoint,
-			model: profile?.model ?? model,
-			reasoningEffort: profile?.reasoningEffort ?? resolved.reasoningEffort,
-			thinkingDisabled: resolved.thinkingDisabled ?? false
-		};
-	}
-	/**
-	* Forwards a Claude-compatible request to an Anthropic-compatible upstream such as Z.ai.
-	*/
-	async forwardAnthropicCompatibleRequest(requestBody, scope, slot, resolved, provider, requestHeaders) {
-		const token = this.getAnthropicCompatibleAuthToken(provider.authTokenEnvVar);
-		if (!token) throw new GatewayAuthError(`Missing upstream auth token for ${ANTHROPIC_COMPATIBLE_PROVIDER}. Set ${provider.authTokenEnvVar || DEFAULT_UPSTREAM_AUTH_ENV}.`, "UPSTREAM_AUTH_MISSING", 401);
-		const payload = this.sanitizeClaudePayloadForAnthropic({
-			...CLAUDE_REQUEST_SCHEMA.parse(JSON.parse(requestBody)),
-			model: resolved.model
-		});
-		const headers = new Headers();
-		headers.set(ACCEPT_HEADER, requestHeaders.get(ACCEPT_HEADER) ?? SSE_CONTENT_TYPE);
-		headers.set(RESPONSE_CONTENT_TYPE_HEADER, JSON_CONTENT_TYPE);
-		headers.set(ANTHROPIC_VERSION_HEADER, requestHeaders.get(ANTHROPIC_VERSION_HEADER) ?? DEFAULT_ANTHROPIC_VERSION);
-		headers.set(X_API_KEY_HEADER, token);
-		headers.set(AUTHORIZATION_HEADER, `Bearer ${token}`);
-		const anthropicBeta = requestHeaders.get(ANTHROPIC_BETA_HEADER);
-		if (anthropicBeta) headers.set(ANTHROPIC_BETA_HEADER, anthropicBeta);
-		const timeoutMs = provider.apiTimeoutMs ?? this.resolveUpstreamTimeoutMs();
-		const upstreamResponse = await this.fetchImpl(provider.endpoint, {
-			method: "POST",
-			headers,
-			body: JSON.stringify(payload),
-			signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : void 0
-		});
-		const upstreamText = await upstreamResponse.text();
-		if (!upstreamResponse.ok) {
-			this.logger.error("[model-proxy-mcp] Anthropic-compatible upstream request failed", {
-				scope,
-				slot,
-				profileId: resolved.profileId,
-				model: resolved.model,
-				status: upstreamResponse.status,
-				body: upstreamText
-			});
-			throw new GatewayUpstreamError(upstreamText || "Anthropic-compatible upstream request failed", upstreamResponse.status, upstreamText, `${resolved.provider}/${resolved.model}`);
-		}
-		return {
-			response: {
-				status: upstreamResponse.status,
-				body: upstreamText,
-				headers: {
-					[RESPONSE_CONTENT_TYPE_HEADER]: upstreamResponse.headers.get(RESPONSE_CONTENT_TYPE_HEADER) ?? SSE_CONTENT_TYPE,
-					[RESPONSE_CACHE_CONTROL_HEADER]: upstreamResponse.headers.get(RESPONSE_CACHE_CONTROL_HEADER) ?? HEADER_NO_CACHE,
-					[RESPONSE_CONNECTION_HEADER]: upstreamResponse.headers.get(RESPONSE_CONNECTION_HEADER) ?? HEADER_KEEP_ALIVE,
-					"x-model-proxy-service": DEFAULT_SERVICE_NAME,
-					"x-model-proxy-scope": scope,
-					"x-model-proxy-slot": slot
-				}
-			},
-			upstreamText,
-			claudeBody: upstreamText
-		};
-	}
-	/**
-	* Resolves the environment-provided auth token for Anthropic-compatible upstreams.
-	*/
-	getAnthropicCompatibleAuthToken(configuredEnvVar) {
-		const envVarName = configuredEnvVar || process.env[CONFIGURED_UPSTREAM_AUTH_ENV_NAME] || DEFAULT_UPSTREAM_AUTH_ENV;
-		return process.env[envVarName] || process.env[FALLBACK_UPSTREAM_AUTH_ENV] || null;
-	}
-	/**
-	* Resolves the request timeout for upstream Anthropic-compatible calls.
-	*/
-	resolveUpstreamTimeoutMs() {
-		const rawTimeout = process.env[DEFAULT_API_TIMEOUT_ENV] || process.env[FALLBACK_UPSTREAM_TIMEOUT_ENV];
-		if (!rawTimeout) return null;
-		const timeoutMs = Number.parseInt(rawTimeout, 10);
-		return Number.isInteger(timeoutMs) && timeoutMs > 0 ? timeoutMs : null;
-	}
-	createErrorResponse(status, message) {
-		return {
-			status,
-			body: JSON.stringify({
-				type: "error",
-				error: {
-					type: API_ERROR_TYPE,
-					message
-				}
-			}),
-			headers: { "content-type": ERROR_RESPONSE_CONTENT_TYPE }
-		};
-	}
-	/**
-	* Parses and validates an inbound Claude request.
-	*/
-	parseClaudeRequest(requestBody) {
-		try {
-			return CLAUDE_REQUEST_SCHEMA.parse(JSON.parse(requestBody));
-		} catch (error) {
-			if (error instanceof SyntaxError || error instanceof ZodError) throw new GatewayValidationError("Invalid Claude request payload", REQUEST_VALIDATION_FAILED, 400, { cause: error });
-			throw error;
-		}
-	}
-	/**
-	* Persists normalized inbound request messages for a proxied call.
-	*/
-	async recordRequest(scope, slot, resolved, requestId, parsedRequest, rawBody) {
-		const entries = [];
-		const systemEntries = this.normalizeSystemPayloads(parsedRequest.system);
-		for (const payload of systemEntries) entries.push({
-			scope,
-			requestId,
-			direction: REQUEST_DIRECTION,
-			role: SYSTEM_ROLE,
-			messageType: SYSTEM_ROLE,
-			model: resolved.model,
-			slot,
-			payloadJson: JSON.stringify(payload)
-		});
-		const messages = Array.isArray(parsedRequest.messages) ? parsedRequest.messages : [];
-		for (const message of messages) {
-			const role = this.extractRole(message);
-			entries.push({
-				scope,
-				requestId,
-				direction: REQUEST_DIRECTION,
-				role,
-				messageType: MESSAGE_MESSAGE_TYPE,
-				model: resolved.model,
-				slot,
-				payloadJson: JSON.stringify(message)
-			});
-		}
-		if (entries.length === 0) entries.push({
-			scope,
-			requestId,
-			direction: REQUEST_DIRECTION,
-			role: null,
-			messageType: RAW_REQUEST_MESSAGE_TYPE,
-			model: resolved.model,
-			slot,
-			payloadJson: rawBody
-		});
-		await this.historyService.appendEntries(entries);
-	}
-	/**
-	* Persists normalized upstream response items or a stream fallback.
-	*/
-	async recordResponse(scope, slot, resolved, requestId, upstreamText, claudeBody) {
-		const parsedEntries = this.normalizeResponsePayloads(scope, requestId, slot, resolved.model, upstreamText);
-		if (parsedEntries.length > 0) {
-			await this.historyService.appendEntries(parsedEntries);
-			return;
-		}
-		await this.historyService.appendEntries([{
-			scope,
-			requestId,
-			direction: RESPONSE_DIRECTION,
-			role: ASSISTANT_ROLE,
-			messageType: RESPONSE_STREAM_MESSAGE_TYPE,
-			model: resolved.model,
-			slot,
-			payloadJson: JSON.stringify({
-				upstreamText,
-				claudeBody
-			})
-		}]);
-	}
-	/**
-	* Persists a redacted error record for the request lifecycle.
-	*/
-	async recordError(scope, slot, resolved, requestId, message, payload) {
-		await this.historyService.appendEntries([{
-			scope,
-			requestId,
-			direction: ERROR_DIRECTION,
-			role: null,
-			messageType: ERROR_MESSAGE_TYPE,
-			model: resolved?.model ?? null,
-			slot,
-			payloadJson: JSON.stringify({
-				message,
-				payloadPreview: this.summarizePayload(payload)
-			})
-		}]);
-	}
-	/**
-	* Normalizes Claude system payloads into storable entries.
-	*/
-	normalizeSystemPayloads(system) {
-		if (!system) return [];
-		if (typeof system === "string") return [{
-			type: "text",
-			text: system
-		}];
-		if (Array.isArray(system)) return system;
-		return [system];
-	}
-	/**
-	* Removes proxy-private metadata before sending Claude payloads to strict Anthropic-compatible upstreams.
-	*/
-	sanitizeClaudePayloadForAnthropic(payload) {
-		return this.stripPrivateChatGptMetadata(payload);
-	}
-	stripPrivateChatGptMetadata(value) {
-		if (Array.isArray(value)) return value.map((item) => this.stripPrivateChatGptMetadata(item));
-		if (!value || typeof value !== "object") return value;
-		return Object.fromEntries(Object.entries(value).filter(([key]) => !key.startsWith("_chatgpt_")).map(([key, nestedValue]) => [key, this.stripPrivateChatGptMetadata(nestedValue)]));
-	}
-	/**
-	* Extracts a message role string when present.
-	*/
-	extractRole(message) {
-		if (!message || typeof message !== "object") return null;
-		const candidate = message.role;
-		return typeof candidate === "string" ? candidate : null;
-	}
-	/**
-	* Extracts response output items from upstream SSE payloads for storage.
-	*/
-	normalizeResponsePayloads(scope, requestId, slot, model, upstreamText) {
-		const entries = [];
-		for (const event of upstreamText.split("\n\n")) {
-			const dataLine = event.split("\n").find((line) => line.startsWith("data:"))?.slice(5).trim();
-			if (!dataLine || dataLine === "[DONE]") continue;
-			let payload;
-			try {
-				payload = JSON.parse(dataLine);
-			} catch {
-				continue;
-			}
-			const response = this.extractCompletedResponse(payload);
-			if (!response?.output || !Array.isArray(response.output)) continue;
-			for (const output of response.output) entries.push({
-				scope,
-				requestId,
-				direction: RESPONSE_DIRECTION,
-				role: ASSISTANT_ROLE,
-				messageType: typeof output.type === "string" ? output.type : RESPONSE_ITEM_MESSAGE_TYPE,
-				model: typeof response.model === "string" ? response.model : model,
-				slot,
-				payloadJson: JSON.stringify(output)
-			});
-		}
-		return entries;
-	}
-	/**
-	* Extracts the completed response envelope from an upstream SSE event payload.
-	*/
-	extractCompletedResponse(payload) {
-		if (!payload || typeof payload !== "object") return null;
-		const candidate = payload;
-		if (candidate.type === "response.completed" && candidate.response && typeof candidate.response === "object") return candidate.response;
-		if (candidate.response && typeof candidate.response === "object") return candidate.response;
-		return {
-			model: typeof candidate.model === "string" ? candidate.model : void 0,
-			output: Array.isArray(candidate.output) ? candidate.output : void 0
-		};
-	}
-	/**
-	* Redacts large request bodies before they are stored in error history.
-	*/
-	summarizePayload(payload) {
-		const compact = payload.replace(/\s+/g, " ").trim();
-		return compact.length <= REQUEST_PAYLOAD_PREVIEW_LIMIT ? compact : `${compact.slice(0, REQUEST_PAYLOAD_PREVIEW_LIMIT)}...`;
-	}
-};
-
-//#endregion
-//#region src/server/adminPage.ts
-const ADMIN_PAGE_HTML = `<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>Model Proxy Admin</title>
-    <style>
-      :root {
-        color-scheme: light;
-        --bg: #f3efe6;
-        --panel: rgba(255, 252, 246, 0.92);
-        --panel-border: #d7cdb7;
-        --text: #1f1b16;
-        --muted: #6b6255;
-        --accent: #b24a2f;
-        --accent-2: #1b6b73;
-        --danger: #8f2d21;
-      }
-      * { box-sizing: border-box; }
-      body {
-        margin: 0;
-        font-family: "Iowan Old Style", "Palatino Linotype", serif;
-        color: var(--text);
-        background:
-          radial-gradient(circle at top left, rgba(178, 74, 47, 0.14), transparent 28%),
-          radial-gradient(circle at top right, rgba(27, 107, 115, 0.12), transparent 24%),
-          linear-gradient(180deg, #f8f4eb 0%, var(--bg) 100%);
-      }
-      main {
-        max-width: 1280px;
-        margin: 0 auto;
-        padding: 32px 20px 48px;
-      }
-      h1, h2 {
-        margin: 0 0 12px;
-        font-weight: 700;
-      }
-      p { color: var(--muted); margin-top: 0; }
-      .hero {
-        display: grid;
-        gap: 16px;
-        margin-bottom: 24px;
-      }
-      .panel {
-        background: var(--panel);
-        border: 1px solid var(--panel-border);
-        border-radius: 18px;
-        padding: 18px;
-        box-shadow: 0 14px 40px rgba(80, 58, 24, 0.08);
-      }
-      .row {
-        display: grid;
-        gap: 12px;
-      }
-      .row.cols-2 { grid-template-columns: repeat(2, minmax(0, 1fr)); }
-      .row.cols-3 { grid-template-columns: repeat(3, minmax(0, 1fr)); }
-      .toolbar {
-        display: flex;
-        flex-wrap: wrap;
-        gap: 10px;
-        align-items: end;
-      }
-      label {
-        display: grid;
-        gap: 6px;
-        font-size: 13px;
-        color: var(--muted);
-      }
-      input, select, button, textarea {
-        font: inherit;
-        border-radius: 10px;
-        border: 1px solid #c9bea7;
-        padding: 10px 12px;
-        background: #fffdf8;
-        color: var(--text);
-      }
-      button {
-        background: var(--text);
-        color: #fff7ea;
-        border-color: var(--text);
-        cursor: pointer;
-      }
-      button.secondary {
-        background: #fff7ea;
-        color: var(--text);
-      }
-      button.danger {
-        background: var(--danger);
-        border-color: var(--danger);
-      }
-      table {
-        width: 100%;
-        border-collapse: collapse;
-      }
-      th, td {
-        padding: 10px 8px;
-        text-align: left;
-        border-bottom: 1px solid rgba(107, 98, 85, 0.16);
-        vertical-align: top;
-      }
-      th {
-        font-size: 12px;
-        text-transform: uppercase;
-        letter-spacing: 0.08em;
-        color: var(--muted);
-      }
-      code, pre {
-        font-family: "SFMono-Regular", "Menlo", monospace;
-        font-size: 12px;
-      }
-      pre {
-        margin: 0;
-        white-space: pre-wrap;
-        word-break: break-word;
-        max-height: 180px;
-        overflow: auto;
-      }
-      .status {
-        min-height: 20px;
-        color: var(--accent-2);
-      }
-      .muted { color: var(--muted); }
-      .slot-grid {
-        display: grid;
-        gap: 12px;
-      }
-      .slot-card {
-        padding: 14px;
-        border-radius: 14px;
-        border: 1px solid rgba(107, 98, 85, 0.16);
-        background: rgba(255, 255, 255, 0.7);
-      }
-      .slot-card h3 {
-        margin: 0 0 10px;
-        font-size: 18px;
-      }
-      .pill {
-        display: inline-flex;
-        padding: 4px 8px;
-        border-radius: 999px;
-        background: rgba(27, 107, 115, 0.1);
-        color: var(--accent-2);
-        font-size: 12px;
-      }
-      .paths {
-        display: grid;
-        gap: 8px;
-      }
-      @media (max-width: 900px) {
-        .row.cols-2, .row.cols-3 { grid-template-columns: 1fr; }
-      }
-    </style>
-  </head>
-  <body>
-    <main>
-      <section class="hero">
-        <div>
-          <h1>Model Proxy Admin</h1>
-          <p>Scoped slot routing, provider-aware model selection, and conversation history.</p>
-        </div>
-        <div class="panel toolbar">
-          <label>
-            Scope
-            <select id="scope-input"></select>
-          </label>
-          <button id="load-button" class="secondary">Load scope</button>
-          <span id="status" class="status"></span>
-        </div>
-      </section>
-
-      <section class="panel">
-        <h2>Runtime Config</h2>
-        <div class="paths muted">
-          <div>Providers: <code id="provider-config-path"></code></div>
-          <div>Model catalog: <code id="model-list-path"></code></div>
-          <div>Scope config: <code id="scope-config-path"></code></div>
-        </div>
-        <div id="slot-grid" class="slot-grid" style="margin-top:16px;"></div>
-        <div class="toolbar" style="margin-top:16px;">
-          <button id="save-config">Save config</button>
-        </div>
-      </section>
-
-      <section class="panel" style="margin-top:20px;">
-        <h2>Model Catalog</h2>
-        <div id="catalog" class="row"></div>
-      </section>
-
-      <section class="panel" style="margin-top:20px;">
-        <div class="toolbar" style="justify-content:space-between;">
-          <div>
-            <h2 style="margin-bottom:4px;">Conversation History</h2>
-            <p id="history-stats"></p>
-          </div>
-          <div class="toolbar">
-            <label>
-              Limit
-              <select id="history-limit">
-                <option>25</option>
-                <option selected>50</option>
-                <option>100</option>
-              </select>
-            </label>
-            <button id="refresh-history" class="secondary">Refresh history</button>
-            <button id="clear-history" class="danger">Clear history</button>
-          </div>
-        </div>
-        <div style="overflow:auto;">
-          <table>
-            <thead>
-              <tr>
-                <th>Created</th>
-                <th>Direction</th>
-                <th>Role</th>
-                <th>Slot</th>
-                <th>Model</th>
-                <th>Payload</th>
-              </tr>
-            </thead>
-            <tbody id="history-body"></tbody>
-          </table>
-        </div>
-        <div class="toolbar" style="margin-top:16px;">
-          <button id="more-history" class="secondary">Load more</button>
-        </div>
-      </section>
-    </main>
-
-    <script>
-      const reasoningOptions = ['minimal', 'low', 'medium', 'high'];
-      const slots = ['default', 'sonnet', 'opus', 'haiku', 'subagent'];
-      let currentConfig = null;
-      let nextCursor = null;
-
-      const scopeInput = document.getElementById('scope-input');
-      const statusEl = document.getElementById('status');
-      const slotGridEl = document.getElementById('slot-grid');
-      const catalogEl = document.getElementById('catalog');
-      const providerConfigPathEl = document.getElementById('provider-config-path');
-      const modelListPathEl = document.getElementById('model-list-path');
-      const scopeConfigPathEl = document.getElementById('scope-config-path');
-      const historyBodyEl = document.getElementById('history-body');
-      const historyStatsEl = document.getElementById('history-stats');
-      const historyLimitEl = document.getElementById('history-limit');
-
-      function setStatus(message, isError = false) {
-        statusEl.textContent = message;
-        statusEl.style.color = isError ? 'var(--danger)' : 'var(--accent-2)';
-      }
-
-      function renderScopeOptions(scopes) {
-        const currentScope = scopeInput.value || 'default';
-        const scopeList = Array.from(new Set(['default'].concat(scopes || []))).sort();
-        scopeInput.innerHTML = scopeList
-          .map((scope) => '<option value="' + scope + '">' + scope + '</option>')
-          .join('');
-        scopeInput.value = scopeList.includes(currentScope) ? currentScope : 'default';
-      }
-
-      function providerOptions(providers, selected) {
-        return Object.entries(providers)
-          .sort((left, right) => left[0].localeCompare(right[0]))
-          .map(([id, config]) => {
-            const isSelected = id === selected ? ' selected' : '';
-            return '<option value="' + id + '"' + isSelected + '>' + id + ' (' + config.type + ')</option>';
-          })
-          .join('');
-      }
-
-      function modelOptions(models, provider, selected) {
-        return models
-          .filter((model) => model.enabled && model.provider === provider)
-          .map((model) => {
-            const isSelected = model.model === selected ? ' selected' : '';
-            return '<option value="' + model.model + '"' + isSelected + '>' + model.label + ' (' + model.model + ')</option>';
-          })
-          .join('');
-      }
-
-      function reasoningSelect(value, slot) {
-        return (
-          '<select data-slot-reasoning="' +
-          slot +
-          '">' +
-          reasoningOptions
-            .map((option) => {
-              const selected = option === value ? ' selected' : '';
-              return '<option value="' + option + '"' + selected + '>' + option + '</option>';
-            })
-            .join('') +
-          '</select>'
-        );
-      }
-
-      function refreshSlotModelOptions(slot) {
-        if (!currentConfig) {
-          return;
-        }
-
-        const providerSelect = document.querySelector('[data-slot-provider="' + slot + '"]');
-        const modelSelect = document.querySelector('[data-slot-model="' + slot + '"]');
-        if (!providerSelect || !modelSelect) {
-          return;
-        }
-
-        const resolved = currentConfig.slots[slot];
-        const provider = providerSelect.value;
-        modelSelect.innerHTML = modelOptions(currentConfig.models, provider, resolved.model);
-
-        if (!modelSelect.value) {
-          const fallbackModel = currentConfig.models.find((model) => model.enabled && model.provider === provider);
-          if (fallbackModel) {
-            modelSelect.value = fallbackModel.model;
-          }
-        }
-
-        const endpointEl = document.querySelector('[data-slot-endpoint="' + slot + '"]');
-        if (endpointEl) {
-          endpointEl.textContent = currentConfig.providers[provider]?.endpoint || 'No provider config';
-        }
-      }
-
-      function renderConfig(config) {
-        currentConfig = config;
-        providerConfigPathEl.textContent = config.providerConfigPath;
-        modelListPathEl.textContent = config.modelListPath;
-        scopeConfigPathEl.textContent = config.scopeConfigPath;
-
-        slotGridEl.innerHTML = slots.map((slot) => {
-          const resolved = config.slots[slot];
-          return (
-            '<div class="slot-card">' +
-            '<div class="toolbar" style="justify-content:space-between;">' +
-            '<h3>' + slot + '</h3>' +
-            '<span class="pill">' +
-            (resolved.providerType ?? 'unconfigured') +
-            (resolved.fallbacks.length > 0 ? ' · +' + resolved.fallbacks.length + ' fallback' + (resolved.fallbacks.length > 1 ? 's' : '') : '') +
-            '</span>' +
-            '</div>' +
-            '<div class="row cols-3">' +
-            '<label>Provider<select data-slot-provider="' + slot + '">' +
-            providerOptions(config.providers, resolved.provider || '') +
-            '</select></label>' +
-            '<label>Model<select data-slot-model="' + slot + '"></select></label>' +
-            '<label>Thinking' + reasoningSelect(resolved.reasoningEffort, slot) + '</label>' +
-            '</div>' +
-            '<div class="muted" style="margin-top:10px;">Endpoint: <code data-slot-endpoint="' + slot + '"></code></div>' +
-            '</div>'
-          );
-        }).join('');
-
-        for (const slot of slots) {
-          refreshSlotModelOptions(slot);
-          const providerSelect = document.querySelector('[data-slot-provider="' + slot + '"]');
-          if (providerSelect) {
-            providerSelect.addEventListener('change', () => refreshSlotModelOptions(slot));
-          }
-        }
-
-        catalogEl.innerHTML = config.models
-          .map(
-            (model) =>
-              '<div class="panel" style="padding:12px;">' +
-              '<strong>' + model.label + '</strong>' +
-              '<div class="muted"><code>' + model.provider + '</code> · <code>' + model.model + '</code> · default thinking: ' + model.reasoningEffort + '</div>' +
-              '</div>',
-          )
-          .join('');
-      }
-
-      function payloadPreview(payloadJson) {
-        try {
-          return JSON.stringify(JSON.parse(payloadJson), null, 2);
-        } catch {
-          return payloadJson;
-        }
-      }
-
-      async function loadConfig() {
-        const scope = encodeURIComponent(scopeInput.value || 'default');
-        const response = await fetch('/admin/config?scope=' + scope);
-        if (!response.ok) {
-          throw new Error(await response.text());
-        }
-        renderConfig(await response.json());
-      }
-
-      async function loadScopes() {
-        const response = await fetch('/admin/scopes');
-        if (!response.ok) {
-          throw new Error(await response.text());
-        }
-        const payload = await response.json();
-        renderScopeOptions(payload.scopes || []);
-      }
-
-      async function saveConfig() {
-        const models = {};
-        for (const slot of slots) {
-          const currentSlot = currentConfig.scopeModels[slot];
-          models[slot] = {
-            main: {
-              provider: document.querySelector('[data-slot-provider="' + slot + '"]')?.value,
-              model: document.querySelector('[data-slot-model="' + slot + '"]')?.value,
-              reasoningEffort: document.querySelector('[data-slot-reasoning="' + slot + '"]')?.value,
-              thinkingDisabled:
-                currentSlot?.main?.thinkingDisabled ?? currentConfig.slots[slot]?.thinkingDisabled ?? false,
-            },
-            fallbacks: currentSlot?.fallbacks ?? [],
-          };
-        }
-
-        const response = await fetch('/admin/config?scope=' + encodeURIComponent(scopeInput.value || 'default'), {
-          method: 'PUT',
-          headers: { 'content-type': 'application/json' },
-          body: JSON.stringify({ models }),
-        });
-        if (!response.ok) {
-          throw new Error(await response.text());
-        }
-        renderConfig(await response.json());
-      }
-
-      async function loadHistory(append = false) {
-        const scope = encodeURIComponent(scopeInput.value || 'default');
-        const cursorQuery = append && nextCursor ? '&cursor=' + encodeURIComponent(nextCursor) : '';
-        const limit = encodeURIComponent(historyLimitEl.value);
-        const response = await fetch('/admin/history?scope=' + scope + '&limit=' + limit + cursorQuery);
-        if (!response.ok) {
-          throw new Error(await response.text());
-        }
-        const payload = await response.json();
-        nextCursor = payload.nextCursor;
-        const rows = payload.items
-          .map(
-            (item) =>
-              '<tr>' +
-              '<td>' + item.createdAt + '</td>' +
-              '<td>' + item.direction + '</td>' +
-              '<td>' + (item.role ?? '') + '</td>' +
-              '<td>' + item.slot + '</td>' +
-              '<td>' + (item.model ?? '') + '</td>' +
-              '<td><pre>' + payloadPreview(item.payloadJson) + '</pre></td>' +
-              '</tr>',
-          )
-          .join('');
-        historyBodyEl.innerHTML = append ? historyBodyEl.innerHTML + rows : rows;
-        document.getElementById('more-history').disabled = !nextCursor;
-
-        const statsResponse = await fetch('/admin/history/stats?scope=' + scope);
-        const stats = await statsResponse.json();
-        historyStatsEl.textContent = stats.totalMessages + ' stored messages. Retention limit ' + stats.retentionLimit + '.';
-      }
-
-      async function clearHistory() {
-        const scope = encodeURIComponent(scopeInput.value || 'default');
-        const response = await fetch('/admin/history?scope=' + scope, { method: 'DELETE' });
-        if (!response.ok) {
-          throw new Error(await response.text());
-        }
-        nextCursor = null;
-        historyBodyEl.innerHTML = '';
-        await loadHistory();
-      }
-
-      document.getElementById('load-button').addEventListener('click', async () => {
-        try {
-          setStatus('Loading...');
-          nextCursor = null;
-          await loadConfig();
-          await loadHistory();
-          setStatus('Scope loaded.');
-        } catch (error) {
-          setStatus(error.message, true);
-        }
-      });
-
-      document.getElementById('save-config').addEventListener('click', async () => {
-        try {
-          setStatus('Saving config...');
-          await saveConfig();
-          setStatus('Config saved.');
-        } catch (error) {
-          setStatus(error.message, true);
-        }
-      });
-
-      document.getElementById('refresh-history').addEventListener('click', async () => {
-        try {
-          setStatus('Refreshing history...');
-          nextCursor = null;
-          await loadHistory();
-          setStatus('History refreshed.');
-        } catch (error) {
-          setStatus(error.message, true);
-        }
-      });
-
-      document.getElementById('clear-history').addEventListener('click', async () => {
-        try {
-          setStatus('Clearing history...');
-          await clearHistory();
-          setStatus('History cleared.');
-        } catch (error) {
-          setStatus(error.message, true);
-        }
-      });
-
-      document.getElementById('more-history').addEventListener('click', async () => {
-        try {
-          setStatus('Loading more history...');
-          await loadHistory(true);
-          setStatus('More history loaded.');
-        } catch (error) {
-          setStatus(error.message, true);
-        }
-      });
-
-      document.addEventListener('DOMContentLoaded', async () => {
-        try {
-          await loadScopes();
-          await loadConfig();
-          await loadHistory();
-          setStatus('Ready.');
-        } catch (error) {
-          setStatus(error.message, true);
-        }
-      });
-    <\/script>
-  </body>
-</html>
-`;
-
-//#endregion
-//#region src/server/http.ts
-const reasoningEffortSchema = z.enum([
-	"minimal",
-	"low",
-	"medium",
-	"high"
-]);
-const modelSlotSchema$1 = z.enum([
-	"default",
-	"sonnet",
-	"opus",
-	"haiku",
-	"subagent"
-]);
-const selectionSchema = z.object({
-	provider: z.string().min(1),
-	model: z.string().min(1),
-	reasoningEffort: reasoningEffortSchema,
-	thinkingDisabled: z.boolean().optional()
-});
-const slotConfigSchema = z.object({
-	main: selectionSchema,
-	fallbacks: z.array(selectionSchema).default([])
-});
-const adminConfigUpdateSchema = z.object({ models: z.object({
-	default: slotConfigSchema.nullable().optional(),
-	sonnet: slotConfigSchema.nullable().optional(),
-	opus: slotConfigSchema.nullable().optional(),
-	haiku: slotConfigSchema.nullable().optional(),
-	subagent: slotConfigSchema.nullable().optional()
-}).optional() });
-const profileSchema = z.object({
-	id: z.string().min(1),
-	label: z.string().min(1),
-	provider: z.string().min(1),
-	model: z.string().min(1),
-	endpoint: z.url().nullable(),
-	reasoningEffort: reasoningEffortSchema.default("medium"),
-	enabled: z.boolean().default(true),
-	providerType: z.enum([
-		"chatgpt-codex",
-		"anthropic-compatible",
-		"gemini-direct"
-	]).nullable().optional()
-});
-function createHttpServer(gatewayService = new GatewayService()) {
-	const app = new Hono();
-	const getScope = (scope) => scope || "default";
-	app.get("/health", (c) => c.json({
-		status: "healthy",
-		service: DEFAULT_SERVICE_NAME
-	}));
-	app.get("/status", async (c) => {
-		const status = await gatewayService.getStatus();
-		return c.json(status);
-	});
-	app.get("/v1/models", async (c) => c.json(await gatewayService.getModels()));
-	app.get("/scopes/:scope/status", async (c) => c.json(await gatewayService.getStatus(getScope(c.req.param("scope")))));
-	app.get("/scopes/:scope/v1/models", async (c) => c.json(await gatewayService.getModels(getScope(c.req.param("scope")))));
-	app.post("/v1/messages", async (c) => {
-		const body = await c.req.text();
-		const response = await gatewayService.forwardClaudeRequest(body, "default", c.req.raw.headers);
-		return new Response(response.body, {
-			status: response.status,
-			headers: response.headers
-		});
-	});
-	app.post("/scopes/:scope/v1/messages", async (c) => {
-		const body = await c.req.text();
-		const response = await gatewayService.forwardClaudeRequest(body, getScope(c.req.param("scope")), c.req.raw.headers);
-		return new Response(response.body, {
-			status: response.status,
-			headers: response.headers
-		});
-	});
-	app.get("/admin", () => new Response(ADMIN_PAGE_HTML, { headers: { "content-type": "text/html; charset=utf-8" } }));
-	app.get("/admin/scopes", async (c) => c.json({ scopes: await gatewayService.listScopes() }));
-	app.get("/admin/config", async (c) => {
-		const scope = getScope(c.req.query("scope"));
-		return c.json(await gatewayService.getAdminConfig(scope));
-	});
-	app.get("/admin/profiles", async (c) => {
-		const scope = getScope(c.req.query("scope"));
-		return c.json({ profiles: await gatewayService.listProfiles(scope) });
-	});
-	app.get("/admin/current-model", async (c) => {
-		const scope = getScope(c.req.query("scope"));
-		const slot = c.req.query("slot") || "default";
-		return c.json({ profile: await gatewayService.getCurrentModel(scope, slot) });
-	});
-	app.get("/admin/history", async (c) => {
-		const scope = getScope(c.req.query("scope"));
-		const limit = z.coerce.number().int().positive().max(200).default(50).parse(c.req.query("limit") ?? 50);
-		const cursor = c.req.query("cursor") || void 0;
-		return c.json(await gatewayService.listHistory(scope, limit, cursor));
-	});
-	app.get("/admin/history/stats", async (c) => {
-		const scope = getScope(c.req.query("scope"));
-		return c.json(await gatewayService.getHistoryStats(scope));
-	});
-	app.put("/admin/profiles/:id", async (c) => {
-		const payload = profileSchema.parse(await c.req.json());
-		const scope = getScope(c.req.query("scope"));
-		const result = await gatewayService.upsertProfile({
-			...payload,
-			id: c.req.param("id"),
-			providerType: payload.providerType ?? null
-		}, scope);
-		return c.json(result);
-	});
-	app.put("/admin/active-profile", async (c) => {
-		const scope = getScope(c.req.query("scope"));
-		const payload = z.object({
-			profileId: z.string().min(1),
-			slot: modelSlotSchema$1.default("default")
-		}).parse(await c.req.json());
-		const result = await gatewayService.setActiveProfile(payload.profileId, scope, payload.slot);
-		return c.json(result);
-	});
-	app.put("/admin/current-model", async (c) => {
-		const scope = getScope(c.req.query("scope"));
-		const payload = z.object({
-			model: z.string().min(1),
-			slot: modelSlotSchema$1.default("default")
-		}).parse(await c.req.json());
-		const result = await gatewayService.switchModel(payload.model, scope, payload.slot);
-		return c.json(result);
-	});
-	app.put("/admin/config", async (c) => {
-		const scope = getScope(c.req.query("scope"));
-		const payload = adminConfigUpdateSchema.parse(await c.req.json());
-		return c.json(await gatewayService.updateAdminConfig(payload, scope));
-	});
-	app.delete("/admin/history", async (c) => {
-		const scope = getScope(c.req.query("scope"));
-		return c.json(await gatewayService.clearHistory(scope));
-	});
-	return app;
-}
-
-//#endregion
-//#region src/server/index.ts
-const DEFAULT_SCOPE = "default";
-const DEFAULT_SLOT = "default";
-const MODEL_PROXY_SCOPE_ENV = "MODEL_PROXY_MCP_SCOPE";
-const MODEL_PROXY_SLOT_ENV = "MODEL_PROXY_MCP_SLOT";
-const modelSlotSchema = z.enum([
-	"default",
-	"sonnet",
-	"opus",
-	"haiku",
-	"subagent"
-]);
-function createServer(gatewayService = new GatewayService(), environment = process.env) {
-	const resolveScope = (args) => {
-		const scope = args?.scope;
-		return typeof scope === "string" && scope.trim() ? scope : environment[MODEL_PROXY_SCOPE_ENV] || DEFAULT_SCOPE;
-	};
-	const resolveSlot = (args) => {
-		const slot = typeof args?.slot === "string" ? args.slot : environment[MODEL_PROXY_SLOT_ENV] || DEFAULT_SLOT;
-		return modelSlotSchema.parse(slot);
-	};
-	const server = new Server({
-		name: "model-proxy-mcp",
-		version: "0.1.0"
-	}, { capabilities: { tools: {} } });
-	server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [
-		{
-			name: "get_proxy_status",
-			description: "Get the HTTP proxy status, auth status, and active profile.",
-			inputSchema: {
-				type: "object",
-				properties: { scope: { type: "string" } },
-				additionalProperties: false
-			}
-		},
-		{
-			name: "list_profiles",
-			description: "List all configured model proxy profiles.",
-			inputSchema: {
-				type: "object",
-				properties: { scope: { type: "string" } },
-				additionalProperties: false
-			}
-		},
-		{
-			name: "get_active_profile",
-			description: "Get the active model proxy profile.",
-			inputSchema: {
-				type: "object",
-				properties: {
-					scope: { type: "string" },
-					slot: {
-						type: "string",
-						enum: modelSlotSchema.options
-					}
-				},
-				additionalProperties: false
-			}
-		},
-		{
-			name: "get_current_model",
-			description: "Get the currently active model and profile settings.",
-			inputSchema: {
-				type: "object",
-				properties: {
-					scope: { type: "string" },
-					slot: {
-						type: "string",
-						enum: modelSlotSchema.options
-					}
-				},
-				additionalProperties: false
-			}
-		},
-		{
-			name: "set_model_target",
-			description: "Set the scoped slot main target directly by provider, model, and reasoning effort.",
-			inputSchema: {
-				type: "object",
-				properties: {
-					provider: { type: "string" },
-					model: { type: "string" },
-					reasoningEffort: {
-						type: "string",
-						enum: [
-							"minimal",
-							"low",
-							"medium",
-							"high"
-						]
-					},
-					scope: { type: "string" },
-					slot: {
-						type: "string",
-						enum: modelSlotSchema.options
-					},
-					thinkingDisabled: { type: "boolean" }
-				},
-				required: [
-					"provider",
-					"model",
-					"reasoningEffort"
-				],
-				additionalProperties: false
-			}
-		},
-		{
-			name: "upsert_profile",
-			description: "Create or update a Codex model profile.",
-			inputSchema: {
-				type: "object",
-				properties: {
-					id: { type: "string" },
-					label: { type: "string" },
-					provider: { type: "string" },
-					model: { type: "string" },
-					endpoint: { type: "string" },
-					reasoningEffort: {
-						type: "string",
-						enum: [
-							"minimal",
-							"low",
-							"medium",
-							"high"
-						]
-					},
-					enabled: { type: "boolean" },
-					scope: { type: "string" }
-				},
-				required: [
-					"id",
-					"label",
-					"model",
-					"endpoint",
-					"reasoningEffort",
-					"enabled"
-				],
-				additionalProperties: false
-			}
-		}
-	] }));
-	server.setRequestHandler(CallToolRequestSchema, async (request) => {
-		const { name, arguments: args } = request.params;
-		try {
-			switch (name) {
-				case "get_proxy_status": return textResult(JSON.stringify(await gatewayService.getStatus(resolveScope(args)), null, 2));
-				case "list_profiles": return textResult(JSON.stringify(await gatewayService.listProfiles(resolveScope(args)), null, 2));
-				case "get_active_profile": return textResult(JSON.stringify(await gatewayService.getActiveProfile(resolveScope(args), resolveSlot(args)), null, 2));
-				case "get_current_model": return textResult(JSON.stringify(await gatewayService.getCurrentModel(resolveScope(args), resolveSlot(args)), null, 2));
-				case "set_model_target": {
-					const scope = resolveScope(args);
-					const slot = resolveSlot(args);
-					const existingConfig = await gatewayService.getAdminConfig(scope);
-					return textResult(JSON.stringify(await gatewayService.updateAdminConfig({ models: { [slot]: {
-						main: {
-							provider: String(args?.provider),
-							model: String(args?.model),
-							reasoningEffort: z.enum([
-								"minimal",
-								"low",
-								"medium",
-								"high"
-							]).parse(String(args?.reasoningEffort)),
-							thinkingDisabled: args?.thinkingDisabled === void 0 ? false : Boolean(args.thinkingDisabled)
-						},
-						fallbacks: existingConfig.scopeModels[slot]?.fallbacks ?? []
-					} } }, scope), null, 2));
-				}
-				case "upsert_profile": return textResult(JSON.stringify(await gatewayService.upsertProfile({
-					id: String(args?.id),
-					label: String(args?.label),
-					provider: String(args?.provider || "chatgpt-codex"),
-					providerType: null,
-					model: String(args?.model),
-					endpoint: String(args?.endpoint),
-					reasoningEffort: String(args?.reasoningEffort),
-					enabled: Boolean(args?.enabled)
-				}, resolveScope(args)), null, 2));
-				default: throw new Error(`Unknown tool: ${name}`);
-			}
-		} catch (error) {
-			return {
-				content: [{
-					type: "text",
-					text: `Error executing tool ${name}: ${error instanceof Error ? error.message : String(error)}`
-				}],
-				isError: true
-			};
-		}
-	});
-	return server;
-}
-function textResult(text) {
-	return { content: [{
-		type: "text",
-		text
-	}] };
-}
-
-//#endregion
-//#region src/transports/stdio.ts
-var StdioTransportHandler = class {
-	transport = null;
-	constructor(server) {
-		this.server = server;
-	}
-	async start() {
-		this.transport = new StdioServerTransport();
-		await this.server.connect(this.transport);
-	}
-	async stop() {
-		if (this.transport) {
-			await this.transport.close();
-			this.transport = null;
-		}
-	}
-};
-
-//#endregion
-export { ConversationHistoryService as a, DEFAULT_HTTP_PORT as c, GatewayService as i, DEFAULT_SERVICE_NAME as l, createServer as n, ProfileStore as o, createHttpServer as r, consoleLogger as s, StdioTransportHandler as t };