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

package/model-Cjp-Dr8V.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-Cjp-Dr8V.mjs","names":["dirname","KnownProviderEnum","KnownProviderEnumSchema","Type","ModelCatalogLoadError","bundled","Filesystem.readText","ModelCatalog.KnownProviderEnum","ModelCatalog.KnownProviderEnumSchema","ModelCatalog.ModelCatalogLoadError","Type","ModelCatalog.path","ModelCatalog.get"],"sources":["../../src/utils/lazy.ts","../../src/utils/error.ts","../../src/utils/filesystem.ts","../../src/model/baseline.json","../../src/model/catalog.ts","../../src/model/model.ts"],"sourcesContent":["export function lazy<T>(fn: () => T) {\n\tlet value: T | undefined;\n\tlet loaded = false;\n\n\tconst result = (): T => {\n\t\tif (loaded) return value as T;\n\t\tvalue = fn();\n\t\tloaded = true;\n\t\treturn value as T;\n\t};\n\n\tresult.reset = () => {\n\t\tloaded = false;\n\t\tvalue = undefined;\n\t};\n\n\treturn result;\n}\n","import type { Static, TSchema } from \"typebox\";\n\ntype SchemaLike = TSchema;\ntype StaticData<Data extends SchemaLike> = Static<Data>;\n\nexport abstract class NamedError extends Error {\n\tabstract schema(): SchemaLike;\n\tabstract toObject(): { name: string; data: unknown };\n\n\tstatic create<Name extends string, Data extends SchemaLike>(name: Name, data: Data) {\n\t\tconst schema = {\n\t\t\t$id: name,\n\t\t\ttype: \"object\",\n\t\t\trequired: [\"name\", \"data\"],\n\t\t\tproperties: {\n\t\t\t\tname: {\n\t\t\t\t\tconst: name,\n\t\t\t\t},\n\t\t\t\tdata,\n\t\t\t},\n\t\t} as const;\n\n\t\tconst result = class extends NamedError {\n\t\t\tpublic static readonly Schema = schema;\n\n\t\t\tpublic override readonly name = name as Name;\n\n\t\t\tpublic readonly data: StaticData<Data>;\n\n\t\t\tconstructor(data: StaticData<Data>, options?: ErrorOptions) {\n\t\t\t\tsuper(name, options);\n\t\t\t\tthis.data = data;\n\t\t\t\tthis.name = name;\n\t\t\t}\n\n\t\t\tstatic isInstance(input: unknown): input is InstanceType<typeof result> {\n\t\t\t\treturn typeof input === \"object\" && input !== null && \"name\" in input && input.name === name;\n\t\t\t}\n\n\t\t\tschema() {\n\t\t\t\treturn schema;\n\t\t\t}\n\n\t\t\ttoObject() {\n\t\t\t\treturn {\n\t\t\t\t\tname,\n\t\t\t\t\tdata: this.data,\n\t\t\t\t};\n\t\t\t}\n\t\t};\n\n\t\tObject.defineProperty(result, \"name\", { value: name });\n\t\treturn result;\n\t}\n\n\tpublic static readonly Unknown = NamedError.create(\"UnknownError\", {\n\t\ttype: \"object\",\n\t\trequired: [\"message\"],\n\t\tproperties: {\n\t\t\tmessage: {\n\t\t\t\ttype: \"string\",\n\t\t\t},\n\t\t},\n\t});\n}\n","import { mkdir, readFile, rename, rm, writeFile } from \"fs/promises\";\nimport { dirname } from \"path\";\n\nexport async function readText(path: string): Promise<string> {\n\treturn readFile(path, \"utf-8\");\n}\n\nexport async function readJson<T = unknown>(path: string): Promise<T> {\n\treturn JSON.parse(await readFile(path, \"utf-8\"));\n}\n\nfunction isEnoent(error: unknown): error is { code: \"ENOENT\" } {\n\treturn (\n\t\ttypeof error === \"object\" && error !== null && \"code\" in error && (error as { code: string }).code === \"ENOENT\"\n\t);\n}\n\nexport async function write(path: string, content: string | Buffer | Uint8Array, mode?: number): Promise<void> {\n\ttry {\n\t\tif (mode) {\n\t\t\tawait writeFile(path, content, { mode });\n\t\t} else {\n\t\t\tawait writeFile(path, content);\n\t\t}\n\t} catch (error) {\n\t\tif (isEnoent(error)) {\n\t\t\tawait mkdir(dirname(path), { recursive: true });\n\t\t\tif (mode) {\n\t\t\t\tawait writeFile(path, content, { mode });\n\t\t\t} else {\n\t\t\t\tawait writeFile(path, content);\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\t\tthrow error;\n\t}\n}\n\nexport async function writeJson(path: string, data: unknown, mode?: number): Promise<void> {\n\treturn write(path, JSON.stringify(data, null, 2), mode);\n}\n\n/**\n * Write through a temp file and rename it into place, so a concurrent reader\n * sees either the old content or the new, never a partial file.\n */\nexport async function writeAtomic(path: string, content: string | Buffer | Uint8Array): Promise<void> {\n\tconst temp = `${path}.${process.pid}.${Date.now()}.tmp`;\n\ttry {\n\t\tawait write(temp, content);\n\t\tawait rename(temp, path);\n\t} catch (error) {\n\t\tawait rm(temp, { force: true });\n\t\tthrow error;\n\t}\n}\n\nexport async function writeJsonAtomic(path: string, data: unknown): Promise<void> {\n\treturn writeAtomic(path, JSON.stringify(data, null, 2));\n}\n","","import { join, resolve } from \"node:path\";\nimport Type, { type Static } from \"typebox\";\nimport { NamedError } from \"../utils/error.ts\";\nimport * as Filesystem from \"../utils/filesystem.ts\";\nimport { lazy } from \"../utils/lazy.ts\";\nimport bundled from \"./baseline.json\" with { type: \"json\" };\n\n// known AI SDK LLM providers\n// used as the public protocol discriminator for the AI SDK transport layer\nexport const KnownProviderEnum = {\n\tanthropic: \"anthropic\",\n\tgoogle: \"google\",\n\tgoogleVertex: \"google-vertex\",\n\tgoogleVertexAnthropic: \"google-vertex-anthropic\",\n\tgithubCopilot: \"github-copilot\",\n\topenai: \"openai\",\n\topenaiCompatible: \"openai-compatible\",\n\topenaiCodex: \"openai-codex\",\n\topenrouter: \"openrouter\",\n\txai: \"xai\",\n} as const;\nexport const KnownProviderEnumSchema = Type.Union([\n\tType.Literal(KnownProviderEnum.anthropic),\n\tType.Literal(KnownProviderEnum.google),\n\tType.Literal(KnownProviderEnum.googleVertex),\n\tType.Literal(KnownProviderEnum.googleVertexAnthropic),\n\tType.Literal(KnownProviderEnum.githubCopilot),\n\tType.Literal(KnownProviderEnum.openai),\n\tType.Literal(KnownProviderEnum.openaiCompatible),\n\tType.Literal(KnownProviderEnum.openaiCodex),\n\tType.Literal(KnownProviderEnum.openrouter),\n\tType.Literal(KnownProviderEnum.xai),\n]);\nexport type KnownProviderEnum = Static<typeof KnownProviderEnumSchema>;\n\nexport type GeneratedCatalog = Partial<Record<string, Record<string, unknown>>>;\ntype LazyGeneratedCatalog = ReturnType<typeof lazy<Promise<GeneratedCatalog>>>;\n\nexport const ModelCatalogLoadError = NamedError.create(\n\t\"ModelCatalogLoadError\",\n\tType.Object({\n\t\tpath: Type.String(),\n\t\treason: Type.Union([Type.Literal(\"unreadable\"), Type.Literal(\"empty\"), Type.Literal(\"invalid\")]),\n\t\tmessage: Type.String(),\n\t}),\n);\nexport type ModelCatalogLoadError = InstanceType<typeof ModelCatalogLoadError>;\n\nexport function projectRoot(): string {\n\treturn process.cwd();\n}\n\nexport const filename = \"models.gen.json\";\n\nlet configured: string | undefined;\n\n/**\n * Read the catalog from `catalogPath` instead of `./models.gen.json`, for an\n * embedder that keeps it elsewhere. `CODEWORK_MODELS_FILE` still wins.\n */\nexport function configure(catalogPath: string): void {\n\tconfigured = resolve(catalogPath);\n\tdata.reset();\n}\n\nexport function path(): string {\n\treturn resolve(process.env.CODEWORK_MODELS_FILE ?? configured ?? join(projectRoot(), filename));\n}\n\n/**\n * The catalog bundled with aikit for OpenAI, Anthropic and OpenRouter (`aikit modelgen --baseline`),\n * so a first run works before any catalog was generated.\n */\nexport const baseline: GeneratedCatalog = bundled;\n\n/**\n * The catalog at `catalogPath` over the {@link baseline}: a provider the file lists replaces the\n * bundled one, so a fresh generated catalog wins and an older one still gets the bundled providers.\n * A missing file reads as the baseline alone.\n */\nexport async function load(catalogPath = path()): Promise<GeneratedCatalog> {\n\tlet content: string;\n\ttry {\n\t\tcontent = await Filesystem.readText(catalogPath);\n\t} catch (cause) {\n\t\tconst value =\n\t\t\ttypeof cause === \"object\" && cause !== null && \"code\" in cause && typeof cause.code === \"string\"\n\t\t\t\t? cause.code\n\t\t\t\t: undefined;\n\t\tif (value === \"ENOENT\") return { ...baseline };\n\t\tthrow new ModelCatalogLoadError(\n\t\t\t{ path: catalogPath, reason: \"unreadable\", message: `model catalog could not be read at ${catalogPath}` },\n\t\t\t{ cause },\n\t\t);\n\t}\n\tif (!content.trim()) {\n\t\tthrow new ModelCatalogLoadError({\n\t\t\tpath: catalogPath,\n\t\t\treason: \"empty\",\n\t\t\tmessage: `model catalog is empty at ${catalogPath}`,\n\t\t});\n\t}\n\ttry {\n\t\tconst parsed: unknown = JSON.parse(content);\n\t\tif (typeof parsed !== \"object\" || parsed === null || Array.isArray(parsed)) throw new Error(\"expected an object\");\n\t\treturn { ...baseline, ...(parsed as GeneratedCatalog) };\n\t} catch (cause) {\n\t\tthrow new ModelCatalogLoadError(\n\t\t\t{\n\t\t\t\tpath: catalogPath,\n\t\t\t\treason: \"invalid\",\n\t\t\t\tmessage: `model catalog contains invalid json at ${catalogPath}`,\n\t\t\t},\n\t\t\t{ cause },\n\t\t);\n\t}\n}\n\nexport const data: LazyGeneratedCatalog = lazy(() => load());\n\nexport async function get(): Promise<GeneratedCatalog> {\n\treturn data();\n}\n","import Type, { type Static } from \"typebox\";\nimport { lazy } from \"../utils/lazy.ts\";\nimport * as ModelCatalog from \"./catalog.ts\";\n\n// re-export\nexport const KnownProviderEnum = ModelCatalog.KnownProviderEnum;\nexport const KnownProviderEnumSchema = ModelCatalog.KnownProviderEnumSchema;\nexport type KnownProviderEnum = ModelCatalog.KnownProviderEnum;\n\nexport const ModelCatalogLoadError = ModelCatalog.ModelCatalogLoadError;\nexport type ModelCatalogLoadError = ModelCatalog.ModelCatalogLoadError;\n\n// Common reasoning-effort levels used by adapters that expose model reasoning,\n// thinking, or deliberation controls. Protocol-specific layers can map these\n// values to native fields like OpenAI `reasoning_effort`, Anthropic `thinking`,\n// or Gemini `thinkingConfig`.\nexport const ThinkingLevelEnum = {\n\t// Disable explicit reasoning controls when the provider supports turning them off.\n\toff: \"off\",\n\t// Smallest reasoning budget/effort above off; useful for fastest low-cost responses.\n\tminimal: \"minimal\",\n\t// Light reasoning for simple tasks that still benefit from some deliberation.\n\tlow: \"low\",\n\t// Balanced default for general tasks.\n\tmedium: \"medium\",\n\t// Higher reasoning effort for complex coding, analysis, or planning.\n\thigh: \"high\",\n\t// Extra-high reasoning effort for difficult tasks when supported by the model.\n\txhigh: \"xhigh\",\n\t// Maximum provider-defined effort above xhigh when explicitly supported by the model.\n\tmax: \"max\",\n} as const;\n\nexport const ThinkingLevel = Type.Union([\n\tType.Literal(ThinkingLevelEnum.off),\n\tType.Literal(ThinkingLevelEnum.minimal),\n\tType.Literal(ThinkingLevelEnum.low),\n\tType.Literal(ThinkingLevelEnum.medium),\n\tType.Literal(ThinkingLevelEnum.high),\n\tType.Literal(ThinkingLevelEnum.xhigh),\n\tType.Literal(ThinkingLevelEnum.max),\n]);\nexport type ThinkingLevel = Static<typeof ThinkingLevel>;\n\nexport const ActiveThinkingLevel = Type.Union([\n\tType.Literal(ThinkingLevelEnum.minimal),\n\tType.Literal(ThinkingLevelEnum.low),\n\tType.Literal(ThinkingLevelEnum.medium),\n\tType.Literal(ThinkingLevelEnum.high),\n\tType.Literal(ThinkingLevelEnum.xhigh),\n\tType.Literal(ThinkingLevelEnum.max),\n]);\nexport type ActiveThinkingLevel = Static<typeof ActiveThinkingLevel>;\n\nexport const ThinkingBudgets = Type.Partial(Type.Record(ActiveThinkingLevel, Type.Number()));\nexport type ThinkingBudgets = Static<typeof ThinkingBudgets>;\n\n// Note: order of entries matters!\nconst ACTIVE_THINKING_LEVELS = [\n\tThinkingLevelEnum.minimal,\n\tThinkingLevelEnum.low,\n\tThinkingLevelEnum.medium,\n\tThinkingLevelEnum.high,\n\tThinkingLevelEnum.xhigh,\n\tThinkingLevelEnum.max,\n] as const satisfies readonly ActiveThinkingLevel[];\nconst MODEL_THINKING_LEVELS = [\n\tThinkingLevelEnum.off,\n\t...ACTIVE_THINKING_LEVELS,\n] as const satisfies readonly ThinkingLevel[];\n\nexport const ProviderInfo = Type.Object({\n\tid: Type.String(),\n\tname: Type.String(),\n\tsource: Type.Enum([\"env\", \"config\", \"custom\", \"api\", \"unknown\"]),\n\tenv: Type.Array(Type.String()),\n\tkey: Type.Optional(Type.String()), // runtime api/oauth key\n\toptions: Type.Optional(Type.Record(Type.String(), Type.Any())),\n});\nexport type ProviderInfo = Static<typeof ProviderInfo>;\n\nconst InputSchema = Type.Array(Type.Union([Type.Literal(\"text\"), Type.Literal(\"image\")]));\nconst CostRatesSchema = Type.Object({\n\tinput: Type.Number(),\n\toutput: Type.Number(),\n\tcacheRead: Type.Number(),\n\tcacheWrite: Type.Number(),\n});\nconst CostTierSchema = Type.Object({\n\t...CostRatesSchema.properties,\n\tinputTokensAbove: Type.Number(),\n});\nconst CostSchema = Type.Object({\n\t...CostRatesSchema.properties,\n\ttiers: Type.Optional(Type.Array(CostTierSchema)),\n\tserviceTierMultipliers: Type.Optional(Type.Record(Type.String(), Type.Number())),\n});\nconst SupportedProtocolsSchema = Type.Partial(\n\tType.Object({\n\t\tanthropic: KnownProviderEnumSchema,\n\t\tgoogle: KnownProviderEnumSchema,\n\t\tgoogleVertex: KnownProviderEnumSchema,\n\t\tgoogleVertexAnthropic: KnownProviderEnumSchema,\n\t\tgithubCopilot: KnownProviderEnumSchema,\n\t\topenai: KnownProviderEnumSchema,\n\t\topenaiCompatible: KnownProviderEnumSchema,\n\t\topenaiCodex: KnownProviderEnumSchema,\n\t\topenrouter: KnownProviderEnumSchema,\n\t\txai: KnownProviderEnumSchema,\n\t}),\n);\n\nexport const APIMethodEnum = {\n\tlanguageModel: \"languageModel\",\n\tchat: \"chat\",\n\tcompletion: \"completion\",\n\tcompletionModel: \"completionModel\",\n\tmessages: \"messages\",\n\tresponses: \"responses\",\n} as const;\nexport const APIMethodEnumSchema = Type.Union([\n\tType.Literal(APIMethodEnum.languageModel),\n\tType.Literal(APIMethodEnum.chat),\n\tType.Literal(APIMethodEnum.completion),\n\tType.Literal(APIMethodEnum.completionModel),\n\tType.Literal(APIMethodEnum.messages),\n\tType.Literal(APIMethodEnum.responses),\n]);\nexport type APIMethodEnum = Static<typeof APIMethodEnumSchema>;\n\nexport const APIMetadataSchema = Type.Object({\n\tid: Type.Optional(Type.String()),\n\turl: Type.Optional(Type.String()),\n\tmethod: Type.Optional(APIMethodEnumSchema),\n});\nexport type APIMetadata = Static<typeof APIMetadataSchema>;\n\nexport const ThinkingLevelMapSchema = Type.Partial(\n\tType.Record(\n\t\tThinkingLevel, // Safe key validation\n\t\tType.Union([Type.String(), Type.Null()]), // Allowed values\n\t),\n);\nexport type ThinkingLevelMap = Static<typeof ThinkingLevelMapSchema>;\n\n/**\n * The level map for a model that lists the reasoning efforts it accepts (models.dev\n * `reasoning_options`, OpenRouter `supported_efforts`): a level maps to itself only when listed,\n * and off maps to `none` only when `none` is listed (pi). Undefined when nothing usable is listed.\n */\nexport function effortThinkingLevels(efforts: ReadonlyArray<string | null>): ThinkingLevelMap | undefined {\n\tconst supported = new Set(efforts);\n\tif (!ACTIVE_THINKING_LEVELS.some((level) => supported.has(level)) && !supported.has(\"none\")) return undefined;\n\tconst map: ThinkingLevelMap = { off: supported.has(\"none\") ? \"none\" : null };\n\tfor (const level of ACTIVE_THINKING_LEVELS) map[level] = supported.has(level) ? level : null;\n\treturn map;\n}\n\nexport const CompatibilitySchema = Type.Object({\n\t/** The Google protocol accepts thinking levels rather than a token budget. */\n\tsupportsThinkingLevel: Type.Optional(Type.Boolean()),\n\tsupportsToolSearch: Type.Optional(Type.Boolean()),\n\tsupportsAdditionalTools: Type.Optional(Type.Boolean()),\n\tsupportsStrictMode: Type.Optional(Type.Boolean()),\n\tsupportsOpenAIGrammarTools: Type.Optional(Type.Boolean()),\n\t/** The model takes a thinking-token budget as a top-level request field. */\n\tsupportsThinkingTokenBudget: Type.Optional(Type.Boolean()),\n\t/** Claude model that sizes its own thinking, driven by `effort` instead of a token budget. */\n\tforceAdaptiveThinking: Type.Optional(Type.Boolean()),\n\t/** False for a model that rejects a `temperature` field; the request then leaves it out. */\n\tsupportsTemperature: Type.Optional(Type.Boolean()),\n\t/** Name of that field, when it is not the conventional `thinking_token_budget`. */\n\tthinkingTokenBudgetField: Type.Optional(Type.String()),\n});\nexport type Compatibility = Static<typeof CompatibilitySchema>;\n\n/**\n * Claude models that decide their own thinking depth.\n *\n * These take an `effort` level and let the model size each turn's reasoning; the\n * older models take a fixed `budget_tokens` instead. Sending a budget to an\n * adaptive model pins it to one depth for every turn, which is the thing adaptive\n * thinking exists to avoid.\n */\nexport function isAnthropicAdaptiveThinkingModel(modelId: string): boolean {\n\treturn [\n\t\t\"opus-4-6\",\n\t\t\"opus-4.6\",\n\t\t\"opus-4-7\",\n\t\t\"opus-4.7\",\n\t\t\"opus-4-8\",\n\t\t\"opus-4.8\",\n\t\t\"opus-5\",\n\t\t\"opus.5\",\n\t\t\"sonnet-4-6\",\n\t\t\"sonnet-4.6\",\n\t\t\"sonnet-5\",\n\t\t\"sonnet.5\",\n\t\t\"fable-5\",\n\t\t\"haiku-5\",\n\t\t\"haiku.5\",\n\t].some((needle) => modelId.includes(needle));\n}\n\nexport const Schema = Type.Object({\n\tid: Type.String(),\n\tname: Type.String(),\n\tprovider: ProviderInfo,\n\tbaseUrl: Type.String(),\n\treasoning: Type.Boolean(),\n\tthinkingLevelMap: Type.Optional(ThinkingLevelMapSchema),\n\t/** Default budgets; request-level thinkingBudgets take precedence. */\n\tthinkingBudgets: Type.Optional(ThinkingBudgets),\n\tinput: InputSchema,\n\tcost: CostSchema,\n\tcontextWindow: Type.Number(),\n\tmaxTokens: Type.Number(),\n\theaders: Type.Optional(Type.Record(Type.String(), Type.String())),\n\tnpm: Type.Optional(Type.String()),\n\tapi: Type.Optional(APIMetadataSchema),\n\tproviderOptionsKey: Type.Optional(Type.String()),\n\toptions: Type.Optional(Type.Record(Type.String(), Type.Unknown())),\n\tproviderOptions: Type.Optional(Type.Record(Type.String(), Type.Unknown())),\n\tcompat: Type.Optional(CompatibilitySchema),\n\tprotocol: KnownProviderEnumSchema, // provider as the underlying protocol\n\tsupportedProtocols: Type.Optional(SupportedProtocolsSchema), // provider as the underlying supported protocols\n});\n\nexport const ExtrasSchema = Type.Object({});\n\nexport const Info = Type.Evaluate(Type.Intersect([Schema, ExtrasSchema]));\nexport type Info = Static<typeof Info>;\nexport type TModel<TProtocol extends KnownProviderEnum> = Omit<Info, \"protocol\"> & { protocol: TProtocol };\n\nexport function calculateCost(\n\tmodel: Info,\n\tusage: {\n\t\tinput: number;\n\t\toutput: number;\n\t\tcacheRead: number;\n\t\tcacheWrite: number;\n\t\tcacheWrite1h?: number;\n\t\tcost: {\n\t\t\tinput: number;\n\t\t\toutput: number;\n\t\t\tcacheRead: number;\n\t\t\tcacheWrite: number;\n\t\t\ttotal: number;\n\t\t};\n\t},\n): void {\n\tconst inputTokens = usage.input + usage.cacheRead + usage.cacheWrite;\n\tlet rates = model.cost;\n\tlet matchedThreshold = -1;\n\tfor (const tier of model.cost.tiers ?? []) {\n\t\tif (inputTokens > tier.inputTokensAbove && tier.inputTokensAbove > matchedThreshold) {\n\t\t\trates = tier;\n\t\t\tmatchedThreshold = tier.inputTokensAbove;\n\t\t}\n\t}\n\n\t// Anthropic charges 2x base input for 1h cache writes; `cost.cacheWrite` is the 5m rate.\n\tconst longWrite = usage.cacheWrite1h ?? 0;\n\tconst shortWrite = usage.cacheWrite - longWrite;\n\n\tusage.cost.input = (usage.input / 1_000_000) * rates.input;\n\tusage.cost.output = (usage.output / 1_000_000) * rates.output;\n\tusage.cost.cacheRead = (usage.cacheRead / 1_000_000) * rates.cacheRead;\n\tusage.cost.cacheWrite = (rates.cacheWrite * shortWrite + rates.input * 2 * longWrite) / 1_000_000;\n\tusage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;\n}\n\nexport type BuiltInModels = Partial<Record<string, Record<string, Info>>>;\n\nexport function normalizeInput(input?: string[]): Array<\"text\" | \"image\"> {\n\tconst normalized = new Set<\"text\" | \"image\">();\n\tfor (const modality of input ?? [\"text\"]) {\n\t\tif (modality === \"text\" || modality === \"image\") {\n\t\t\tnormalized.add(modality);\n\t\t}\n\t}\n\tif (normalized.size === 0) normalized.add(\"text\");\n\treturn [...normalized];\n}\n\n/** Where the catalog is read from: `CODEWORK_MODELS_FILE`, the configured path, or `./models.gen.json`. */\nexport const catalogPath = ModelCatalog.path;\n\n/** Read the catalog from `path` from now on, dropping whatever was already loaded. */\nexport function configureCatalog(path: string): void {\n\tModelCatalog.configure(path);\n\tregistry.reset();\n}\n\n/** Drop the loaded catalog, so the next lookup re-reads the file -- after it was regenerated. */\nexport function reloadCatalog(): void {\n\tModelCatalog.data.reset();\n\tregistry.reset();\n}\n\nexport async function getBuiltInModels(): Promise<BuiltInModels> {\n\treturn (await ModelCatalog.get()) as BuiltInModels;\n}\n\nexport const registry = lazy(async () => {\n\tconst registry: Map<string, Map<string, Info>> = new Map();\n\tconst models = await getBuiltInModels();\n\tfor (const [provider, value] of Object.entries(models) as Array<[string, Record<string, Info>]>) {\n\t\tconst providerModels = new Map<string, Info>();\n\t\tfor (const [id, model] of Object.entries(value)) {\n\t\t\tproviderModels.set(id, model);\n\t\t}\n\t\tregistry.set(provider, providerModels);\n\t}\n\treturn registry;\n});\n\n/**\n * The key a provider's own option bag is filed under.\n *\n * Providers that speak another provider's protocol still carry their own option\n * namespace, so this is not always the protocol.\n */\n/**\n * The request-body field a model takes its thinking-token budget in, if any.\n *\n * OpenAI-compatible endpoints have no standard place for this, so each one names\n * its own field; a bare `supportsThinkingTokenBudget` means the conventional name.\n */\nexport function thinkingTokenBudgetField(model: Info): string | undefined {\n\tif (model.compat?.thinkingTokenBudgetField) return model.compat.thinkingTokenBudgetField;\n\treturn model.compat?.supportsThinkingTokenBudget ? \"thinking_token_budget\" : undefined;\n}\n\nexport function optionsKey(model: Info): string {\n\treturn model.providerOptionsKey ?? model.protocol;\n}\n\nexport function supportsProtocol(model: Info, protocol: KnownProviderEnum): boolean {\n\tif (model.protocol === protocol) return true;\n\treturn Object.values(model.supportedProtocols ?? {}).includes(protocol);\n}\n\nexport type ProviderToProtocol<TProvider extends string> = TProvider extends KnownProviderEnum\n\t? TProvider\n\t: KnownProviderEnum;\n\nexport async function getModel<\n\tTProvider extends string,\n\tTProtocol extends KnownProviderEnum = ProviderToProtocol<TProvider>,\n>(\n\tprovider: TProvider,\n\tmodel: string,\n\toverrides?: Partial<Info> & { protocol?: TProtocol },\n): Promise<TModel<TProtocol> | undefined> {\n\tconst data = await registry();\n\tconst providerModels = data.get(provider);\n\tconst result = providerModels?.get(model);\n\tif (result && overrides) {\n\t\tif (overrides.protocol && !supportsProtocol(result, overrides.protocol)) {\n\t\t\treturn undefined;\n\t\t}\n\t\treturn {\n\t\t\t...result,\n\t\t\t...overrides,\n\t\t} as TModel<TProtocol>;\n\t}\n\treturn result as TModel<TProtocol> | undefined;\n}\n\nexport async function getProviders(): Promise<string[]> {\n\tconst data = await registry();\n\treturn Array.from(data.keys());\n}\n\nexport async function getModels<TProvider extends string>(provider: TProvider): Promise<Info[]> {\n\tconst data = await registry();\n\tconst models = data.get(provider);\n\treturn models ? Array.from(models.values()) : [];\n}\n\n/**\n * Check if two models are equal by comparing both their id and provider id.\n * Returns false if either model is null or undefined.\n */\nexport function modelsAreEqual(a: Info | null | undefined, b: Info | null | undefined): boolean {\n\tif (!a || !b) return false;\n\treturn a.id === b.id && a.provider.id === b.provider.id;\n}\n\nexport function getSupportedThinkingLevels<TProtocol extends KnownProviderEnum>(\n\tmodel: TModel<TProtocol>,\n): ThinkingLevel[] {\n\tif (!model.reasoning) return [\"off\"];\n\n\treturn MODEL_THINKING_LEVELS.filter((level) => {\n\t\tconst mapped = model.thinkingLevelMap?.[level];\n\t\tif (mapped === null) return false;\n\t\tif (level === \"xhigh\" || level === \"max\") return mapped !== undefined;\n\t\treturn true;\n\t});\n}\n\nexport function clampThinkingLevel<TProtocol extends KnownProviderEnum>(\n\tmodel: TModel<TProtocol>,\n\tlevel: ThinkingLevel,\n): ThinkingLevel {\n\tconst availableLevels = getSupportedThinkingLevels(model);\n\tif (availableLevels.includes(level)) return level;\n\n\tconst requestedIndex = MODEL_THINKING_LEVELS.indexOf(level);\n\tif (requestedIndex === -1) return availableLevels[0] ?? \"off\";\n\n\t// walk up the ladder from the point and pick first supported\n\t// biased to avail more thinking, then less not round to nearest.\n\tfor (let i = requestedIndex; i < MODEL_THINKING_LEVELS.length; i++) {\n\t\tconst candidate = MODEL_THINKING_LEVELS[i]!;\n\t\tif (availableLevels.includes(candidate)) return candidate;\n\t}\n\t// otherwise walk down from the point\n\tfor (let i = requestedIndex - 1; i >= 0; i--) {\n\t\tconst candidate = MODEL_THINKING_LEVELS[i]!;\n\t\tif (availableLevels.includes(candidate)) return candidate;\n\t}\n\treturn availableLevels[0] ?? \"off\";\n}\n"],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/{model-DCfjY0fS.d.mts → model-D3wc9-u4.d.mts}

