@vascend/talos 0.1.0

package/dist/providers/plan-limits.js

@@ -0,0 +1,175 @@
+// Lettura dei LIMITI DI PIANO dagli header di risposta dei provider.
+//
+// Gli abbonamenti Claude Code (OAuth) riportano le finestre "unified"
+// (es. 5 ore, settimanale) con utilizzazione e reset; le API key Anthropic
+// riportano i rate limit standard requests/tokens. Modulo PURO: header -> dati,
+// nessuna rete. I provider lo chiamano dopo il fetch e allegano l'esito al
+// ModelTurn; il runtime lo propaga nell'evento turn_end (la UI host mostra
+// "quanto manca del piano").
+import { validResetAt } from "./provider-reset.js";
+// Etichette leggibili per le finestre unified note.
+const UNIFIED_LABEL = {
+    "5h": "Limite 5 ore",
+    "7d": "Settimanale",
+    "7d_sonnet": "Settimanale Sonnet",
+    "7d_opus": "Settimanale Opus",
+    "7d_oauth_apps": "Settimanale app OAuth",
+};
+function windowLabel(id) {
+    return UNIFIED_LABEL[id] ?? `Finestra ${id}`;
+}
+function num(value) {
+    if (value === null || value === undefined || value === "")
+        return undefined;
+    const n = Number(value);
+    return Number.isFinite(n) ? n : undefined;
+}
+// I reset arrivano come ISO date o come epoch secondi, a seconda dell'header.
+function resetEpochMs(value) {
+    if (!value)
+        return undefined;
+    const asNumber = Number(value);
+    if (Number.isFinite(asNumber) && asNumber > 0) {
+        // euristica: epoch secondi (10 cifre) vs ms
+        const at = asNumber > 1e12 ? asNumber : asNumber * 1000;
+        return validResetAt(at) ? at : undefined;
+    }
+    const parsed = Date.parse(value);
+    return validResetAt(parsed) ? parsed : undefined;
+}
+// Estrae le finestre "unified" degli abbonamenti Claude:
+//   anthropic-ratelimit-unified-status: allowed|allowed_warning|...
+//   anthropic-ratelimit-unified-reset: epoch/ISO
+//   anthropic-ratelimit-unified-5h-utilization: 0.16   (frazione)
+//   anthropic-ratelimit-unified-5h-status / -reset
+// Il set esatto varia: si scandiscono TUTTI gli header col prefisso.
+function unifiedWindows(headers) {
+    const seen = new Map();
+    const record = (id) => {
+        let entry = seen.get(id);
+        if (!entry) {
+            entry = {};
+            seen.set(id, entry);
+        }
+        return entry;
+    };
+    const visit = (value, rawKey) => {
+        const key = rawKey.toLowerCase();
+        const m = /^anthropic-ratelimit-unified-(?:(.+)-)?(utilization|reset|status|remaining)$/.exec(key);
+        if (!m)
+            return;
+        const id = m[1] ?? "unified";
+        const field = m[2];
+        const entry = record(id);
+        if (field === "utilization") {
+            const n = num(value);
+            // La frazione puo' superare 1 quando la quota e' esaurita: 1.01 e' 101%.
+            if (n !== undefined)
+                entry.utilization = n;
+        }
+        else if (field === "reset") {
+            entry.resetAt = resetEpochMs(value);
+        }
+        else if (field === "status") {
+            entry.status = value;
+        }
+    };
+    if (typeof headers.forEach === "function")
+        headers.forEach(visit);
+    const out = [];
+    for (const [id, entry] of seen) {
+        if (entry.utilization === undefined && entry.resetAt === undefined && entry.status === undefined)
+            continue;
+        out.push({
+            id,
+            label: windowLabel(id),
+            ...(entry.utilization !== undefined ? { utilization: Math.max(0, Math.min(1, entry.utilization)) } : {}),
+            ...(entry.resetAt !== undefined ? { resetAt: entry.resetAt } : {}),
+            ...(entry.status !== undefined ? { status: entry.status } : {}),
+            unit: "percent",
+        });
+    }
+    return out.sort((a, b) => a.id.localeCompare(b.id));
+}
+// Rate limit standard delle API key Anthropic: requests e input/output tokens.
+function standardWindows(headers) {
+    const out = [];
+    const push = (id, label, unit) => {
+        const limit = num(headers.get(`anthropic-ratelimit-${id}-limit`));
+        const remaining = num(headers.get(`anthropic-ratelimit-${id}-remaining`));
+        const resetAt = resetEpochMs(headers.get(`anthropic-ratelimit-${id}-reset`));
+        if (limit === undefined && remaining === undefined)
+            return;
+        const utilization = limit && remaining !== undefined && limit > 0
+            ? Math.max(0, Math.min(1, (limit - remaining) / limit))
+            : undefined;
+        out.push({
+            id,
+            label,
+            ...(utilization !== undefined ? { utilization } : {}),
+            ...(remaining !== undefined ? { remaining } : {}),
+            ...(limit !== undefined ? { limit } : {}),
+            ...(resetAt !== undefined ? { resetAt } : {}),
+            unit,
+        });
+    };
+    push("requests", "Richieste al minuto", "requests");
+    push("input-tokens", "Token input al minuto", "tokens");
+    push("output-tokens", "Token output al minuto", "tokens");
+    return out;
+}
+// Rate limit stile OpenAI (x-ratelimit-*): usati da OpenAI e da vari compat.
+function openAiWindows(headers) {
+    const out = [];
+    const push = (id, label, unit) => {
+        const limit = num(headers.get(`x-ratelimit-limit-${id}`));
+        const remaining = num(headers.get(`x-ratelimit-remaining-${id}`));
+        if (limit === undefined && remaining === undefined)
+            return;
+        const utilization = limit && remaining !== undefined && limit > 0
+            ? Math.max(0, Math.min(1, (limit - remaining) / limit))
+            : undefined;
+        out.push({
+            id,
+            label,
+            ...(utilization !== undefined ? { utilization } : {}),
+            ...(remaining !== undefined ? { remaining } : {}),
+            ...(limit !== undefined ? { limit } : {}),
+            unit,
+        });
+    };
+    push("requests", "Richieste", "requests");
+    push("tokens", "Token", "tokens");
+    return out;
+}
+// Finestre di abbonamento ChatGPT, distinte dai limiti RPM/TPM delle API key.
+function codexWindows(headers, now) {
+    const windows = [];
+    for (const id of ["primary", "secondary"]) {
+        const prefix = `x-codex-${id}`;
+        const used = num(headers.get(`${prefix}-used-percent`));
+        const minutes = num(headers.get(`${prefix}-window-minutes`));
+        const epoch = resetEpochMs(headers.get(`${prefix}-reset-at`));
+        const delay = num(headers.get(`${prefix}-reset-after-seconds`));
+        const resetAt = epoch ?? (delay !== undefined && delay >= 0 && validResetAt(now + delay * 1000) ? now + delay * 1000 : undefined);
+        if (used === undefined && resetAt === undefined)
+            continue;
+        const label = minutes === 10080 ? "Settimanale" : minutes === 300 ? "Limite 5 ore"
+            : minutes ? `${minutes % 60 === 0 ? `${minutes / 60}h` : `${minutes} min`}` : id === "primary" ? "Primaria" : "Secondaria";
+        windows.push({ id, label, unit: "percent", ...(used !== undefined ? { utilization: Math.max(0, Math.min(1, used / 100)) } : {}),
+            ...(resetAt !== undefined ? { resetAt } : {}) });
+    }
+    return windows;
+}
+// Estrae i limiti di piano dagli header. null se il provider non ne espone.
+export function planLimitsFromHeaders(providerId, headers, now = Date.now()) {
+    const windows = [
+        ...(providerId === "chatgpt" ? codexWindows(headers, now) : []),
+        ...unifiedWindows(headers),
+        ...standardWindows(headers),
+        ...openAiWindows(headers),
+    ];
+    if (!windows.length)
+        return null;
+    return { providerId, windows, capturedAt: now };
+}

