@vascend/talos 0.1.0

package/dist/providers/catalog.js

@@ -0,0 +1,166 @@
+// Catalogo dei provider noti. Ogni voce dice come costruire il provider dalla
+// chiave d'ambiente. 'anthropic' usa il provider nativo; tutti gli altri sono
+// API in stile OpenAI (cambiano solo baseUrl + chiave).
+//
+// I `models` sono SUGGERIMENTI per /models e l'autocompletamento: l'utente puo'
+// sempre indicare qualsiasi id con `provider/<id>`.
+// Cataloghi condivisi tra API key, OAuth e UI. I modelli correnti restano in
+// testa alla lista; i precedenti restano selezionabili per sessioni salvate e
+// compatibilita' con account che non hanno ancora il rollout piu' recente.
+export const ANTHROPIC_MODELS = [
+    "claude-fable-5-1",
+    "claude-fable-5",
+    "claude-opus-5",
+    "claude-sonnet-5",
+    "claude-haiku-4-5-20251001",
+    "claude-opus-4-8",
+    "claude-sonnet-4-6",
+];
+export const OPENAI_MODELS = [
+    "gpt-5.6-sol",
+    "gpt-5.6-terra",
+    "gpt-5.6-luna",
+    "gpt-4o",
+    "gpt-4o-mini",
+    "o3",
+    "o4-mini",
+];
+// Il provider ChatGPT usa il login Codex e un endpoint sperimentale distinto
+// dall'API a consumo: conserva quindi anche i vecchi id dell'abbonamento.
+export const CHATGPT_MODELS = [
+    "gpt-5.6-sol",
+    "gpt-5.6-terra",
+    "gpt-5.6-luna",
+    "gpt-6-astra",
+    "gpt-5-codex",
+    "gpt-5",
+    "gpt-5-mini",
+    "o4-mini",
+];
+export const PROVIDER_CATALOG = [
+    {
+        id: "anthropic",
+        label: "Anthropic",
+        kind: "anthropic",
+        envKey: "ANTHROPIC_API_KEY",
+        models: ANTHROPIC_MODELS,
+    },
+    {
+        id: "openai",
+        label: "OpenAI",
+        kind: "openai",
+        envKey: "OPENAI_API_KEY",
+        baseUrl: "https://api.openai.com/v1",
+        models: OPENAI_MODELS,
+    },
+    {
+        id: "openrouter",
+        label: "OpenRouter",
+        kind: "openai",
+        envKey: "OPENROUTER_API_KEY",
+        baseUrl: "https://openrouter.ai/api/v1",
+        models: [
+            "openrouter/fusion",
+            "anthropic/claude-sonnet-4-6",
+            "openai/gpt-4o",
+            "google/gemini-2.5-flash",
+            "meta-llama/llama-3.3-70b-instruct",
+        ],
+    },
+    {
+        id: "mistral",
+        label: "Mistral",
+        kind: "openai",
+        envKey: "MISTRAL_API_KEY",
+        baseUrl: "https://api.mistral.ai/v1",
+        models: ["mistral-large-latest", "mistral-small-latest"],
+    },
+    {
+        id: "deepseek",
+        label: "DeepSeek",
+        kind: "openai",
+        envKey: "DEEPSEEK_API_KEY",
+        baseUrl: "https://api.deepseek.com/v1",
+        models: ["deepseek-chat", "deepseek-reasoner"],
+    },
+    {
+        id: "xai",
+        label: "Grok",
+        kind: "openai",
+        envKey: "XAI_API_KEY",
+        baseUrl: "https://api.x.ai/v1",
+        models: ["grok-4.5", "grok-4.20-reasoning", "grok-latest"],
+    },
+    {
+        id: "together",
+        label: "Together",
+        kind: "openai",
+        envKey: "TOGETHER_API_KEY",
+        baseUrl: "https://api.together.xyz/v1",
+        models: ["meta-llama/Llama-3.3-70B-Instruct-Turbo"],
+    },
+    {
+        id: "minimax",
+        label: "MiniMax",
+        kind: "openai",
+        envKey: "MINIMAX_API_KEY",
+        baseUrl: "https://api.minimax.io/v1",
+        models: ["MiniMax-M3"],
+    },
+    {
+        id: "nvidia",
+        label: "NVIDIA NIM",
+        kind: "openai",
+        envKey: "NVIDIA_API_KEY",
+        baseUrl: "https://integrate.api.nvidia.com/v1",
+        models: ["meta/llama-3.3-70b-instruct", "deepseek-ai/deepseek-r1"],
+    },
+    {
+        id: "antling",
+        label: "Ant Ling",
+        kind: "openai",
+        envKey: "ANT_LING_API_KEY",
+        baseUrl: "https://antchat.antgroup.com/v1",
+        models: ["Ling-1.5", "Ring-1.5"],
+    },
+    {
+        id: "google",
+        label: "Google Gemini",
+        kind: "openai",
+        envKey: "GEMINI_API_KEY",
+        baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+        models: ["gemini-2.5-pro", "gemini-2.5-flash"],
+    },
+    {
+        id: "opensource",
+        label: "Open source (OpenAI-compatible)",
+        kind: "openai",
+        envKey: "",
+        baseUrlEnv: "OPEN_SOURCE_HOST",
+        defaultBaseUrl: "",
+        optionalEndpoint: true,
+        // Unsloth/vLLM/llama.cpp/Transformers server sono interrogati via
+        // /v1/models: nessun id Hugging Face viene duplicato nel catalogo.
+        models: [],
+    },
+    {
+        id: "lmstudio",
+        label: "LM Studio (locale)",
+        kind: "openai",
+        envKey: "", // server OpenAI-compatible locale, senza chiave
+        baseUrlEnv: "LMSTUDIO_HOST",
+        defaultBaseUrl: "http://127.0.0.1:1234/v1",
+        // I modelli non sono suggerimenti statici: Terminal interroga /v1/models
+        // e mostra esclusivamente quelli realmente caricati in LM Studio.
+        models: [],
+    },
+    {
+        id: "ollama",
+        label: "Ollama (locale)",
+        kind: "openai",
+        envKey: "", // nessuna chiave: e' locale
+        baseUrlEnv: "OLLAMA_HOST",
+        defaultBaseUrl: "http://localhost:11434/v1",
+        models: ["llama3.1", "qwen2.5-coder"],
+    },
+];