@@ -5,7 +5,7 @@ declare function lazy<T>(fn: () => T): {
   reset: () => void;
 };
 declare namespace catalog_d_exports {
-  export { GeneratedCatalog, KnownProviderEnum$1 as KnownProviderEnum, KnownProviderEnumSchema$1 as KnownProviderEnumSchema, ModelCatalogLoadError$1 as ModelCatalogLoadError, configure, data, filename, get, load, path, projectRoot };
+  export { GeneratedCatalog, KnownProviderEnum$1 as KnownProviderEnum, KnownProviderEnumSchema$1 as KnownProviderEnumSchema, ModelCatalogLoadError$1 as ModelCatalogLoadError, baseline, configure, data, filename, get, load, path, projectRoot };
 }
 declare const KnownProviderEnum$1: {
   readonly anthropic: "anthropic";
@@ -26,14 +26,14 @@ type LazyGeneratedCatalog = ReturnType<typeof lazy<Promise<GeneratedCatalog>>>;
 declare const ModelCatalogLoadError$1: {
   new (data: {
     path: string;
-    reason: "empty" | "invalid" | "missing" | "unreadable";
+    reason: "empty" | "invalid" | "unreadable";
     message: string;
   }, options?: ErrorOptions): {
     cause?: unknown;
     readonly name: "ModelCatalogLoadError";
     readonly data: {
       path: string;
-      reason: "empty" | "invalid" | "missing" | "unreadable";
+      reason: "empty" | "invalid" | "unreadable";
       message: string;
     };
     schema(): {
@@ -46,7 +46,7 @@ declare const ModelCatalogLoadError$1: {
         };
         readonly data: Type$1.TObject<{
           path: Type$1.TString;
-          reason: Type$1.TUnion<[Type$1.TLiteral<"missing">, Type$1.TLiteral<"unreadable">, Type$1.TLiteral<"empty">, Type$1.TLiteral<"invalid">]>;
+          reason: Type$1.TUnion<[Type$1.TLiteral<"unreadable">, Type$1.TLiteral<"empty">, Type$1.TLiteral<"invalid">]>;
           message: Type$1.TString;
         }>;
       };
@@ -55,7 +55,7 @@ declare const ModelCatalogLoadError$1: {
       name: "ModelCatalogLoadError";
       data: {
         path: string;
-        reason: "empty" | "invalid" | "missing" | "unreadable";
+        reason: "empty" | "invalid" | "unreadable";
         message: string;
       };
     };
@@ -77,7 +77,7 @@ declare const ModelCatalogLoadError$1: {
       };
       readonly data: Type$1.TObject<{
         path: Type$1.TString;
-        reason: Type$1.TUnion<[Type$1.TLiteral<"missing">, Type$1.TLiteral<"unreadable">, Type$1.TLiteral<"empty">, Type$1.TLiteral<"invalid">]>;
+        reason: Type$1.TUnion<[Type$1.TLiteral<"unreadable">, Type$1.TLiteral<"empty">, Type$1.TLiteral<"invalid">]>;
         message: Type$1.TString;
       }>;
     };
@@ -87,7 +87,7 @@ declare const ModelCatalogLoadError$1: {
     readonly name: "ModelCatalogLoadError";
     readonly data: {
       path: string;
-      reason: "empty" | "invalid" | "missing" | "unreadable";
+      reason: "empty" | "invalid" | "unreadable";
       message: string;
     };
     schema(): {
@@ -100,7 +100,7 @@ declare const ModelCatalogLoadError$1: {
         };
         readonly data: Type$1.TObject<{
           path: Type$1.TString;
-          reason: Type$1.TUnion<[Type$1.TLiteral<"missing">, Type$1.TLiteral<"unreadable">, Type$1.TLiteral<"empty">, Type$1.TLiteral<"invalid">]>;
+          reason: Type$1.TUnion<[Type$1.TLiteral<"unreadable">, Type$1.TLiteral<"empty">, Type$1.TLiteral<"invalid">]>;
           message: Type$1.TString;
         }>;
       };
@@ -109,7 +109,7 @@ declare const ModelCatalogLoadError$1: {
       name: "ModelCatalogLoadError";
       data: {
         path: string;
-        reason: "empty" | "invalid" | "missing" | "unreadable";
+        reason: "empty" | "invalid" | "unreadable";
         message: string;
       };
     };
@@ -436,11 +436,21 @@ declare const filename = "models.gen.json";
  */
 declare function configure(catalogPath: string): void;
 declare function path(): string;
+/**
+ * The catalog bundled with aikit for OpenAI, Anthropic and OpenRouter (`aikit modelgen --baseline`),
+ * so a first run works before any catalog was generated.
+ */
+declare const baseline: GeneratedCatalog;
+/**
+ * The catalog at `catalogPath` over the {@link baseline}: a provider the file lists replaces the
+ * bundled one, so a fresh generated catalog wins and an older one still gets the bundled providers.
+ * A missing file reads as the baseline alone.
+ */
 declare function load(catalogPath?: string): Promise<GeneratedCatalog>;
 declare const data: LazyGeneratedCatalog;
 declare function get(): Promise<GeneratedCatalog>;
 declare namespace model_d_exports {
-  export { APIMetadata, APIMetadataSchema, APIMethodEnum, APIMethodEnumSchema, ActiveThinkingLevel, BuiltInModels, Compatibility, CompatibilitySchema, ExtrasSchema, Info, KnownProviderEnum, KnownProviderEnumSchema, ModelCatalogLoadError, ProviderInfo, ProviderToProtocol, Schema, TModel, ThinkingBudgets, ThinkingLevel, ThinkingLevelEnum, ThinkingLevelMap, ThinkingLevelMapSchema, calculateCost, catalogPath, clampThinkingLevel, configureCatalog, getBuiltInModels, getModel, getModels, getProviders, getSupportedThinkingLevels, isAnthropicAdaptiveThinkingModel, modelsAreEqual, normalizeInput, optionsKey, registry, reloadCatalog, supportsProtocol, thinkingTokenBudgetField };
+  export { APIMetadata, APIMetadataSchema, APIMethodEnum, APIMethodEnumSchema, ActiveThinkingLevel, BuiltInModels, Compatibility, CompatibilitySchema, ExtrasSchema, Info, KnownProviderEnum, KnownProviderEnumSchema, ModelCatalogLoadError, ProviderInfo, ProviderToProtocol, Schema, TModel, ThinkingBudgets, ThinkingLevel, ThinkingLevelEnum, ThinkingLevelMap, ThinkingLevelMapSchema, calculateCost, catalogPath, clampThinkingLevel, configureCatalog, effortThinkingLevels, getBuiltInModels, getModel, getModels, getProviders, getSupportedThinkingLevels, isAnthropicAdaptiveThinkingModel, modelsAreEqual, normalizeInput, optionsKey, registry, reloadCatalog, supportsProtocol, thinkingTokenBudgetField };
 }
 declare const KnownProviderEnum: {
   readonly anthropic: "anthropic";
@@ -459,14 +469,14 @@ type KnownProviderEnum = KnownProviderEnum$1;
 declare const ModelCatalogLoadError: {
   new (data: {
     path: string;
-    reason: "empty" | "invalid" | "missing" | "unreadable";
+    reason: "empty" | "invalid" | "unreadable";
     message: string;
   }, options?: ErrorOptions): {
     cause?: unknown;
     readonly name: "ModelCatalogLoadError";
     readonly data: {
       path: string;
-      reason: "empty" | "invalid" | "missing" | "unreadable";
+      reason: "empty" | "invalid" | "unreadable";
       message: string;
     };
     schema(): {
@@ -479,7 +489,7 @@ declare const ModelCatalogLoadError: {
         };
         readonly data: Type$1.TObject<{
           path: Type$1.TString;
-          reason: Type$1.TUnion<[Type$1.TLiteral<"missing">, Type$1.TLiteral<"unreadable">, Type$1.TLiteral<"empty">, Type$1.TLiteral<"invalid">]>;
+          reason: Type$1.TUnion<[Type$1.TLiteral<"unreadable">, Type$1.TLiteral<"empty">, Type$1.TLiteral<"invalid">]>;
           message: Type$1.TString;
         }>;
       };
@@ -488,7 +498,7 @@ declare const ModelCatalogLoadError: {
       name: "ModelCatalogLoadError";
       data: {
         path: string;
-        reason: "empty" | "invalid" | "missing" | "unreadable";
+        reason: "empty" | "invalid" | "unreadable";
         message: string;
       };
     };
@@ -510,7 +520,7 @@ declare const ModelCatalogLoadError: {
       };
       readonly data: Type$1.TObject<{
         path: Type$1.TString;
-        reason: Type$1.TUnion<[Type$1.TLiteral<"missing">, Type$1.TLiteral<"unreadable">, Type$1.TLiteral<"empty">, Type$1.TLiteral<"invalid">]>;
+        reason: Type$1.TUnion<[Type$1.TLiteral<"unreadable">, Type$1.TLiteral<"empty">, Type$1.TLiteral<"invalid">]>;
         message: Type$1.TString;
       }>;
     };
@@ -520,7 +530,7 @@ declare const ModelCatalogLoadError: {
     readonly name: "ModelCatalogLoadError";
     readonly data: {
       path: string;
-      reason: "empty" | "invalid" | "missing" | "unreadable";
+      reason: "empty" | "invalid" | "unreadable";
       message: string;
     };
     schema(): {
@@ -533,7 +543,7 @@ declare const ModelCatalogLoadError: {
         };
         readonly data: Type$1.TObject<{
           path: Type$1.TString;
-          reason: Type$1.TUnion<[Type$1.TLiteral<"missing">, Type$1.TLiteral<"unreadable">, Type$1.TLiteral<"empty">, Type$1.TLiteral<"invalid">]>;
+          reason: Type$1.TUnion<[Type$1.TLiteral<"unreadable">, Type$1.TLiteral<"empty">, Type$1.TLiteral<"invalid">]>;
           message: Type$1.TString;
         }>;
       };
@@ -542,7 +552,7 @@ declare const ModelCatalogLoadError: {
       name: "ModelCatalogLoadError";
       data: {
         path: string;
-        reason: "empty" | "invalid" | "missing" | "unreadable";
+        reason: "empty" | "invalid" | "unreadable";
         message: string;
       };
     };
@@ -918,6 +928,12 @@ declare const ThinkingLevelMapSchema: Type$1.TObject<{
   xhigh: Type$1.TOptional<Type$1.TUnion<[Type$1.TString, Type$1.TNull]>>;
 }>;
 type ThinkingLevelMap = Static<typeof ThinkingLevelMapSchema>;
+/**
+ * The level map for a model that lists the reasoning efforts it accepts (models.dev
+ * `reasoning_options`, OpenRouter `supported_efforts`): a level maps to itself only when listed,
+ * and off maps to `none` only when `none` is listed (pi). Undefined when nothing usable is listed.
+ */
+declare function effortThinkingLevels(efforts: ReadonlyArray<string | null>): ThinkingLevelMap | undefined;
 declare const CompatibilitySchema: Type$1.TObject<{
   /** The Google protocol accepts thinking levels rather than a token budget. */
   supportsThinkingLevel: Type$1.TOptional<Type$1.TBoolean>;
@@ -929,6 +945,8 @@ declare const CompatibilitySchema: Type$1.TObject<{
   supportsThinkingTokenBudget: Type$1.TOptional<Type$1.TBoolean>;
   /** Claude model that sizes its own thinking, driven by `effort` instead of a token budget. */
   forceAdaptiveThinking: Type$1.TOptional<Type$1.TBoolean>;
+  /** False for a model that rejects a `temperature` field; the request then leaves it out. */
+  supportsTemperature: Type$1.TOptional<Type$1.TBoolean>;
   /** Name of that field, when it is not the conventional `thinking_token_budget`. */
   thinkingTokenBudgetField: Type$1.TOptional<Type$1.TString>;
 }>;
@@ -1011,6 +1029,8 @@ declare const Schema: Type$1.TObject<{
     supportsThinkingTokenBudget: Type$1.TOptional<Type$1.TBoolean>;
     /** Claude model that sizes its own thinking, driven by `effort` instead of a token budget. */
     forceAdaptiveThinking: Type$1.TOptional<Type$1.TBoolean>;
+    /** False for a model that rejects a `temperature` field; the request then leaves it out. */
+    supportsTemperature: Type$1.TOptional<Type$1.TBoolean>;
     /** Name of that field, when it is not the conventional `thinking_token_budget`. */
     thinkingTokenBudgetField: Type$1.TOptional<Type$1.TString>;
   }>>;
@@ -1047,6 +1067,8 @@ declare const Info: Type$1.TObject<{
     supportsThinkingTokenBudget: Type$1.TOptional<Type$1.TBoolean>;
     /** Claude model that sizes its own thinking, driven by `effort` instead of a token budget. */
     forceAdaptiveThinking: Type$1.TOptional<Type$1.TBoolean>;
+    /** False for a model that rejects a `temperature` field; the request then leaves it out. */
+    supportsTemperature: Type$1.TOptional<Type$1.TBoolean>;
     /** Name of that field, when it is not the conventional `thinking_token_budget`. */
     thinkingTokenBudgetField: Type$1.TOptional<Type$1.TString>;
   }>>;
@@ -1157,6 +1179,7 @@ declare const registry: {
       supportsOpenAIGrammarTools?: boolean;
       supportsThinkingTokenBudget?: boolean;
       forceAdaptiveThinking?: boolean;
+      supportsTemperature?: boolean;
       thinkingTokenBudgetField?: string;
     };
     contextWindow: number;
@@ -1255,4 +1278,4 @@ declare function getSupportedThinkingLevels<TProtocol extends KnownProviderEnum>
 declare function clampThinkingLevel<TProtocol extends KnownProviderEnum>(model: TModel<TProtocol>, level: ThinkingLevel): ThinkingLevel;
 //#endregion
 export { ProviderToProtocol as a, getModel as c, model_d_exports as d, modelsAreEqual as f, KnownProviderEnum as i, getModels as l, ActiveThinkingLevel as n, TModel as o, registry as p, Info as r, ThinkingBudgets as s, APIMethodEnum as t, getProviders as u };
-//# sourceMappingURL=model-DCfjY0fS.d.mts.map
+//# sourceMappingURL=model-D3wc9-u4.d.mts.map