package/dist/providers/provider-reset.d.ts

@@ -0,0 +1,4 @@
+export declare const cleanProviderText: (text: string) => string;
+export declare const validResetAt: (value: number) => boolean;
+export declare function providerResetAt(original: string, now?: number): number | undefined;
+export declare function errorTimingDetail(raw: unknown): string;

package/dist/providers/provider-reset.js

@@ -0,0 +1,83 @@
+import { stripVTControlCharacters } from "node:util";
+export const cleanProviderText = (text) => stripVTControlCharacters(text).replace(/[’‘]/g, "'");
+export const validResetAt = (value) => Number.isFinite(value) && value > 0 && value <= 8.64e15;
+function epoch(value, now) {
+    const n = Number(value);
+    const at = Number.isFinite(n) && n > 0 ? (n < 1e12 ? n * 1000 : n) : Date.parse(value);
+    return validResetAt(at) && at > now ? at : undefined;
+}
+// Resolve a time in the provider's timezone, including a reset after midnight.
+// Never substitute the computer's timezone for an invalid provider timezone.
+function nextClockTime(hour, minute, zone, now) {
+    if (hour > 23 || minute > 59)
+        return undefined;
+    try {
+        const fmt = new Intl.DateTimeFormat("en-CA", {
+            ...(zone ? { timeZone: zone } : {}), year: "numeric", month: "2-digit", day: "2-digit",
+            hour: "2-digit", minute: "2-digit", second: "2-digit", hourCycle: "h23",
+        });
+        const local = (at) => {
+            const parts = Object.fromEntries(fmt.formatToParts(at).map(p => [p.type, p.value]));
+            return Date.UTC(Number(parts.year), Number(parts.month) - 1, Number(parts.day), Number(parts.hour), Number(parts.minute), Number(parts.second));
+        };
+        const today = new Date(local(now));
+        for (let day = 0; day <= 1; day++) {
+            const target = Date.UTC(today.getUTCFullYear(), today.getUTCMonth(), today.getUTCDate() + day, hour, minute);
+            let at = target;
+            for (let i = 0; i < 4; i++)
+                at += target - local(at);
+            // A nonexistent DST clock time must remain unknown.
+            if (local(at) === target && at > now)
+                return at;
+            if (local(at) !== target && target > local(now))
+                return undefined;
+        }
+    }
+    catch { /* The original reset text remains visible in the error. */ }
+    return undefined;
+}
+export function providerResetAt(original, now = Date.now()) {
+    const text = cleanProviderText(original);
+    const absolute = text.match(/\b(?:resets?_at|resetAt|resetsAt)["']?\s*[:=]\s*["']?([^\s,"'}]+)/i);
+    if (absolute) {
+        const at = epoch(absolute[1], now);
+        if (at !== undefined)
+            return at;
+    }
+    const retry = text.match(/\b(retry_after_ms|retryAfterMs|retry_after_seconds|retry_after|resets?_in_seconds)["']?\s*[:=]\s*["']?(\d+(?:\.\d+)?(?:e[+-]?\d+)?)/i);
+    if (retry) {
+        const delay = Number(retry[2]) * (/ms$/i.test(retry[1]) ? 1 : 1000);
+        if (delay > 0 && validResetAt(now + delay))
+            return now + delay;
+    }
+    const relative = text.match(/\b(?:resets? in|try again in|retry after)\s+((?:\d+(?:\.\d+)?\s*(?:hours?|hrs?|h|minutes?|mins?|m|seconds?|secs?|s)\s*)+)/i);
+    if (relative) {
+        let delay = 0;
+        for (const part of relative[1].matchAll(/(\d+(?:\.\d+)?)\s*(h\w*|m\w*|s\w*)/gi)) {
+            delay += Number(part[1]) * (/^h/i.test(part[2]) ? 3_600_000 : /^m/i.test(part[2]) ? 60_000 : 1000);
+        }
+        if (delay > 0 && validResetAt(now + delay))
+            return now + delay;
+    }
+    const iso = text.match(/\bresets?\s+(?:at\s+|on\s+)?(\d{4}-\d{2}-\d{2}T[\d:.]+(?:Z|[+-]\d{2}:?\d{2}))/i);
+    if (iso)
+        return epoch(iso[1], now);
+    const clock = text.match(/\bresets?\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?(?:\s*\(([^)]+)\))?/i);
+    if (!clock || (!clock[2] && !clock[3]))
+        return undefined;
+    let hour = Number(clock[1]);
+    if (clock[3]) {
+        if (hour < 1 || hour > 12)
+            return undefined;
+        hour = hour % 12 + (/pm/i.test(clock[3]) ? 12 : 0);
+    }
+    return nextClockTime(hour, Number(clock[2] ?? 0), clock[4]?.trim(), now);
+}
+// Preserve reset metadata when an SSE error is converted into a readable string.
+export function errorTimingDetail(raw) {
+    if (!raw || typeof raw !== "object")
+        return "";
+    const allowed = ["resets_at", "reset_at", "resetAt", "retry_after", "retry_after_seconds", "retry_after_ms"];
+    const fields = Object.fromEntries(Object.entries(raw).filter(([key, value]) => allowed.includes(key) && (typeof value === "string" || typeof value === "number")));
+    return Object.keys(fields).length ? ` ${JSON.stringify(fields)}` : "";
+}