package/dist/providers/effort.d.ts

@@ -0,0 +1,12 @@
+export type EffortLevel = "" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export declare function openaiReasoningEffort(effort: string | undefined, env: NodeJS.ProcessEnv): string | null;
+export declare function responsesReasoningEffort(model: string, effort: string | undefined, env: NodeJS.ProcessEnv): string | null;
+export declare function geminiReasoningEffort(effort: string | undefined): string | null;
+export declare function openrouterReasoning(effort: string | undefined): {
+    effort: string;
+} | null;
+export declare function anthropicEffort(effort: string | undefined, model?: string): Record<string, unknown> | null;
+export declare function compatReasoningField(baseUrl: string, effort: string | undefined, env: NodeJS.ProcessEnv, model?: string): {
+    key: string;
+    value: unknown;
+} | null;

package/dist/providers/effort.js

@@ -0,0 +1,102 @@
+// Mappatura del livello di effort (low/medium/high/max) verso il parametro
+// nativo di reasoning di ciascuna famiglia di provider. Verificato sui doc dei
+// provider (giugno 2026). Conservativo: per i provider che NON espongono un
+// parametro standard si invia NULLA, per evitare 400 da campi sconosciuti.
+import { modelCapabilities } from "./models-dev.js";
+import { modelEfforts } from "./model-effort.js";
+function norm(effort) {
+    const e = (effort ?? "").trim().toLowerCase();
+    return e === "none" || e === "minimal" || e === "low" || e === "medium" || e === "high" || e === "xhigh" || e === "max" ? e : "";
+}
+function nativeEffort(model, effort, env) {
+    const metadata = modelCapabilities(model, env);
+    if (!metadata)
+        return undefined;
+    const e = norm(effort);
+    return modelEfforts(model, metadata).includes(e) ? e || null : null;
+}
+// OpenAI Chat Completions: reasoning_effort top-level. "xhigh" esiste solo sui
+// modelli piu' recenti -> "max" viene mappato a "high" per sicurezza, salvo
+// override esplicito via TALOS_OPENAI_MAX_EFFORT=xhigh.
+export function openaiReasoningEffort(effort, env) {
+    const e = norm(effort);
+    if (!e)
+        return null;
+    if (e === "max")
+        return /^xhigh$/i.test(env["TALOS_OPENAI_MAX_EFFORT"] ?? "") ? "xhigh" : "high";
+    return e;
+}
+// Responses espone `max` nativo su Astra; gli altri modelli conservano la
+// mappatura esistente. Il livello scelto deve raggiungere anche il canale OAuth.
+export function responsesReasoningEffort(model, effort, env) {
+    const native = nativeEffort(`openai/${model}`, effort, env);
+    if (native !== undefined)
+        return native;
+    if (/(?:^|\/)gpt-6-astra(?:$|-)/i.test(model))
+        return norm(effort) || null;
+    return openaiReasoningEffort(effort, env);
+}
+// Gemini via endpoint OpenAI-compat: reasoning_effort accetta solo low/med/high
+// ("max" non e' valido -> high).
+export function geminiReasoningEffort(effort) {
+    const e = norm(effort);
+    if (!e)
+        return null;
+    return e === "max" || e === "xhigh" ? "high" : e;
+}
+// OpenRouter: oggetto reasoning:{effort}. Accetta xhigh; "max" -> "high" per
+// sicurezza cross-modello (alcuni backend non hanno xhigh).
+export function openrouterReasoning(effort) {
+    const e = norm(effort);
+    if (!e)
+        return null;
+    return { effort: e === "max" ? "high" : e };
+}
+// Anthropic Messages (Opus 4.8 / Sonnet 4.x): adaptive thinking + output_config
+// effort. NB: su Opus 4.8 budget_tokens da' 400 -> mai inviarlo. Ritorna i campi
+// da fondere nel body, o null se effort non impostato.
+export function anthropicEffort(effort, model) {
+    const native = model ? nativeEffort(`anthropic/${model}`, effort, process.env) : undefined;
+    const e = native === undefined ? norm(effort) : native;
+    if (!e)
+        return null;
+    if (model && !modelEfforts(`anthropic/${model}`).includes(e))
+        return null;
+    return { output_config: { effort: native !== undefined || (model && /claude-(?:fable|opus)-5/.test(model)) ? e : e === "xhigh" ? "high" : e }, thinking: { type: "adaptive" } };
+}
+// Provider OpenAI-compat che supportano reasoning_effort top-level (allowlist).
+// baseUrl-based: openai, gemini-compat, together. Gli altri (mistral/xai/
+// deepseek/ollama) ricevono NULLA.
+export function compatReasoningField(baseUrl, effort, env, model) {
+    if (!norm(effort))
+        return null;
+    const provider = /openrouter\.ai/i.test(baseUrl) ? "openrouter" : /generativelanguage\.googleapis\.com/i.test(baseUrl) ? "google"
+        : /api\.openai\.com/i.test(baseUrl) ? "openai" : /api\.together\.xyz/i.test(baseUrl) ? "togetherai" : undefined;
+    const native = provider && model ? nativeEffort(`${provider}/${model}`, effort, env) : undefined;
+    if (native !== undefined)
+        return native ? { key: provider === "openrouter" ? "reasoning" : "reasoning_effort", value: provider === "openrouter" ? { effort: native } : native } : null;
+    if (provider && model) {
+        const levels = modelEfforts(`${provider}/${model}`);
+        if (levels.length > 1 && levels.includes(norm(effort)))
+            return { key: provider === "openrouter" ? "reasoning" : "reasoning_effort", value: provider === "openrouter" ? { effort: norm(effort) } : norm(effort) };
+        if (provider === "openai" && /^gpt-4/.test(model))
+            return null;
+    }
+    if (/openrouter\.ai/i.test(baseUrl)) {
+        const r = openrouterReasoning(effort);
+        return r ? { key: "reasoning", value: r } : null;
+    }
+    if (/generativelanguage\.googleapis\.com/i.test(baseUrl)) {
+        const v = geminiReasoningEffort(effort);
+        return v ? { key: "reasoning_effort", value: v } : null;
+    }
+    if (/api\.openai\.com/i.test(baseUrl)) {
+        const v = openaiReasoningEffort(effort, env);
+        return v ? { key: "reasoning_effort", value: v } : null;
+    }
+    if (/api\.together\.xyz/i.test(baseUrl)) {
+        const e = norm(effort);
+        return { key: "reasoning_effort", value: e };
+    }
+    return null;
+}

