@codeworksh/aikit 0.11.0-dev.20261013131320 → 0.11.0-dev.20261019181702

package/modelgen-DDO_NHoQ.mjs

@@ -0,0 +1,731 @@
+import { C as readJson, S as path, T as writeJsonAtomic, d as effortThinkingLevels, h as isAnthropicAdaptiveThinkingModel, i as KnownProviderEnum, t as APIMethodEnum, v as normalizeInput } from "./model-Cjp-Dr8V.mjs";
+import { a as protocolForPackage, n as isAISDKPackage } from "./registry-u49t0S4S.mjs";
+import { n as GITHUB_COPILOT_STATIC_HEADERS } from "./copilot-headers-BLnBaJyp.mjs";
+import { resolve } from "node:path";
+import { mapValues, pick, pickBy, pipe } from "remeda";
+//#region src/model/openrouter.ts
+const PROVIDER_ID = "openrouter";
+const BASE_URL = "https://openrouter.ai/api/v1";
+const NPM = "@openrouter/ai-sdk-provider";
+const USER_MODELS_TIMEOUT_MS = 15e3;
+/**
+* $/token to $/1M tokens. Missing, invalid and negative prices use the fallback: OpenRouter
+* reports -1 for router models such as `openrouter/auto`, whose price depends on the model it picks.
+*/
+function perMillion(value, fallback) {
+	const perToken = Number.parseFloat(value ?? "");
+	return perToken >= 0 ? Number((perToken * 1e6).toFixed(6)) : fallback;
+}
+/**
+* Prompt-length overrides become request-wide tiers; a rate a tier does not list keeps the base
+* price. Time-of-day overrides are skipped: the cost model cannot express them.
+*/
+function cost(pricing) {
+	const base = {
+		input: perMillion(pricing?.prompt, 0),
+		output: perMillion(pricing?.completion, 0),
+		cacheRead: perMillion(pricing?.input_cache_read, 0),
+		cacheWrite: perMillion(pricing?.input_cache_write, 0)
+	};
+	const tiers = (pricing?.overrides ?? []).flatMap((override) => {
+		if (override.min_prompt_tokens === void 0 || override.utc_start !== void 0 || override.utc_end !== void 0 || override.utc_days !== void 0) return [];
+		return [{
+			inputTokensAbove: override.min_prompt_tokens,
+			input: perMillion(override.prompt, base.input),
+			output: perMillion(override.completion, base.output),
+			cacheRead: perMillion(override.input_cache_read, base.cacheRead),
+			cacheWrite: perMillion(override.input_cache_write, base.cacheWrite)
+		}];
+	});
+	return tiers.length > 0 ? {
+		...base,
+		tiers
+	} : base;
+}
+/**
+* `supported_efforts` uses models.dev's effort vocabulary. Off maps to `none` unless reasoning is
+* mandatory; a mandatory model without listed efforts can only refuse off.
+*/
+function thinkingLevels(reasoning) {
+	if (!reasoning) return void 0;
+	const map = effortThinkingLevels(reasoning.supported_efforts ?? []);
+	if (!map) return reasoning.mandatory === true ? { off: null } : void 0;
+	return {
+		...map,
+		off: reasoning.mandatory === true ? null : "none"
+	};
+}
+/**
+* The catalog entry for one listed model, or undefined for one an agent cannot use: no tool
+* calling, or a `:batch` variant, whose asynchronous pricing an interactive turn never gets.
+*/
+function toModel(entry) {
+	if (!entry.supported_parameters?.includes("tools") || entry.id.endsWith(":batch")) return void 0;
+	const thinkingLevelMap = thinkingLevels(entry.reasoning);
+	return {
+		id: entry.id,
+		name: entry.name ?? entry.id,
+		provider: {
+			id: PROVIDER_ID,
+			name: "OpenRouter",
+			source: "api",
+			env: ["OPENROUTER_API_KEY"]
+		},
+		baseUrl: BASE_URL,
+		reasoning: entry.supported_parameters.includes("reasoning"),
+		...thinkingLevelMap ? { thinkingLevelMap } : {},
+		input: normalizeInput(entry.architecture?.input_modalities),
+		cost: cost(entry.pricing),
+		contextWindow: entry.top_provider?.context_length || entry.context_length || 4096,
+		maxTokens: entry.top_provider?.max_completion_tokens || 4096,
+		npm: NPM,
+		api: {
+			id: entry.id,
+			url: BASE_URL,
+			method: APIMethodEnum.languageModel
+		},
+		providerOptionsKey: PROVIDER_ID,
+		protocol: KnownProviderEnum.openrouter
+	};
+}
+function entries(body) {
+	if (typeof body !== "object" || body === null || !("data" in body) || !Array.isArray(body.data)) throw new Error("invalid OpenRouter model list");
+	return body.data.filter((entry) => typeof entry === "object" && entry !== null && "id" in entry && typeof entry.id === "string");
+}
+/** The public `GET /models`, built into catalog entries keyed by id. */
+function catalog(body) {
+	const models = {};
+	for (const entry of entries(body)) {
+		const model = toModel(entry);
+		if (model) models[model.id] = model;
+	}
+	return models;
+}
+/**
+* Restrict OpenRouter models to those `key` may use, with the key's limits and prices from
+* `GET /models/user` (pi). A missing limit keeps the catalog value. When the endpoint rejects the
+* key (401/403) or does not exist (404), or allows nothing, the models come back unchanged.
+*/
+async function personalize(models, key, options = {}) {
+	const signal = AbortSignal.timeout(USER_MODELS_TIMEOUT_MS);
+	const response = await fetch(`${(options.baseUrl ?? "https://openrouter.ai/api/v1").replace(/\/+$/, "")}/models/user`, {
+		headers: {
+			accept: "application/json",
+			authorization: `Bearer ${key}`
+		},
+		signal: options.signal ? AbortSignal.any([options.signal, signal]) : signal
+	});
+	if (response.status === 401 || response.status === 403 || response.status === 404) return models;
+	if (!response.ok) throw new Error(`OpenRouter model list request failed: ${response.status}`);
+	const allowed = new Map(entries(await response.json()).map((entry) => [entry.id, entry]));
+	const personal = {};
+	for (const [id, model] of Object.entries(models)) {
+		const entry = allowed.get(id);
+		if (!entry) continue;
+		personal[id] = {
+			...model,
+			contextWindow: entry.top_provider?.context_length || entry.context_length || model.contextWindow,
+			maxTokens: entry.top_provider?.max_completion_tokens || model.maxTokens,
+			cost: entry.pricing ? cost(entry.pricing) : model.cost
+		};
+	}
+	return Object.keys(personal).length > 0 ? personal : models;
+}
+//#endregion
+//#region src/cli/modelgen.ts
+const DEFAULT_PROVIDER_BASE_URLS = {
+	[KnownProviderEnum.anthropic]: "https://api.anthropic.com/v1",
+	[KnownProviderEnum.openai]: "https://api.openai.com/v1",
+	[KnownProviderEnum.openrouter]: BASE_URL,
+	[KnownProviderEnum.xai]: "https://api.x.ai/v1"
+};
+/** Providers bundled with aikit as the baseline catalog, read until a generated one exists. */
+const BASELINE_PROVIDERS = [
+	"anthropic",
+	"openai",
+	PROVIDER_ID
+];
+function modelsDevURL() {
+	return process.env.CODEWORK_MODELS_DEV_URL || "https://models.dev";
+}
+function modelsDevPath() {
+	return process.env.CODEWORK_MODELS_DEV_FILE;
+}
+async function pullModelsDevData() {
+	const path = modelsDevPath();
+	if (path) {
+		const result = await readJson(path).catch(() => void 0);
+		if (result) return result;
+	}
+	const response = await fetch(`${modelsDevURL()}/api.json`);
+	if (!response.ok) throw new Error(`models.dev responded ${response.status} ${response.statusText}`);
+	return await response.json();
+}
+/** OpenRouter's public listing, or undefined when it cannot be had: models.dev's copy stands in. */
+async function pullOpenRouterData() {
+	try {
+		const response = await fetch(`${BASE_URL}/models`, { signal: AbortSignal.timeout(3e4) });
+		return response.ok ? await response.json() : void 0;
+	} catch {
+		return;
+	}
+}
+function toModelValue(providerId, provider, model) {
+	return applyModification(providerId, provider, model);
+}
+const MODELS_DEV_UNSUPPORTED_MODEL_IDS = /* @__PURE__ */ new Set(["openai/gpt-5.6"]);
+function usable(providerId, provider, model) {
+	return Boolean(model.tool_call) && !MODELS_DEV_UNSUPPORTED_MODEL_IDS.has(`${providerId}/${model.id}`) && isAISDKPackage(resolveModelNpm(provider, model));
+}
+function loadBuiltInFromModelsDev(catalog) {
+	return pipe(catalog, pickBy((provider, providerId) => Object.values(provider.models).some((model) => usable(providerId, provider, model))), mapValues((provider, providerId) => pipe(provider.models, pickBy((model) => usable(providerId, provider, model)), mapValues((model) => toModelValue(providerId, provider, model)), pickBy((model) => model !== void 0))));
+}
+function resolveModelNpm(provider, model) {
+	return model.provider?.npm ?? provider.npm ?? "@ai-sdk/openai-compatible";
+}
+function resolveModelBaseUrl(provider, model) {
+	const npm = resolveModelNpm(provider, model);
+	const protocol = protocolForPackage(npm);
+	return model.baseUrl ?? model.provider?.api ?? provider.api ?? DEFAULT_PROVIDER_BASE_URLS[protocol] ?? "";
+}
+function resolveModelAPIMethod(npm) {
+	const protocol = protocolForPackage(npm);
+	if (protocol === KnownProviderEnum.openai || protocol === KnownProviderEnum.xai) return APIMethodEnum.responses;
+	return APIMethodEnum.languageModel;
+}
+function resolveProviderOptionsKey(protocol) {
+	if (protocol === KnownProviderEnum.openaiCompatible) return "openai-compatible";
+	if (protocol === KnownProviderEnum.googleVertex) return "google-vertex";
+	if (protocol === KnownProviderEnum.googleVertexAnthropic) return "google-vertex-anthropic";
+	return protocol;
+}
+function roundCost(value) {
+	return Number(value.toFixed(6));
+}
+/** models.dev prices, with its context tiers; a rate a tier does not list keeps the base price (pi). */
+function modelsDevCost(cost) {
+	const base = {
+		input: cost?.input ?? 0,
+		output: cost?.output ?? 0,
+		cacheRead: cost?.cache_read ?? 0,
+		cacheWrite: cost?.cache_write ?? 0
+	};
+	const tiers = cost?.tiers?.flatMap((tier) => {
+		const context = tier.tier;
+		if (context?.type !== "context" || context.size === void 0) return [];
+		return [{
+			inputTokensAbove: context.size,
+			input: tier.input ?? base.input,
+			output: tier.output ?? base.output,
+			cacheRead: tier.cache_read ?? base.cacheRead,
+			cacheWrite: tier.cache_write ?? base.cacheWrite
+		}];
+	});
+	return tiers && tiers.length > 0 ? {
+		...base,
+		tiers
+	} : base;
+}
+/** The efforts models.dev verified for a model, or undefined when it lists none. */
+function modelsDevEfforts(model) {
+	const efforts = model?.reasoning_options?.flatMap((option) => option.type === "effort" && Array.isArray(option.values) ? option.values : []);
+	return efforts && efforts.length > 0 ? efforts : void 0;
+}
+function mergeThinkingLevelMap(model, map) {
+	model.thinkingLevelMap = {
+		...model.thinkingLevelMap,
+		...map
+	};
+}
+function mergeCompat(model, compat) {
+	model.compat = {
+		...model.compat,
+		...compat
+	};
+}
+/** Merge the level map models.dev's verified efforts give, when it lists any. */
+function applyEffortThinkingLevels(model, source) {
+	const efforts = modelsDevEfforts(source);
+	const map = efforts ? effortThinkingLevels(efforts) : void 0;
+	if (map) mergeThinkingLevelMap(model, map);
+}
+const OPENAI_LONG_CONTEXT_INPUT_THRESHOLD = 272e3;
+const OPENAI_MAX_TOKENS = 128e3;
+const OPENAI_RESPONSES_NONE_REASONING_MODELS = /* @__PURE__ */ new Set([
+	"gpt-5.1",
+	"gpt-5.2",
+	"gpt-5.3-codex",
+	"gpt-5.4",
+	"gpt-5.4-mini",
+	"gpt-5.4-nano",
+	"gpt-5.5",
+	"gpt-5.6-luna",
+	"gpt-5.6-sol",
+	"gpt-5.6-terra",
+	"gpt-6-luna",
+	"gpt-6-sol"
+]);
+const OPENAI_GPT6_MODELS = /* @__PURE__ */ new Set([
+	"gpt-6-astra",
+	"gpt-6-luna",
+	"gpt-6-sol",
+	"gpt-6.1-sol"
+]);
+const OPENAI_GPT6_NO_NONE_MODELS = /* @__PURE__ */ new Set(["gpt-6-astra", "gpt-6.1-sol"]);
+const OPENAI_NO_MINIMAL_REASONING = /gpt-5\.[456]|gpt-6/;
+const OPENAI_SHORT_CONTEXT_CAPPED_MODELS = /* @__PURE__ */ new Set([
+	"gpt-5.4",
+	"gpt-5.5",
+	"gpt-5.6-luna",
+	"gpt-5.6-sol",
+	"gpt-5.6-terra",
+	"gpt-6-astra",
+	"gpt-6-luna",
+	"gpt-6-sol",
+	"gpt-6.1-sol"
+]);
+const OPENAI_LONG_CONTEXT_PRICING_MODELS = /* @__PURE__ */ new Set([
+	...OPENAI_SHORT_CONTEXT_CAPPED_MODELS,
+	"gpt-5.4-pro",
+	"gpt-5.5-pro"
+]);
+function isOpenAiResponses(model) {
+	return model.protocol === KnownProviderEnum.openai || model.protocol === KnownProviderEnum.openaiCodex;
+}
+function isOpenAiDirect(model) {
+	return model.protocol === KnownProviderEnum.openai && model.provider.id === "openai";
+}
+function supportsOpenAiXhigh(model) {
+	return /gpt-5\.[2-6]|gpt-6/.test(model.id);
+}
+function supportsOpenAiMax(model) {
+	return isOpenAiResponses(model) && /gpt-5\.6|gpt-6/.test(model.id);
+}
+function withOpenAiLongContextPricing(cost) {
+	return {
+		...cost,
+		tiers: [{
+			inputTokensAbove: OPENAI_LONG_CONTEXT_INPUT_THRESHOLD,
+			input: roundCost(cost.input * 2),
+			output: roundCost(cost.output * 1.5),
+			cacheRead: roundCost(cost.cacheRead * 2),
+			cacheWrite: roundCost(cost.cacheWrite * 2)
+		}]
+	};
+}
+/**
+* Price multipliers per service tier: models.dev's modes that set `service_tier` (fast is
+* `priority`), over OpenAI's flex 0.5x / priority 2x list defaults.
+*/
+function serviceTierMultipliers(model, source) {
+	const multipliers = {
+		flex: .5,
+		priority: 2
+	};
+	for (const mode of Object.values(source?.experimental?.modes ?? {})) {
+		const tier = mode.provider?.body?.service_tier;
+		const input = mode.cost?.input;
+		if (typeof tier !== "string" || input === void 0 || model.cost.input <= 0) continue;
+		multipliers[tier] = roundCost(input / model.cost.input);
+	}
+	return multipliers;
+}
+function applyOpenAiMetadata(model, source) {
+	const id = model.id;
+	if (isOpenAiDirect(model)) {
+		if (OPENAI_SHORT_CONTEXT_CAPPED_MODELS.has(id)) {
+			model.contextWindow = OPENAI_LONG_CONTEXT_INPUT_THRESHOLD;
+			model.maxTokens = OPENAI_MAX_TOKENS;
+		}
+		if (OPENAI_LONG_CONTEXT_PRICING_MODELS.has(id) && !model.cost.tiers) model.cost = withOpenAiLongContextPricing(model.cost);
+		if (id === "gpt-5-pro") model.maxTokens = OPENAI_MAX_TOKENS;
+	}
+	model.cost.serviceTierMultipliers = serviceTierMultipliers(model, source);
+	applyEffortThinkingLevels(model, source);
+	if (model.protocol === KnownProviderEnum.openai && id.startsWith("gpt-5")) mergeThinkingLevelMap(model, { off: null });
+	if (OPENAI_GPT6_MODELS.has(id)) mergeThinkingLevelMap(model, {
+		off: OPENAI_GPT6_NO_NONE_MODELS.has(id) ? null : "none",
+		minimal: null,
+		low: "low",
+		medium: "medium",
+		high: "high",
+		xhigh: "xhigh",
+		max: "max"
+	});
+	if (isOpenAiDirect(model) && OPENAI_RESPONSES_NONE_REASONING_MODELS.has(id)) mergeThinkingLevelMap(model, { off: "none" });
+	if (supportsOpenAiMax(model)) mergeThinkingLevelMap(model, { max: "max" });
+	if (OPENAI_NO_MINIMAL_REASONING.test(id)) mergeThinkingLevelMap(model, { minimal: null });
+	if (id.endsWith("gpt-5.5-pro")) mergeThinkingLevelMap(model, {
+		off: null,
+		minimal: null,
+		low: null
+	});
+}
+function isAnthropicMessages(model) {
+	return model.protocol === KnownProviderEnum.anthropic || model.protocol === KnownProviderEnum.googleVertexAnthropic;
+}
+const ANTHROPIC_NO_TEMPERATURE = /opus-4[-.][78]|opus-5|(sonnet|haiku)-5[-.]5/;
+function applyAnthropicMetadata(model) {
+	const id = model.id;
+	if (/sonnet-4[-.]5/.test(id)) model.contextWindow = 2e5;
+	if (isAnthropicAdaptiveThinkingModel(id)) mergeCompat(model, { forceAdaptiveThinking: true });
+	if (/(opus|sonnet)-4[-.]6/.test(id)) mergeThinkingLevelMap(model, { max: "max" });
+	if (/opus-4[-.][78]|(opus|sonnet|fable|haiku)-5/.test(id)) mergeThinkingLevelMap(model, {
+		xhigh: "xhigh",
+		max: "max"
+	});
+	if (/(opus|sonnet|haiku)-5[-.]5/.test(id)) mergeThinkingLevelMap(model, {
+		...id.includes("haiku") ? {} : { off: null },
+		minimal: null,
+		low: "low",
+		medium: "medium",
+		high: "high",
+		xhigh: "xhigh",
+		max: "max"
+	});
+	if (/fable-5/.test(id)) mergeThinkingLevelMap(model, { off: null });
+	if (ANTHROPIC_NO_TEMPERATURE.test(id)) mergeCompat(model, { supportsTemperature: false });
+}
+function applyGoogleThinkingMetadata(model) {
+	const id = model.id.toLowerCase();
+	const supportsThinkingLevel = /gemini-3(?:\.\d+)?-(?:pro|flash)|gemma-?4/.test(id) || id === "gemini-flash-latest" || id === "gemini-flash-lite-latest";
+	mergeCompat(model, { supportsThinkingLevel });
+	if (supportsThinkingLevel) return;
+	model.thinkingBudgets = [
+		["2.5-pro", {
+			minimal: 128,
+			low: 2048,
+			medium: 8192,
+			high: 32768
+		}],
+		["2.5-flash-lite", {
+			minimal: 512,
+			low: 2048,
+			medium: 8192,
+			high: 24576
+		}],
+		["2.5-flash", {
+			minimal: 128,
+			low: 2048,
+			medium: 8192,
+			high: 24576
+		}]
+	].find(([family]) => id.includes(family))?.[1] ?? {
+		minimal: -1,
+		low: -1,
+		medium: -1,
+		high: -1
+	};
+}
+function applyModelMetadata(model, source) {
+	if (model.protocol === KnownProviderEnum.google || model.protocol === KnownProviderEnum.googleVertex) {
+		applyGoogleThinkingMetadata(model);
+		if (/gemini-3(?:\.\d+)?-pro|gemini-3\.[78]-flash/.test(model.id.toLowerCase())) mergeThinkingLevelMap(model, {
+			off: "low",
+			minimal: null
+		});
+	}
+	if (model.id.includes("opus-4-6") || model.id.includes("opus-4.6")) mergeThinkingLevelMap(model, { xhigh: "max" });
+	if (model.id.includes("opus-4-7") || model.id.includes("opus-4.7")) mergeThinkingLevelMap(model, { xhigh: "xhigh" });
+	if (isOpenAiResponses(model)) applyOpenAiMetadata(model, source);
+	if (supportsOpenAiXhigh(model)) mergeThinkingLevelMap(model, { xhigh: "xhigh" });
+	if (isAnthropicMessages(model)) applyAnthropicMetadata(model);
+}
+const OPENAI_CODEX_PROVIDER_ID = "openai-codex";
+const OPENAI_CODEX_NPM = "@codeworksh/ai-sdk-openai-codex";
+const OPENAI_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+const OPENAI_CODEX_CONTEXT = 272e3;
+const OPENAI_CODEX_MODELS = [
+	{
+		id: "gpt-5.3-codex-spark",
+		contextWindow: 128e3
+	},
+	{ id: "gpt-5.5" },
+	{ id: "gpt-5.6-luna" },
+	{ id: "gpt-5.6-sol" },
+	{ id: "gpt-5.6-terra" },
+	{ id: "gpt-6-astra" },
+	{ id: "gpt-6-luna" },
+	{ id: "gpt-6-sol" },
+	{
+		id: "gpt-6.1-sol",
+		contextWindow: 5e5
+	}
+];
+const OPENAI_CODEX_ADDITIONAL_TOOLS_MODEL_IDS = /* @__PURE__ */ new Set([
+	"gpt-5.6-luna",
+	"gpt-5.6-sol",
+	"gpt-5.6-terra",
+	"gpt-6-astra",
+	"gpt-6-luna",
+	"gpt-6-sol",
+	"gpt-6.1-sol"
+]);
+const OPENAI_CODEX_TOOL_SEARCH_MODEL_IDS = /* @__PURE__ */ new Set(["gpt-5.5", ...OPENAI_CODEX_ADDITIONAL_TOOLS_MODEL_IDS]);
+const OPENAI_CODEX_NONE_REASONING_MODEL_IDS = /* @__PURE__ */ new Set([
+	"gpt-5.5",
+	"gpt-5.6-luna",
+	"gpt-6-luna",
+	"gpt-6-sol"
+]);
+/** The Codex models, from the generated `openai` entries; one models.dev does not list is skipped. */
+function openAICodexBuiltInModels(openai) {
+	const models = {};
+	for (const seed of OPENAI_CODEX_MODELS) {
+		const base = openai[seed.id];
+		if (!base) continue;
+		const info = {
+			...base,
+			provider: {
+				id: OPENAI_CODEX_PROVIDER_ID,
+				name: "OpenAI Codex (ChatGPT)",
+				source: "custom",
+				env: ["OPENAI_CODEX_API_KEY"]
+			},
+			baseUrl: OPENAI_CODEX_BASE_URL,
+			reasoning: true,
+			thinkingLevelMap: {
+				...base.thinkingLevelMap,
+				off: OPENAI_CODEX_NONE_REASONING_MODEL_IDS.has(seed.id) ? "none" : null,
+				...supportsOpenAiXhigh(base) ? { minimal: "low" } : {}
+			},
+			contextWindow: seed.contextWindow ?? OPENAI_CODEX_CONTEXT,
+			maxTokens: OPENAI_MAX_TOKENS,
+			npm: OPENAI_CODEX_NPM,
+			api: {
+				id: seed.id,
+				url: OPENAI_CODEX_BASE_URL,
+				method: APIMethodEnum.responses
+			},
+			providerOptionsKey: OPENAI_CODEX_PROVIDER_ID,
+			compat: {
+				supportsOpenAIGrammarTools: true,
+				...OPENAI_CODEX_TOOL_SEARCH_MODEL_IDS.has(seed.id) ? { supportsToolSearch: true } : {},
+				...OPENAI_CODEX_ADDITIONAL_TOOLS_MODEL_IDS.has(seed.id) ? { supportsAdditionalTools: true } : {}
+			},
+			protocol: KnownProviderEnum.openaiCodex
+		};
+		delete info.headers;
+		models[seed.id] = info;
+	}
+	return models;
+}
+const GITHUB_COPILOT_PROVIDER_ID = "github-copilot";
+const GITHUB_COPILOT_NPM = "@codeworksh/ai-sdk-github-copilot";
+const GITHUB_COPILOT_BASE_URL = "https://api.githubcopilot.com";
+const GITHUB_COPILOT_EXTENDED_CONTEXT = 1e6;
+const GITHUB_COPILOT_EXTENDED_CONTEXT_MODELS = /* @__PURE__ */ new Set([
+	"claude-fable-5",
+	"claude-opus-4.6",
+	"claude-opus-4.7",
+	"claude-opus-4.8",
+	"claude-opus-5",
+	"claude-sonnet-4.6",
+	"claude-sonnet-5",
+	"gpt-5.3-codex",
+	"gpt-5.4",
+	"gpt-5.5"
+]);
+const GITHUB_COPILOT_THINKING_LEVEL_OVERRIDES = {
+	"claude-opus-4.7": { minimal: "low" },
+	"claude-opus-4.8": { minimal: "low" },
+	"claude-opus-5": { minimal: "low" },
+	"claude-sonnet-4.6": {
+		minimal: "low",
+		max: "max"
+	}
+};
+/**
+* The offline routing approximation (pi). The live `/models` response's
+* `supported_endpoints` is authoritative at runtime.
+*
+* - `claude-(haiku|sonnet|opus|fable)-[45]` → Anthropic Messages
+* - `gpt-*`, `grok-*`, `oswe*`, `mai-*` → OpenAI Responses
+* - everything else → OpenAI Chat Completions
+*/
+function githubCopilotApiMethod(modelId) {
+	if (/^claude-(haiku|sonnet|opus|fable)-[45]([.-]|$)/.test(modelId)) return APIMethodEnum.messages;
+	const gpt = /^gpt-(\d+)/.exec(modelId);
+	if (gpt !== null && Number(gpt[1]) >= 5 || modelId.startsWith("grok-") || modelId.startsWith("oswe") || modelId.startsWith("mai-")) return APIMethodEnum.responses;
+	return APIMethodEnum.chat;
+}
+/**
+* Derive the level map from models.dev `reasoning_options`: a level maps to
+* itself only when the endpoint actually advertises it. `minimal` degrades to
+* `low` — the lowest effort every reasoning model accepts.
+*/
+function githubCopilotThinkingLevels(model, method) {
+	const listed = modelsDevEfforts(model);
+	const efforts = listed ? new Set(listed) : void 0;
+	const map = {};
+	if (method !== APIMethodEnum.messages) map.off = null;
+	if (!efforts) return Object.keys(map).length > 0 ? map : void 0;
+	if (efforts.has("minimal")) map.minimal = "minimal";
+	else if (efforts.has("low")) map.minimal = "low";
+	for (const level of [
+		"low",
+		"medium",
+		"high",
+		"xhigh",
+		"max"
+	]) map[level] = efforts.has(level) ? level : null;
+	return map;
+}
+function githubCopilotBuiltInModels(provider) {
+	const models = {};
+	if (!provider) return models;
+	for (const [id, source] of Object.entries(provider.models)) {
+		if (source.tool_call !== true) continue;
+		if (source.status === "deprecated") continue;
+		if (id === "gpt-5-chat-latest") continue;
+		const base = applyModification(GITHUB_COPILOT_PROVIDER_ID, provider, source);
+		if (!base) continue;
+		const method = githubCopilotApiMethod(id);
+		const info = {
+			...base,
+			provider: {
+				id: GITHUB_COPILOT_PROVIDER_ID,
+				name: "GitHub Copilot",
+				source: "custom",
+				env: ["COPILOT_GITHUB_TOKEN"]
+			},
+			baseUrl: GITHUB_COPILOT_BASE_URL,
+			headers: { ...GITHUB_COPILOT_STATIC_HEADERS },
+			npm: GITHUB_COPILOT_NPM,
+			api: {
+				id,
+				url: GITHUB_COPILOT_BASE_URL,
+				method
+			},
+			providerOptionsKey: GITHUB_COPILOT_PROVIDER_ID,
+			protocol: KnownProviderEnum.githubCopilot,
+			...method === APIMethodEnum.responses ? { providerOptions: {
+				...base.providerOptions,
+				[GITHUB_COPILOT_PROVIDER_ID]: {
+					store: false,
+					include: ["reasoning.encrypted_content"]
+				}
+			} } : {}
+		};
+		if (GITHUB_COPILOT_EXTENDED_CONTEXT_MODELS.has(id)) info.contextWindow = GITHUB_COPILOT_EXTENDED_CONTEXT;
+		if (method === APIMethodEnum.messages && isAnthropicAdaptiveThinkingModel(id)) mergeCompat(info, { forceAdaptiveThinking: true });
+		const gpt = /^gpt-(\d+)/.exec(id);
+		if (method === APIMethodEnum.responses && gpt !== null && Number(gpt[1]) >= 5) mergeCompat(info, { supportsOpenAIGrammarTools: true });
+		if (id.startsWith("gpt-5")) mergeThinkingLevelMap(info, {
+			off: null,
+			minimal: "low"
+		});
+		if (id.includes("fable-5")) mergeThinkingLevelMap(info, {
+			off: null,
+			xhigh: "xhigh",
+			max: "max"
+		});
+		const levels = githubCopilotThinkingLevels(source, method);
+		if (levels) mergeThinkingLevelMap(info, levels);
+		const override = GITHUB_COPILOT_THINKING_LEVEL_OVERRIDES[id];
+		if (override) mergeThinkingLevelMap(info, override);
+		models[id] = info;
+	}
+	return models;
+}
+/** OpenRouter's listing as catalog entries, or undefined when it is missing or unreadable. */
+function openRouterModels(listing) {
+	if (listing === void 0) return void 0;
+	try {
+		const models = catalog(listing);
+		return Object.keys(models).length > 0 ? models : void 0;
+	} catch {
+		return;
+	}
+}
+/** Object keys in order at every level, so identical content serializes to identical bytes. */
+function sortKeys(value) {
+	if (Array.isArray(value)) return value.map(sortKeys);
+	if (typeof value !== "object" || value === null) return value;
+	return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, entry]) => [key, sortKeys(entry)]));
+}
+/**
+* The catalog from fetched sources, keys sorted so identical content serializes to identical
+* bytes. OpenRouter's own listing replaces models.dev's copy of it.
+*/
+function buildCatalog(sources) {
+	const modelsDev = loadBuiltInFromModelsDev(sources.modelsDev);
+	const openrouter = openRouterModels(sources.openRouter);
+	const copilotProvider = sources.modelsDev[GITHUB_COPILOT_PROVIDER_ID];
+	return sortKeys({
+		...modelsDev,
+		...openrouter ? { [PROVIDER_ID]: openrouter } : {},
+		[OPENAI_CODEX_PROVIDER_ID]: openAICodexBuiltInModels(modelsDev.openai ?? {}),
+		...copilotProvider ? { [GITHUB_COPILOT_PROVIDER_ID]: githubCopilotBuiltInModels(copilotProvider) } : {}
+	});
+}
+async function generateModels(args = {}) {
+	const path$1 = resolve(args.path ?? path());
+	const [modelsDev, openRouter] = await Promise.all([pullModelsDevData(), pullOpenRouterData()]);
+	const catalog = buildCatalog({
+		modelsDev,
+		openRouter
+	});
+	await writeJsonAtomic(path$1, args.baseline ? pick(catalog, BASELINE_PROVIDERS) : catalog);
+	return path$1;
+}
+const ModelgenCommand = {
+	command: "modelgen [path]",
+	describe: "generate models.gen.json",
+	builder: (yargs) => yargs.positional("path", {
+		type: "string",
+		describe: "output path (defaults to CODEWORK_MODELS_FILE or ./models.gen.json)"
+	}).option("baseline", {
+		type: "boolean",
+		describe: `keep only the bundled baseline providers (${BASELINE_PROVIDERS.join(", ")})`
+	}),
+	handler: async (args) => {
+		const path = await generateModels(args);
+		console.log(`Generated model catalog at ${path}`);
+	}
+};
+function applyModification(providerId, provider, model) {
+	const npm = resolveModelNpm(provider, model);
+	if (!isAISDKPackage(npm)) return;
+	const protocol = protocolForPackage(npm);
+	const baseUrl = resolveModelBaseUrl(provider, model);
+	const providerInfo = {
+		id: providerId,
+		name: provider.name,
+		source: "api",
+		env: provider.env
+	};
+	if (provider.key) providerInfo.key = provider.key;
+	const api = {
+		id: model.id,
+		method: resolveModelAPIMethod(npm)
+	};
+	if (baseUrl) api.url = baseUrl;
+	const info = {
+		id: model.id,
+		name: model.name,
+		provider: providerInfo,
+		baseUrl,
+		reasoning: Boolean(model.reasoning),
+		input: normalizeInput(model.modalities.input),
+		cost: modelsDevCost(model.cost),
+		contextWindow: model.limit?.context ?? 4096,
+		maxTokens: model.limit?.output ?? 4096,
+		headers: {
+			...provider.headers,
+			...model.provider?.headers,
+			...model.headers
+		},
+		npm,
+		api,
+		providerOptionsKey: resolveProviderOptionsKey(protocol),
+		protocol
+	};
+	if (Object.keys(info.headers ?? {}).length === 0) delete info.headers;
+	applyModelMetadata(info, model);
+	return info;
+}
+//#endregion
+export { personalize as i, generateModels as n, PROVIDER_ID as r, ModelgenCommand as t };
+
+//# sourceMappingURL=modelgen-DDO_NHoQ.mjs.map