package/dist/providers/quota-limits.d.ts

@@ -0,0 +1,4 @@
+import type { PlanLimits, PlanLimitWindow } from "../core/types.js";
+export declare function rejectedQuotaWindows(limits?: PlanLimits): readonly PlanLimitWindow[];
+export declare function quotaResetAt(limits?: PlanLimits): number | undefined;
+export declare function quotaLimitsFromError(providerId: string, original: string, limits?: PlanLimits, now?: number): PlanLimits | undefined;

package/dist/providers/quota-limits.js

@@ -0,0 +1,33 @@
+import { cleanProviderText, providerResetAt, validResetAt } from "./provider-reset.js";
+export function rejectedQuotaWindows(limits) {
+    // A rejected overage allowance does not mean the included plan is exhausted.
+    return limits?.windows.filter(w => w.status === "rejected" && !w.id.startsWith("overage")) ?? [];
+}
+export function quotaResetAt(limits) {
+    const times = rejectedQuotaWindows(limits).map(w => w.resetAt).filter((at) => at !== undefined && validResetAt(at));
+    return times.length ? Math.max(...times) : undefined;
+}
+// Called only for a provider error already classified as quota exhaustion.
+// A reset alone does not identify a 5h window; preserve an unknown window then.
+export function quotaLimitsFromError(providerId, original, limits, now = Date.now()) {
+    const text = cleanProviderText(original);
+    const resetAt = providerResetAt(text, now);
+    const session = /\b(?:5[ -]?(?:h(?:our)?s?)|five[ -]hours?)\b/i.test(text)
+        || (providerId === "claude-code" && /\bsession[_\s-]*limit/i.test(text));
+    const weekly = /\bweekly[_\s-]*limit/i.test(text);
+    const id = session ? "5h" : weekly ? "7d" : undefined;
+    const label = session ? "Limite 5 ore" : weekly ? "Settimanale" : "Quota provider";
+    const windows = [...(limits?.windows ?? [])];
+    const index = windows.findIndex(w => (id && (w.id === id || w.label === label))
+        || (!id && w.status === "rejected" && !w.id.startsWith("overage")));
+    if (index >= 0) {
+        const previous = windows[index];
+        windows[index] = { ...previous, status: "rejected", ...(previous.resetAt === undefined && resetAt !== undefined ? { resetAt } : {}) };
+    }
+    else if (id || (resetAt !== undefined && !rejectedQuotaWindows(limits).length)) {
+        windows.push({ id: id ?? "quota", label, status: "rejected", unit: "percent", ...(resetAt !== undefined ? { resetAt } : {}) });
+    }
+    if (!windows.length)
+        return limits;
+    return { providerId, windows, capturedAt: limits?.capturedAt ?? now };
+}