package/dist/providers/model-catalog.d.ts

@@ -0,0 +1,43 @@
+export type ReasoningOption = {
+    readonly type: "effort";
+    readonly values: readonly string[];
+} | {
+    readonly type: "toggle";
+} | {
+    readonly type: "budget_tokens";
+    readonly min?: number;
+    readonly max?: number;
+};
+export interface CatalogModel {
+    readonly provider: string;
+    readonly id: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly family?: string;
+    readonly reasoning?: boolean;
+    readonly reasoningOptions?: readonly ReasoningOption[];
+    readonly toolCall?: boolean;
+    readonly structuredOutput?: boolean;
+    readonly temperature?: boolean;
+    readonly attachment?: boolean;
+    readonly openWeights?: boolean;
+    readonly inputModalities: readonly string[];
+    readonly outputModalities: readonly string[];
+    readonly context?: number;
+    readonly inputLimit?: number;
+    readonly outputLimit?: number;
+    readonly cost: Readonly<Record<string, number>>;
+    readonly releaseDate?: string;
+    readonly updatedAt?: string;
+    readonly knowledge?: string;
+    readonly status?: string;
+}
+export declare function catalogProvider(provider: string): string;
+export declare class ModelCatalog {
+    readonly models: readonly CatalogModel[];
+    private readonly byId;
+    constructor(models?: readonly CatalogModel[]);
+    get(fullModel: string): CatalogModel | undefined;
+    list(provider: string): readonly CatalogModel[];
+}
+export declare function parseModelCatalog(payload: unknown): ModelCatalog;