package/dist/providers/registry.d.ts

@@ -0,0 +1,33 @@
+import type { Provider } from "../core/types.js";
+export interface Resolved {
+    readonly provider: Provider;
+    readonly modelId: string;
+}
+export interface ParsedModelId {
+    readonly provider?: string;
+    readonly vendor?: string;
+    readonly model: string;
+    readonly modelId?: string;
+}
+export declare function parseModelId(model: string): ParsedModelId;
+export declare class ProviderRegistry {
+    private readonly providers;
+    register(provider: Provider): void;
+    remove(id: string): boolean;
+    get(id: string): Provider | undefined;
+    list(): readonly Provider[];
+    has(): boolean;
+    resolve(model: string): Resolved | null;
+    firstAvailableModel(): string | null;
+}
+export declare function resolveStartupModel(registry: ProviderRegistry, desired: string): {
+    readonly model: string;
+    readonly fellBack: boolean;
+};
+export declare function providerEnvKeys(env: NodeJS.ProcessEnv, id: string): string[];
+export declare function proxyUrl(env: NodeJS.ProcessEnv): string | undefined;
+export declare function parseCustomModels(env: NodeJS.ProcessEnv): Map<string, string[]>;
+export interface RegistryOptions {
+    readonly detectOAuth?: boolean;
+}
+export declare function defaultRegistry(env: NodeJS.ProcessEnv, opts?: RegistryOptions): ProviderRegistry;

package/dist/providers/registry.js

@@ -0,0 +1,213 @@
+import { AnthropicProvider } from "./anthropic.js";
+import { AnthropicOAuthProvider } from "./anthropic-oauth.js";
+import { OpenAIOAuthProvider } from "./openai-oauth.js";
+import { OpenAICompatProvider } from "./openai-compat.js";
+import { readClaudeCreds, readCodexCreds } from "./oauth-store.js";
+import { readOpenRouterCreds } from "./openrouter-auth.js";
+import { PROVIDER_CATALOG } from "./catalog.js";
+import { retryConfigFromEnv, withRetry } from "./retry.js";
+// Scompone un identificatore di modello a uno/due/tre (o piu') segmenti.
+// Funzione PURA: non tocca il registro; serve per display, validazione e per
+// la risoluzione. Segmenti vuoti (es. "a//b", slash iniziale/finale) vengono
+// ignorati, cosi' l'input resta robusto.
+export function parseModelId(model) {
+    const raw = typeof model === "string" ? model.trim() : "";
+    const segments = raw.split("/").map((s) => s.trim()).filter(Boolean);
+    if (segments.length <= 1) {
+        return { model: segments[0] ?? "" };
+    }
+    const provider = segments[0];
+    const lastModel = segments[segments.length - 1];
+    const modelId = segments.slice(1).join("/");
+    if (segments.length === 2) {
+        return { provider, model: lastModel, modelId };
+    }
+    // 3+ segmenti: il vendor e' il secondo, il model e' l'ultimo. Il modelId
+    // conserva l'intera coda dopo il provider (es. "z-ai/glm-5.2").
+    const vendor = segments[1];
+    return { provider, vendor, model: lastModel, modelId };
+}
+// Registro dei provider configurati. La selezione del modello e' LIBERA:
+// si indica `provider/<modelId>` (es. openai/gpt-4o, anthropic/claude-opus-4-8,
+// openrouter/google/gemini-2.5-flash, openrouter/z-ai/glm-5.2). Un modello noto
+// puo' anche essere indicato nudo: viene cercato tra i provider.
+export class ProviderRegistry {
+    providers = new Map();
+    register(provider) {
+        this.providers.set(provider.id, provider);
+    }
+    // Rimuove un provider (es. unregisterProvider da estensione).
+    remove(id) {
+        return this.providers.delete(id);
+    }
+    get(id) {
+        return this.providers.get(id);
+    }
+    list() {
+        return [...this.providers.values()];
+    }
+    has() {
+        return this.providers.size > 0;
+    }
+    // Risolve "provider/modelId" oppure un modello noto nudo. Il parsing usa
+    // parseModelId: il primo segmento e' il provider, tutto cio' che segue (vendor
+    // incluso) e' il modelId che il provider riceve. Cosi' "openrouter/z-ai/glm-5.2"
+    // -> provider "openrouter", modelId "z-ai/glm-5.2" (i tre segmenti non rompono
+    // i due segmenti come "openai/gpt-4o").
+    resolve(model) {
+        const parsed = parseModelId(model);
+        if (parsed.provider && parsed.modelId) {
+            const provider = this.providers.get(parsed.provider);
+            if (provider)
+                return { provider, modelId: parsed.modelId };
+        }
+        // Modello nudo: il primo provider che lo dichiara. Confrontiamo sia con
+        // l'id completo passato, sia con il nome puro (model) ricavato dal parsing.
+        for (const p of this.providers.values()) {
+            if (p.models.includes(model) || p.models.includes(parsed.model)) {
+                return { provider: p, modelId: model };
+            }
+        }
+        return null;
+    }
+    // Modello di ripiego SENSATO quando quello desiderato non e' servito da
+    // nessun provider configurato. Invece di insistere su un default hardcodato
+    // (es. anthropic/claude-sonnet-4-6) che puo' non avere chiave, scegliamo il
+    // PRIMO modello realmente erogabile da un provider attivo, dando priorita'
+    // agli abbonamenti/anthropic (esperienza "stile Claude Code"). Ritorna l'id
+    // COMPLETO "provider/modello" (cosi' la risoluzione resta deterministica) o
+    // null se non c'e' alcun provider configurato.
+    firstAvailableModel() {
+        const priority = ["claude-code", "anthropic", "openai", "openrouter"];
+        const ordered = [...this.providers.values()].sort((a, b) => {
+            const ia = priority.indexOf(a.id);
+            const ib = priority.indexOf(b.id);
+            return (ia < 0 ? priority.length : ia) - (ib < 0 ? priority.length : ib);
+        });
+        for (const p of ordered) {
+            const first = p.models[0];
+            if (first)
+                return `${p.id}/${first}`;
+        }
+        return null;
+    }
+}
+// Sceglie il modello con cui PARTIRE: se quello desiderato (salvato/config) e'
+// risolvibile lo si tiene; altrimenti si ripiega sul primo modello realmente
+// disponibile tra i provider configurati. Non tocca alcun file: il modello
+// salvato resta la PREFERENZA dell'utente e torna valido appena il suo provider
+// e' di nuovo configurato. Ritorna anche `fellBack` per segnalarlo all'avvio.
+export function resolveStartupModel(registry, desired) {
+    if (desired && registry.resolve(desired))
+        return { model: desired, fellBack: false };
+    const fallback = registry.firstAvailableModel();
+    if (fallback)
+        return { model: fallback, fellBack: true };
+    // Nessun provider configurato: lasciamo il desiderato cosi' com'e' (la TUI
+    // guidera' l'utente alla configurazione / scelta del modello).
+    return { model: desired, fellBack: false };
+}
+function localBase(env, envName, fallback) {
+    const raw = String(env[envName] ?? "").trim();
+    if (!raw)
+        return fallback;
+    return /\/v\d+\/?$/.test(raw) ? raw.replace(/\/$/, "") : `${raw.replace(/\/$/, "")}/v1`;
+}
+// Override per-provider: TALOS_<ID>_BASE_URL e TALOS_<ID>_API_KEY (selective
+// base entry points + provider-scoped API key environments).
+function providerEnvKey(env, id) {
+    const norm = id.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+    return String(env[`TALOS_${norm}_API_KEY`] ?? "").trim();
+}
+export function providerEnvKeys(env, id) {
+    const norm = id.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+    const primary = providerEnvKey(env, id);
+    const raw = String(env[`TALOS_${norm}_API_KEYS`] ?? "").trim();
+    let values = [];
+    if (raw) {
+        try {
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed))
+                values = parsed.map((item) => String(item ?? "").trim()).filter(Boolean);
+        }
+        catch {
+            values = raw.split(/[\r\n,;]+/).map((item) => item.trim()).filter(Boolean);
+        }
+    }
+    return [...new Set([primary, ...values].filter(Boolean))];
+}
+function providerEnvBaseUrl(env, id) {
+    const norm = id.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+    return String(env[`TALOS_${norm}_BASE_URL`] ?? "").trim();
+}
+// Proxy HTTP globale: TALOS_HTTP_PROXY (o HTTPS_PROXY/HTTP_PROXY). Bun e undici
+// onorano HTTPS_PROXY/HTTP_PROXY dall'ambiente per fetch.
+export function proxyUrl(env) {
+    const v = String(env["TALOS_HTTP_PROXY"] ?? env["HTTPS_PROXY"] ?? env["HTTP_PROXY"] ?? "").trim();
+    return v || undefined;
+}
+// Modelli aggiuntivi per provider: TALOS_CUSTOM_MODELS="openai:o9,xai:grok-latest".
+export function parseCustomModels(env) {
+    const out = new Map();
+    for (const pair of String(env["TALOS_CUSTOM_MODELS"] ?? "").split(",").map((s) => s.trim()).filter(Boolean)) {
+        const sep = pair.indexOf(":");
+        if (sep <= 0)
+            continue;
+        const provider = pair.slice(0, sep).trim();
+        const model = pair.slice(sep + 1).trim();
+        if (!model)
+            continue;
+        out.set(provider, [...(out.get(provider) ?? []), model]);
+    }
+    return out;
+}
+// Costruisce il registro leggendo le chiavi dall'ambiente: un provider per
+// ogni voce del catalogo che risulta configurata (chiave presente, o locale).
+// In piu', se presenti, registra i provider ABBONAMENTO via OAuth (token dei
+// CLI ufficiali claude/codex): id "claude-code" e "chatgpt".
+export function defaultRegistry(env, opts = {}) {
+    const reg = new ProviderRegistry();
+    const customModels = parseCustomModels(env);
+    const retry = retryConfigFromEnv(env);
+    const add = (p) => reg.register(withRetry(p, retry));
+    for (const spec of PROVIDER_CATALOG) {
+        const extraModels = customModels.get(spec.id) ?? [];
+        if (spec.kind === "anthropic") {
+            const key = providerEnvKey(env, spec.id) || String(env[spec.envKey] ?? "").trim();
+            if (key)
+                add(new AnthropicProvider(key));
+            continue;
+        }
+        // OpenAI-compatibile. envKey vuoto = locale (Ollama), sempre incluso.
+        const scopedKeys = providerEnvKeys(env, spec.id);
+        const scopedKey = scopedKeys[0] ?? "";
+        let key = scopedKey || (spec.envKey ? String(env[spec.envKey] ?? "").trim() : "");
+        // OpenRouter: oltre all'env, accetta le credenziali su disco (OAuth PKCE o
+        // API key manuale, in ~/.talos/openrouter.json) cosi' che il metodo di
+        // accesso resti attivo anche senza OPENROUTER_API_KEY esportata.
+        if (!key && spec.id === "openrouter" && env["TALOS_NO_GLOBAL_CONFIG"] !== "1") {
+            key = readOpenRouterCreds(env)?.apiKey ?? "";
+        }
+        if (spec.envKey && !key)
+            continue;
+        const baseUrl = providerEnvBaseUrl(env, spec.id)
+            || (spec.baseUrlEnv ? localBase(env, spec.baseUrlEnv, spec.defaultBaseUrl ?? "") : (spec.baseUrl ?? ""));
+        // Il connettore open source e' opt-in: compare nel catalogo guidato, ma
+        // entra nel runtime solo dopo che l'utente ha indicato il server reale.
+        if (spec.optionalEndpoint && !baseUrl)
+            continue;
+        const keyInput = spec.id === "openrouter" && scopedKeys.length > 1 ? scopedKeys : key;
+        add(new OpenAICompatProvider(spec.id, spec.label, baseUrl, keyInput, [...spec.models, ...extraModels]));
+    }
+    if (opts.detectOAuth !== false) {
+        const claude = readClaudeCreds(env);
+        if (claude)
+            add(new AnthropicOAuthProvider(claude, env));
+        if (env["TALOS_DISABLE_CHATGPT_OAUTH"] !== "1") {
+            const codex = readCodexCreds(env);
+            if (codex)
+                add(new OpenAIOAuthProvider(codex, env));
+        }
+    }
+    return reg;
+}