package/dist/providers/model-catalog.js

@@ -0,0 +1,70 @@
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function str(value) {
+    return typeof value === "string" ? value.replace(/[\x00-\x1f\x7f-\x9f]/g, " ").slice(0, 4000) : undefined;
+}
+function num(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function bool(value) { return typeof value === "boolean" ? value : undefined; }
+function strings(value) {
+    return Array.isArray(value) ? value.flatMap(v => typeof v === "string" ? [str(v)] : []) : [];
+}
+export function catalogProvider(provider) {
+    return { "claude-code": "anthropic", chatgpt: "openai", gemini: "google", together: "togetherai" }[provider] ?? provider;
+}
+export class ModelCatalog {
+    models;
+    byId;
+    constructor(models = []) {
+        this.models = models;
+        this.byId = new Map(models.map(m => [`${m.provider}/${m.id}`, m]));
+    }
+    get(fullModel) {
+        const slash = fullModel.indexOf("/");
+        if (slash < 0)
+            return undefined; // Never borrow limits/prices from a different provider.
+        return this.byId.get(`${catalogProvider(fullModel.slice(0, slash))}/${fullModel.slice(slash + 1)}`);
+    }
+    list(provider) {
+        const id = catalogProvider(provider);
+        return this.models.filter(m => m.provider === id);
+    }
+}
+export function parseModelCatalog(payload) {
+    const out = [];
+    for (const [provider, rawProvider] of Object.entries(record(payload))) {
+        if (!/^[a-zA-Z0-9_.-]+$/.test(provider))
+            continue;
+        for (const [id, raw] of Object.entries(record(record(rawProvider)["models"]))) {
+            if (!id || id.length > 256 || /[\s\x00-\x1f\x7f-\x9f]/.test(id))
+                continue;
+            const m = record(raw);
+            if (!Object.keys(m).length)
+                continue;
+            const limit = record(m["limit"]), modalities = record(m["modalities"]);
+            const options = [];
+            if (Array.isArray(m["reasoning_options"]))
+                for (const rawOption of m["reasoning_options"]) {
+                    const option = record(rawOption);
+                    if (option["type"] === "effort")
+                        options.push({ type: "effort", values: strings(option["values"]) });
+                    if (option["type"] === "toggle")
+                        options.push({ type: "toggle" });
+                    if (option["type"] === "budget_tokens")
+                        options.push({ type: "budget_tokens", min: num(option["min"]), max: num(option["max"]) });
+                }
+            out.push({ provider, id, name: str(m["name"]) ?? id,
+                description: str(m["description"]), family: str(m["family"]),
+                reasoning: bool(m["reasoning"]), reasoningOptions: Array.isArray(m["reasoning_options"]) ? options : undefined,
+                toolCall: bool(m["tool_call"]), structuredOutput: bool(m["structured_output"]),
+                temperature: bool(m["temperature"]), attachment: bool(m["attachment"]), openWeights: bool(m["open_weights"]),
+                inputModalities: strings(modalities["input"]), outputModalities: strings(modalities["output"]),
+                context: num(limit["context"]), inputLimit: num(limit["input"]), outputLimit: num(limit["output"]),
+                cost: Object.fromEntries(Object.entries(record(m["cost"])).flatMap(([k, v]) => num(v) === undefined ? [] : [[k, num(v)]])),
+                releaseDate: str(m["release_date"]), updatedAt: str(m["last_updated"]), knowledge: str(m["knowledge"]), status: str(m["status"]), });
+        }
+    }
+    return new ModelCatalog(out);
+}

package/dist/providers/model-effort.d.ts

@@ -0,0 +1,5 @@
+import { type CatalogModel } from "./model-catalog.js";
+export declare const EFFORT_LEVELS: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+export type ModelEffort = "" | typeof EFFORT_LEVELS[number];
+export declare function modelEfforts(fullModel: string, metadata?: CatalogModel | undefined): readonly ModelEffort[];
+export declare function supportedModelEffort(fullModel: string, effort: string | undefined): ModelEffort;

package/dist/providers/model-effort.js

@@ -0,0 +1,43 @@
+import { modelCapabilities } from "./models-dev.js";
+import { catalogProvider } from "./model-catalog.js";
+export const EFFORT_LEVELS = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+// Only expose controls the Talos adapter can transmit. A reasoning=true flag
+// alone is not proof that a provider supports an adjustable effort parameter.
+export function modelEfforts(fullModel, metadata = modelCapabilities(fullModel)) {
+    const slash = fullModel.indexOf("/"), provider = catalogProvider(fullModel.slice(0, slash));
+    const id = fullModel.slice(slash + 1);
+    if (slash < 0 || !["anthropic", "openai", "google", "openrouter", "togetherai"].includes(provider))
+        return [""];
+    if (metadata?.reasoning === false)
+        return [""];
+    if (metadata?.reasoningOptions !== undefined) {
+        const declared = metadata.reasoningOptions.flatMap(o => o.type === "effort" ? o.values : []);
+        return ["", ...EFFORT_LEVELS.filter(e => declared.includes(e) &&
+                (provider !== "anthropic" || !["none", "minimal"].includes(e)) &&
+                (provider !== "google" || ["minimal", "low", "medium", "high"].includes(e)))];
+    }
+    // Conservative offline fallback for models already supported by Talos.
+    if (provider === "anthropic") {
+        if (/claude-fable-5|claude-opus-5/.test(id))
+            return ["", "low", "medium", "high", "xhigh", "max"];
+        if (/claude-opus-4-[678]/.test(id))
+            return ["", "low", "medium", "high", "max"];
+        if (/claude-sonnet-(?:4-6|5)/.test(id))
+            return ["", "low", "medium", "high"];
+    }
+    if (provider === "openai") {
+        if (/gpt-6-astra/.test(id))
+            return ["", "low", "medium", "high", "xhigh", "max"];
+        if (/gpt-5\.[456]/.test(id))
+            return ["", "low", "medium", "high", "xhigh"];
+        if (/gpt-5|^o[134](?:-|$)/.test(id))
+            return ["", "low", "medium", "high"];
+    }
+    if (provider === "google" && /gemini-3/.test(id))
+        return ["", "low", "high"];
+    return [""];
+}
+// A stale saved effort must not make a different model reject every request.
+export function supportedModelEffort(fullModel, effort) {
+    return modelEfforts(fullModel).find(e => e === effort) ?? "";
+}

package/dist/providers/model-registry.d.ts

@@ -0,0 +1,39 @@
+import { type OpenRouterModel } from "./openrouter.js";
+export interface ModelInfo {
+    readonly id: string;
+    readonly name?: string;
+    readonly contextLength?: number;
+    readonly inputPricePerM?: number;
+    readonly outputPricePerM?: number;
+}
+export interface CostEstimate {
+    readonly inputCost: number;
+    readonly outputCost: number;
+    readonly totalCost: number;
+    readonly known: boolean;
+}
+export declare function toModelInfo(m: OpenRouterModel): ModelInfo;
+export declare class ModelRegistry {
+    private readonly legacyOpenRouterAlias;
+    private readonly byId;
+    private readonly ordered;
+    constructor(models?: readonly ModelInfo[], legacyOpenRouterAlias?: boolean);
+    get size(): number;
+    isEmpty(): boolean;
+    get(id: string): ModelInfo | undefined;
+    has(id: string): boolean;
+    list(): readonly ModelInfo[];
+    ids(): readonly string[];
+    search(query: string): readonly ModelInfo[];
+    pricing(id: string): {
+        readonly input?: number;
+        readonly output?: number;
+    } | undefined;
+    estimateCost(id: string, inputTokens: number, outputTokens: number): CostEstimate;
+}
+export declare function loadModelRegistry(env?: NodeJS.ProcessEnv, opts?: {
+    readonly force?: boolean;
+    readonly timeoutMs?: number;
+}): Promise<ModelRegistry>;
+export declare function modelRegistryFrom(models: readonly OpenRouterModel[]): ModelRegistry;
+export declare function _resetModelRegistry(): void;

package/dist/providers/model-registry.js

@@ -0,0 +1,142 @@
+import { loadModelsDev } from "./models-dev.js";
+// Registro dei modelli OpenRouter. Recupera l'elenco dei modelli disponibili con
+// i relativi metadati di pricing (costo per token input/output) e li espone via
+// un'API interna stabile: lookup per id, elenco, ricerca e stima del costo di
+// una chiamata. Si appoggia al fetch gia' presente in openrouter.ts (endpoint
+// pubblico /models) e ne normalizza i dati in `ModelInfo`.
+import { fetchOpenRouterModels, } from "./openrouter.js";
+// Converte un modello "grezzo" OpenRouter nel formato interno del registro.
+export function toModelInfo(m) {
+    return {
+        id: m.id,
+        name: m.name,
+        contextLength: m.contextLength,
+        inputPricePerM: m.promptPrice,
+        outputPricePerM: m.completionPrice,
+    };
+}
+// Calcola il costo (USD) dati i token e il prezzo per 1M.
+function costFor(tokens, pricePerM) {
+    if (!pricePerM || !Number.isFinite(tokens) || tokens <= 0)
+        return 0;
+    return (tokens / 1_000_000) * pricePerM;
+}
+// Registro immutabile: si costruisce da un elenco di ModelInfo e offre una vista
+// di sola lettura con indice per id (lookup O(1)).
+export class ModelRegistry {
+    legacyOpenRouterAlias;
+    byId;
+    ordered;
+    constructor(models = [], legacyOpenRouterAlias = true) {
+        this.legacyOpenRouterAlias = legacyOpenRouterAlias;
+        const map = new Map();
+        for (const m of models) {
+            if (m.id && !map.has(m.id))
+                map.set(m.id, m);
+        }
+        this.ordered = [...map.values()].sort((a, b) => a.id.localeCompare(b.id));
+        this.byId = map;
+    }
+    // Numero di modelli registrati.
+    get size() {
+        return this.byId.size;
+    }
+    // Vero se il registro non contiene alcun modello.
+    isEmpty() {
+        return this.byId.size === 0;
+    }
+    // Modello per id esatto (accetta anche il prefisso "openrouter/").
+    get(id) {
+        if (!id)
+            return undefined;
+        const direct = this.byId.get(id);
+        if (direct)
+            return direct;
+        const stripped = this.legacyOpenRouterAlias && id.startsWith("openrouter/") ? id.slice("openrouter/".length) : undefined;
+        return stripped ? this.byId.get(stripped) : undefined;
+    }
+    // Vero se il modello e' presente.
+    has(id) {
+        return this.get(id) !== undefined;
+    }
+    // Elenco completo, ordinato per id.
+    list() {
+        return this.ordered;
+    }
+    // Solo gli id, ordinati.
+    ids() {
+        return this.ordered.map((m) => m.id);
+    }
+    // Ricerca per substring case-insensitive su id e nome. Query vuota = tutti.
+    search(query) {
+        const q = query.trim().toLowerCase();
+        if (!q)
+            return this.ordered;
+        const terms = q.split(/\s+/).filter(Boolean);
+        return this.ordered.filter((m) => {
+            const hay = `${m.id} ${m.name ?? ""}`.toLowerCase();
+            return terms.every((t) => hay.includes(t));
+        });
+    }
+    // Pricing di un modello (input/output per 1M token), se noto.
+    pricing(id) {
+        const m = this.get(id);
+        if (!m)
+            return undefined;
+        return { input: m.inputPricePerM, output: m.outputPricePerM };
+    }
+    // Stima il costo in USD di una chiamata con i token di input e output indicati.
+    // Se il modello e' sconosciuto o senza pricing, ritorna 0 con `known: false`.
+    estimateCost(id, inputTokens, outputTokens) {
+        const m = this.get(id);
+        const hasPricing = !!m && (m.inputPricePerM !== undefined || m.outputPricePerM !== undefined);
+        const inputCost = costFor(inputTokens, m?.inputPricePerM);
+        const outputCost = costFor(outputTokens, m?.outputPricePerM);
+        return {
+            inputCost,
+            outputCost,
+            totalCost: inputCost + outputCost,
+            known: hasPricing,
+        };
+    }
+}
+// Cache di sessione del registro: l'elenco modelli cambia di rado.
+let cachedRegistry = null;
+let inflight = null;
+// Recupera la lista modelli OpenRouter e ne costruisce il registro. Fallisce in
+// modo morbido: se il fetch non restituisce nulla, il registro risulta vuoto ma
+// l'API resta utilizzabile. `force` ignora la cache di sessione.
+export async function loadModelRegistry(env = process.env, opts = {}) {
+    if (cachedRegistry && !opts.force)
+        return cachedRegistry;
+    if (inflight && !opts.force)
+        return inflight;
+    const run = (async () => {
+        try {
+            const [raw, catalog] = await Promise.all([fetchOpenRouterModels(env, opts), loadModelsDev(env, opts)]);
+            const reg = new ModelRegistry([
+                ...catalog.models.map(m => ({ id: `${m.provider}/${m.id}`, name: m.name, contextLength: m.context,
+                    inputPricePerM: m.cost["input"], outputPricePerM: m.cost["output"] })),
+                ...raw.map(m => ({ ...toModelInfo(m), id: `openrouter/${m.id}` })),
+            ], false);
+            if (!reg.isEmpty())
+                cachedRegistry = reg;
+            return cachedRegistry ?? reg;
+        }
+        finally {
+            inflight = null;
+        }
+    })();
+    inflight = run;
+    return run;
+}
+// Costruisce un registro direttamente da modelli gia' noti (utile per test e per
+// alimentarlo da un payload gia' scaricato altrove).
+export function modelRegistryFrom(models) {
+    return new ModelRegistry(models.map(toModelInfo));
+}
+// Solo per i test: azzera la cache di sessione del registro.
+export function _resetModelRegistry() {
+    cachedRegistry = null;
+    inflight = null;
+}

package/dist/providers/models-dev.d.ts

@@ -0,0 +1,9 @@
+import { ModelCatalog, type CatalogModel } from "./model-catalog.js";
+export declare function cachedModelCatalog(env?: NodeJS.ProcessEnv): ModelCatalog;
+export declare function modelCapabilities(model: string, env?: NodeJS.ProcessEnv): CatalogModel | undefined;
+export declare function loadModelsDev(env?: NodeJS.ProcessEnv, opts?: {
+    readonly force?: boolean;
+    readonly timeoutMs?: number;
+    readonly fetch?: typeof fetch;
+    readonly now?: number;
+}): Promise<ModelCatalog>;