package/dist/providers/retry.d.ts

@@ -0,0 +1,37 @@
+import type { CompletionRequest, ModelTurn, PlanLimits, Provider } from "../core/types.js";
+export interface RetryConfig {
+    readonly maxRetries: number;
+    readonly baseDelayMs: number;
+    readonly timeoutMs: number;
+    readonly networkMaxRetries?: number;
+    readonly networkRetryDelayMs?: number;
+    readonly overloadMaxAttempts?: number;
+    readonly overloadBaseDelayMs?: number;
+    readonly overloadMaxDelayMs?: number;
+}
+export declare const DEFAULT_RETRY: RetryConfig;
+export declare function retryConfigFromEnv(env: NodeJS.ProcessEnv): RetryConfig;
+export declare function isNetworkError(text: string): boolean;
+export declare function isUpstreamRouterError(text: string): boolean;
+export declare function isTransientError(text: string): boolean;
+export declare function isOverloadError(text: string): boolean;
+export declare function retryAfterMs(text: string): number | undefined;
+export declare function isQuotaError(text: string): boolean;
+export declare function quotaMessage(providerId: string, original: string, limits?: PlanLimits): string;
+export declare class RetryProvider implements Provider {
+    private readonly inner;
+    private readonly cfg;
+    constructor(inner: Provider, cfg: RetryConfig);
+    get id(): string;
+    get label(): string | undefined;
+    get models(): readonly string[];
+    get supportsFastMode(): boolean;
+    private get netMax();
+    private get netDelay();
+    private get overloadMaxAttempts();
+    private overloadDelay;
+    private waitForOverload;
+    complete(req: CompletionRequest): Promise<ModelTurn>;
+    private backoff;
+}
+export declare function withRetry(provider: Provider, cfg: RetryConfig): Provider;