@vascend/talos 0.1.5 → 0.1.6

package/dist/providers/anthropic.d.ts

@@ -11,8 +11,15 @@ interface ApiMessage {
 }
 export declare function toApiMessages(req: CompletionRequest): unknown[];
 export declare function normalizeToolPairing(messages: ApiMessage[]): ApiMessage[];
-export declare function withSystemCache(system: string, turnContext?: string): unknown[];
-export declare function applyMessageCache(messages: unknown[]): unknown[];
+export type CacheTtl = "5m" | "1h";
+export declare function claudeCacheTtl(env: NodeJS.ProcessEnv): CacheTtl;
+export declare function supportsConversationSystem(model: string): boolean;
+export declare function withSystemCache(system: string, turnContext?: string, ttl?: CacheTtl): unknown[];
+export declare function applyMessageCache(messages: unknown[], ttl?: CacheTtl): unknown[];
+export declare function claudePrompt(req: CompletionRequest, ttl?: CacheTtl): {
+    system: unknown[];
+    messages: unknown[];
+};
 export declare const CONTEXT_1M_BETA = "context-1m-2025-08-07";
 export declare function wants1m(model: string, env: NodeJS.ProcessEnv): boolean;
 export declare class AnthropicProvider implements Provider {

package/dist/providers/anthropic.js

@@ -163,12 +163,34 @@ export function normalizeToolPairing(messages) {
     }
     return out;
 }
-// Applica i breakpoint di cache (prompt caching Anthropic): marca l'ultimo
-// blocco di system e l'ultimo blocco dell'ultimo messaggio con cache_control
-// ephemeral. Riduce i token fatturati sui turni successivi.
-export function withSystemCache(system, turnContext = "") {
+// Un'ora come Claude Code, per abbonamento e API key: ogni lettura rinnova la
+// scadenza, quindi le sessioni con pause oltre i 5 minuti non riscrivono tutto
+// il prefisso. TALOS_CLAUDE_CACHE_TTL=5m torna alla durata breve.
+export function claudeCacheTtl(env) {
+    return env["TALOS_CLAUDE_CACHE_TTL"] === "5m" ? "5m" : "1h";
+}
+const CACHE_TTL_MS = { "5m": 300_000, "1h": 3_600_000 };
+// Durata applicata dal provider alla cache di questa risposta: la dice la
+// suddivisione di cache_creation per TTL. Una lettura rinnova la durata gia'
+// scritta, che resta quella dell'ultima scrittura nota.
+function reportedCacheTtlMs(usage) {
+    const creation = usage["cache_creation"];
+    if (Number(creation?.["ephemeral_1h_input_tokens"] ?? 0) > 0)
+        return CACHE_TTL_MS["1h"];
+    if (Number(creation?.["ephemeral_5m_input_tokens"] ?? 0) > 0)
+        return CACHE_TTL_MS["5m"];
+    return undefined;
+}
+function cacheControl(ttl) {
+    return { type: "ephemeral", ...(ttl === "1h" ? { ttl } : {}) };
+}
+// Only documented models accept authoritative system messages in the history.
+export function supportsConversationSystem(model) {
+    return /^claude-(?:opus-(?:5(?:-\d)?|4-8)|(?:fable|mythos)-5(?:-\d)?)(?:-\d{8})?$/.test(model);
+}
+export function withSystemCache(system, turnContext = "", ttl = "5m") {
     return [
-        { type: "text", text: system, cache_control: { type: "ephemeral" } },
+        { type: "text", text: system, cache_control: cacheControl(ttl) },
         ...(turnContext ? [{
                 type: "text",
                 text: `[HORIZON_TURN_CONTEXT]\n${turnContext}\n[/HORIZON_TURN_CONTEXT]`,
@@ -181,20 +203,39 @@ export function withSystemCache(system, turnContext = "") {
 // finisce col turno precedente resta cacheato e viene riconosciuto al turno
 // dopo. Insieme al breakpoint su system restano 3 marcatori, sotto il tetto di
 // 4 dell'API.
-export function applyMessageCache(messages) {
-    markCacheBreakpoint(messages[messages.length - 1]);
-    if (messages.length > 1)
-        markCacheBreakpoint(messages[messages.length - 2]);
-    return messages;
+export function applyMessageCache(messages, ttl = "5m") {
+    // Provider projections must not mutate a caller's history.
+    const copy = messages.map((message) => {
+        const m = message;
+        return { ...m, ...(Array.isArray(m.content) ? { content: m.content.map(b => ({ ...b })) } : {}) };
+    });
+    markCacheBreakpoint(copy[copy.length - 1], ttl);
+    if (copy.length > 1)
+        markCacheBreakpoint(copy[copy.length - 2], ttl);
+    return copy;
 }
-function markCacheBreakpoint(message) {
+function markCacheBreakpoint(message, ttl) {
     const target = message;
     if (!target || !Array.isArray(target.content) || !target.content.length)
         return;
     const blocks = target.content;
     const lastBlock = blocks[blocks.length - 1];
     if (lastBlock)
-        lastBlock["cache_control"] = { type: "ephemeral" };
+        lastBlock["cache_control"] = cacheControl(ttl);
+}
+export function claudePrompt(req, ttl = "5m") {
+    const inline = supportsConversationSystem(req.model);
+    const messages = toApiMessages(req);
+    if (inline && req.turnContext)
+        messages.push({ role: "system", content: [{
+                    type: "text", text: `[HORIZON_TURN_CONTEXT]\n${req.turnContext}\n[/HORIZON_TURN_CONTEXT]`,
+                }] });
+    // Cache the history immediately BEFORE the volatile tail as well as the tail.
+    // On the next request only the tail is replaced; all prior history still matches.
+    return {
+        system: withSystemCache(req.system, inline ? "" : req.turnContext, ttl),
+        messages: applyMessageCache(messages, ttl),
+    };
 }
 import { anthropicEffort } from "./effort.js";
 import { resolveMaxTokens } from "../core/model-limits.js";
@@ -233,8 +274,7 @@ export class AnthropicProvider {
         const body = {
             model: req.model,
             max_tokens: resolveMaxTokens(req.maxTokens, `anthropic/${req.model}`),
-            system: withSystemCache(req.system, req.turnContext),
-            messages: applyMessageCache(toApiMessages(req)),
+            ...claudePrompt(req, claudeCacheTtl(process.env)),
             stream: true,
             tools: req.tools.map((t) => ({
                 name: t.name,
@@ -331,7 +371,7 @@ export async function parseStream(body, onDelta, onActivity, onReasoning, onTool
             stopReason ??= "end";
             sawTerminal = true;
         }
-        const u = readUsage(evt);
+        const u = readUsage(evt, usage);
         if (u)
             usage = u;
     };
@@ -511,16 +551,19 @@ function readProviderError(evt) {
     const message = String(raw?.["message"] ?? evt["message"] ?? "errore streaming senza dettagli");
     return `Errore provider Anthropic (${kind}): ${message}${errorTimingDetail(raw)}${errorTimingDetail(evt)}`;
 }
-function readUsage(evt) {
-    const usage = evt["usage"];
+function readUsage(evt, previous) {
+    const message = evt["message"];
+    const usage = (evt["usage"] ?? message?.["usage"]);
     if (!usage)
         return undefined;
     const cacheRead = usage["cache_read_input_tokens"];
     const cacheWrite = usage["cache_creation_input_tokens"];
+    const cacheTtlMs = reportedCacheTtlMs(usage) ?? previous?.cacheTtlMs;
     return {
-        inputTokens: Number(usage["input_tokens"] ?? 0),
-        outputTokens: Number(usage["output_tokens"] ?? 0),
-        ...(cacheRead !== undefined ? { cacheReadTokens: Number(cacheRead) } : {}),
-        ...(cacheWrite !== undefined ? { cacheWriteTokens: Number(cacheWrite) } : {}),
+        inputTokens: Number(usage["input_tokens"] ?? previous?.inputTokens ?? 0),
+        outputTokens: Number(usage["output_tokens"] ?? previous?.outputTokens ?? 0),
+        ...((cacheRead ?? previous?.cacheReadTokens) !== undefined ? { cacheReadTokens: Number(cacheRead ?? previous?.cacheReadTokens) } : {}),
+        ...((cacheWrite ?? previous?.cacheWriteTokens) !== undefined ? { cacheWriteTokens: Number(cacheWrite ?? previous?.cacheWriteTokens) } : {}),
+        ...(cacheTtlMs !== undefined ? { cacheTtlMs } : {}),
     };
 }

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

@@ -0,0 +1,30 @@
+export type CliName = "claude" | "codex";
+export interface CliModel {
+    readonly id: string;
+    readonly label: string;
+    readonly description?: string;
+}
+/** Primo CLI nel PATH con l'impronta del binario reale (symlink risolti), o null se non installato. */
+export declare function findCli(name: CliName, env: NodeJS.ProcessEnv): {
+    readonly executable: string;
+    readonly stamp: string;
+} | null;
+/** Modelli in cache per il CLI installato ora, o undefined se assenti o superati da un aggiornamento. */
+export declare function cachedCliModels(name: CliName, env: NodeJS.ProcessEnv): readonly CliModel[] | undefined;
+/**
+ * Righe di `initialize` del CLI Claude Code. Gli alias (default, opus, sonnet)
+ * diventano il modello versionato che eseguono: una voce per modello reale,
+ * nell'ordine del CLI.
+ */
+export declare function claudeModelsFromInitialize(models: unknown): CliModel[];
+/** Righe di `model/list` dell'app-server Codex, senza i modelli nascosti. */
+export declare function codexModelsFromList(data: unknown): CliModel[];
+/**
+ * Rilegge i modelli dai CLI installati la cui cache manca o e' superata, e la
+ * salva. Un CLI assente, lento o in errore lascia la cache com'e': il catalogo
+ * ripiega su quello statico.
+ */
+export declare function refreshCliModels(env: NodeJS.ProcessEnv, options?: {
+    readonly timeoutMs?: number;
+    readonly force?: boolean;
+}): Promise<void>;

package/dist/providers/cli-models.js

@@ -0,0 +1,194 @@
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { delimiter, dirname, isAbsolute, join } from "node:path";
+import { talosConfigDir } from "../core/env-paths.js";
+const QUERY_TIMEOUT_MS = 20_000;
+function cachePath(env) {
+    if (env["TALOS_NO_GLOBAL_CONFIG"] === "1" || env["TALOS_DISABLE_CLI_MODELS"] === "1")
+        return null;
+    return join(talosConfigDir(env), "cli-models.json");
+}
+/** Primo CLI nel PATH con l'impronta del binario reale (symlink risolti), o null se non installato. */
+export function findCli(name, env) {
+    const names = process.platform === "win32" ? [`${name}.exe`, `${name}.cmd`] : [name];
+    for (const directory of String(env["PATH"] ?? env["Path"] ?? "").split(delimiter)) {
+        if (!directory || !isAbsolute(directory))
+            continue;
+        for (const file of names) {
+            const candidate = join(directory, file);
+            if (!existsSync(candidate))
+                continue;
+            try {
+                const real = realpathSync(candidate);
+                return { executable: candidate, stamp: `${real}@${statSync(real).mtimeMs}` };
+            }
+            catch {
+                // Voce del PATH non leggibile: si prova la successiva.
+            }
+        }
+    }
+    return null;
+}
+function readCache(env) {
+    const path = cachePath(env);
+    if (!path || !existsSync(path))
+        return {};
+    try {
+        const raw = JSON.parse(readFileSync(path, "utf8"));
+        return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Modelli in cache per il CLI installato ora, o undefined se assenti o superati da un aggiornamento. */
+export function cachedCliModels(name, env) {
+    if (!cachePath(env))
+        return undefined;
+    const cli = findCli(name, env);
+    const entry = readCache(env)[name];
+    if (!cli || !entry || entry.stamp !== cli.stamp)
+        return undefined;
+    const models = Array.isArray(entry.models) ? entry.models.filter((model) => typeof model?.id === "string" && model.id && typeof model.label === "string") : [];
+    return models.length ? models : undefined;
+}
+/**
+ * Righe di `initialize` del CLI Claude Code. Gli alias (default, opus, sonnet)
+ * diventano il modello versionato che eseguono: una voce per modello reale,
+ * nell'ordine del CLI.
+ */
+export function claudeModelsFromInitialize(models) {
+    const out = new Map();
+    for (const raw of Array.isArray(models) ? models : []) {
+        const row = raw;
+        if (row["value"] === "default")
+            continue;
+        const id = String(row["resolvedModel"] || row["value"] || "").trim();
+        if (!id || out.has(id))
+            continue;
+        const label = String(row["displayName"] || id).trim();
+        const description = String(row["description"] ?? "").trim();
+        out.set(id, { id, label, ...(description ? { description } : {}) });
+    }
+    return [...out.values()];
+}
+/** Righe di `model/list` dell'app-server Codex, senza i modelli nascosti. */
+export function codexModelsFromList(data) {
+    const out = new Map();
+    for (const raw of Array.isArray(data) ? data : []) {
+        const row = raw;
+        if (row["hidden"] === true)
+            continue;
+        const id = String(row["model"] || row["id"] || "").trim();
+        if (!id || out.has(id))
+            continue;
+        const label = String(row["displayName"] || id).trim();
+        const description = String(row["description"] ?? "").trim();
+        out.set(id, { id, label, ...(description ? { description } : {}) });
+    }
+    return [...out.values()];
+}
+// Avvia il CLI, scrive le richieste JSONL e attende la prima riga che `pick`
+// riconosce. Il processo viene sempre terminato, anche su timeout o errore.
+function queryCli(executable, args, requests, pick, env, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(executable, [...args], {
+            env, cwd: tmpdir(), stdio: ["pipe", "pipe", "ignore"], windowsHide: true,
+            shell: process.platform === "win32" && executable.toLowerCase().endsWith(".cmd"),
+        });
+        let buffer = "";
+        let settled = false;
+        const finish = (error, value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.kill();
+            if (error)
+                reject(error);
+            else
+                resolve(value);
+        };
+        const timer = setTimeout(() => finish(new Error(`${executable} did not answer in time`)), timeoutMs);
+        child.on("error", (error) => finish(error));
+        child.on("close", () => finish(new Error(`${executable} exited before answering`)));
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            buffer += chunk;
+            let newline;
+            while ((newline = buffer.indexOf("\n")) >= 0) {
+                const line = buffer.slice(0, newline).trim();
+                buffer = buffer.slice(newline + 1);
+                if (!line.startsWith("{"))
+                    continue;
+                try {
+                    const value = pick(JSON.parse(line));
+                    if (value !== undefined)
+                        finish(null, value);
+                }
+                catch {
+                    // Righe non JSON (log) ignorate.
+                }
+            }
+        });
+        child.stdin.on("error", () => { });
+        child.stdin.write(requests.map((request) => JSON.stringify(request)).join("\n") + "\n");
+    });
+}
+async function queryClaudeModels(executable, env, timeoutMs) {
+    const response = await queryCli(executable, ["-p", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose"], [{ type: "control_request", request_id: "talos-models", request: { subtype: "initialize" } }], (message) => {
+        const body = message["response"];
+        return message["type"] === "control_response" && body?.["request_id"] === "talos-models" ? body : undefined;
+    }, env, timeoutMs);
+    if (response["subtype"] !== "success")
+        throw new Error(String(response["error"] ?? "Claude Code initialize failed"));
+    return claudeModelsFromInitialize(response["response"]?.["models"]);
+}
+async function queryCodexModels(executable, env, timeoutMs) {
+    const response = await queryCli(executable, ["app-server"], [
+        { id: 1, method: "initialize", params: { clientInfo: { name: "talos", version: "1" } } },
+        { method: "initialized" },
+        { id: 2, method: "model/list", params: {} },
+    ], (message) => message["id"] === 2 ? message : undefined, env, timeoutMs);
+    if (response["error"])
+        throw new Error(JSON.stringify(response["error"]));
+    return codexModelsFromList(response["result"]?.["data"]);
+}
+/**
+ * Rilegge i modelli dai CLI installati la cui cache manca o e' superata, e la
+ * salva. Un CLI assente, lento o in errore lascia la cache com'e': il catalogo
+ * ripiega su quello statico.
+ */
+export async function refreshCliModels(env, options = {}) {
+    const path = cachePath(env);
+    if (!path)
+        return;
+    const timeoutMs = options.timeoutMs ?? QUERY_TIMEOUT_MS;
+    const queries = { claude: queryClaudeModels, codex: queryCodexModels };
+    const updates = await Promise.all(Object.keys(queries).map(async (name) => {
+        if (!options.force && cachedCliModels(name, env))
+            return null;
+        const cli = findCli(name, env);
+        if (!cli)
+            return null;
+        try {
+            const models = await queries[name](cli.executable, env, timeoutMs);
+            return models.length ? [name, { stamp: cli.stamp, models }] : null;
+        }
+        catch {
+            return null;
+        }
+    }));
+    const fresh = updates.filter((update) => update !== null);
+    if (!fresh.length)
+        return;
+    const cache = { ...readCache(env), ...Object.fromEntries(fresh) };
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, JSON.stringify(cache, null, 2) + "\n", { mode: 0o600 });
+    }
+    catch {
+        // Cache non scrivibile: il catalogo resta quello statico.
+    }
+}

package/dist/providers/model-effort.js

@@ -26,7 +26,7 @@ export function modelEfforts(fullModel, metadata = modelCapabilities(fullModel))
             return ["", "low", "medium", "high"];
     }
     if (provider === "openai") {
-        if (/gpt-6-astra/.test(id))
+        if (/gpt-6/.test(id))
             return ["", "low", "medium", "high", "xhigh", "max"];
         if (/gpt-5\.[456]/.test(id))
             return ["", "low", "medium", "high", "xhigh"];

package/dist/providers/openai-oauth.d.ts

@@ -1,3 +1,4 @@
+import type { CliModel } from "./cli-models.js";
 import type { CompletionRequest, ModelTurn, Provider } from "../core/types.js";
 import { type OAuthCreds } from "./oauth-store.js";
 export declare class OpenAIOAuthProvider implements Provider {
@@ -5,10 +6,14 @@ export declare class OpenAIOAuthProvider implements Provider {
     private readonly env;
     private readonly now;
     readonly id = "chatgpt";
-    readonly label = "ChatGPT (abbonamento)";
-    readonly models: readonly ["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"];
+    readonly label = "ChatGPT";
+    readonly models: readonly string[];
+    readonly modelLabels?: ReadonlyMap<string, {
+        readonly label: string;
+        readonly description?: string;
+    }>;
     readonly supportsFastMode = true;
-    constructor(creds: OAuthCreds, env: NodeJS.ProcessEnv, now?: () => number);
+    constructor(creds: OAuthCreds, env: NodeJS.ProcessEnv, now?: () => number, cliModels?: readonly CliModel[]);
     private ensureToken;
     complete(req: CompletionRequest): Promise<ModelTurn>;
 }

package/dist/providers/openai-oauth.js

@@ -105,13 +105,19 @@ export class OpenAIOAuthProvider {
     env;
     now;
     id = "chatgpt";
-    label = "ChatGPT (abbonamento)";
-    models = CHATGPT_MODELS;
+    label = "ChatGPT";
+    models;
+    modelLabels;
     supportsFastMode = true;
-    constructor(creds, env, now = () => Date.now()) {
+    constructor(creds, env, now = () => Date.now(), 
+    // Modelli del CLI ufficiale installato; senza, il catalogo statico.
+    cliModels) {
         this.creds = creds;
         this.env = env;
         this.now = now;
+        this.models = cliModels?.length ? cliModels.map((model) => model.id) : CHATGPT_MODELS;
+        if (cliModels?.length)
+            this.modelLabels = new Map(cliModels.map((model) => [model.id, model]));
     }
     async ensureToken(signal) {
         if (!isExpired(this.creds, this.now()) || !this.creds.refreshToken) {

package/dist/providers/openrouter-manual-fallback.d.ts

@@ -1,16 +1,18 @@
 import type { OAuthFlow } from "./openrouter-auth.js";
+export type ManualTranslator = (italian: string, english: string, values?: Readonly<Record<string, string | number>>) => string;
 export declare function normalizeAuthCode(raw: string): string;
 export declare function isLikelyAuthCode(value: string): boolean;
 export interface ManualInstructions {
     readonly lines: readonly string[];
     readonly authUrl: string;
 }
-export declare function buildManualInstructions(authUrl: string, reason?: string): ManualInstructions;
+export declare function buildManualInstructions(authUrl: string, reason?: string, tr?: ManualTranslator): ManualInstructions;
 export interface ManualFallbackIo {
     print(line: string): void;
     prompt(label: string): Promise<string | null>;
 }
 export interface ManualFallbackOptions {
+    readonly translate?: ManualTranslator;
     readonly reason?: string;
     readonly maxAttempts?: number;
     readonly signal?: AbortSignal;

package/dist/providers/openrouter-manual-fallback.js

@@ -13,6 +13,7 @@
 // (niente accesso diretto a stdin/stdout/console), e lo scambio del code arriva
 // dall'OAuthFlow.complete gia' fornito da openrouter-auth.ts. Nessun side effect
 // nascosto, niente dipendenze a runtime.
+const defaultTranslation = (italian, _english, values) => italian.replace(/\{(\w+)\}/g, (match, key) => String(values?.[key] ?? match));
 // ---------------------------------------------------------------------------
 // Validazione / normalizzazione del code incollato
 // ---------------------------------------------------------------------------
@@ -91,26 +92,24 @@ export function isLikelyAuthCode(value) {
 // Costruisce le istruzioni per il percorso manuale. `reason` (opzionale) spiega
 // perche' siamo qui (es. "porta 8976 occupata", "nessun browser disponibile"):
 // se assente usiamo un messaggio neutro.
-export function buildManualInstructions(authUrl, reason) {
+export function buildManualInstructions(authUrl, reason, tr = defaultTranslation) {
     const why = (reason ?? "").trim();
     const lines = [];
-    lines.push("Login OpenRouter — modalita' manuale");
+    lines.push(tr("Login OpenRouter — modalita' manuale", "OpenRouter sign-in — manual mode"));
     if (why) {
-        lines.push(`(callback automatico non disponibile: ${why})`);
+        lines.push(tr("(callback automatico non disponibile: {reason})", "(automatic callback unavailable: {reason})", { reason: why }));
     }
     else {
-        lines.push("(callback automatico non disponibile: completiamo a mano)");
+        lines.push(tr("(callback automatico non disponibile: completiamo a mano)", "(automatic callback unavailable: complete sign-in manually)"));
     }
     lines.push("");
-    lines.push("1. Apri questo link nel browser (copialo se non e' cliccabile):");
+    lines.push(tr("1. Apri questo link nel browser (copialo se non e' cliccabile):", "1. Open this link in the browser (copy it if it is not clickable):"));
     lines.push(`   ${authUrl}`);
     lines.push("");
-    lines.push("2. Autorizza l'accesso su OpenRouter.");
-    lines.push("3. Verrai rediretto a un indirizzo localhost che potrebbe non");
-    lines.push("   aprirsi (\"impossibile raggiungere il sito\"): e' normale.");
-    lines.push("4. Copia il valore del parametro `code` dalla barra degli indirizzi");
-    lines.push("   (oppure incolla l'intero URL: estraggo io il code).");
-    lines.push("5. Incollalo qui sotto e premi Invio.");
+    lines.push(tr("2. Autorizza l'accesso su OpenRouter.", "2. Authorize access on OpenRouter."));
+    lines.push(tr("3. Verrai rediretto a un indirizzo localhost che potrebbe non aprirsi: e' normale.", "3. You will be redirected to a localhost address that may not open: this is normal."));
+    lines.push(tr("4. Copia il parametro `code` dalla barra degli indirizzi (oppure incolla l'intero URL).", "4. Copy the `code` parameter from the address bar (or paste the entire URL)."));
+    lines.push(tr("5. Incollalo qui sotto e premi Invio.", "5. Paste it below and press Enter."));
     return { lines, authUrl };
 }
 // Esegue il percorso di fallback manuale: mostra link+istruzioni, chiede il
@@ -118,15 +117,16 @@ export function buildManualInstructions(authUrl, reason) {
 // input invalido o scambio fallito, fino a maxAttempts o annullamento.
 export async function runManualCodeFallback(io, flow, opts = {}) {
     const maxAttempts = Math.max(1, Math.floor(opts.maxAttempts ?? 3));
-    const instructions = buildManualInstructions(flow.authUrl, opts.reason);
+    const tr = opts.translate ?? defaultTranslation;
+    const instructions = buildManualInstructions(flow.authUrl, opts.reason, tr);
     for (const line of instructions.lines)
         io.print(line);
     let attempts = 0;
     let lastError = "";
     while (attempts < maxAttempts) {
         const remaining = maxAttempts - attempts;
-        const hint = attempts === 0 ? "" : ` (tentativi rimasti: ${remaining})`;
-        const raw = await io.prompt(`Incolla il code${hint}`);
+        const hint = attempts === 0 ? "" : tr(" (tentativi rimasti: {count})", " (attempts remaining: {count})", { count: remaining });
+        const raw = await io.prompt(tr("Incolla il code{hint}", "Paste the code{hint}", { hint }));
         // Annullamento esplicito (Esc/EOF): usciamo subito senza consumare logica.
         if (raw === null) {
             return { ok: false, error: "cancelled", attempts };
@@ -134,9 +134,9 @@ export async function runManualCodeFallback(io, flow, opts = {}) {
         attempts += 1;
         const code = normalizeAuthCode(raw);
         if (!isLikelyAuthCode(code)) {
-            lastError = "code non riconosciuto";
+            lastError = tr("code non riconosciuto", "unrecognized code");
             if (attempts < maxAttempts) {
-                io.print("Input non valido: incolla il code (o l'intero URL del callback). Riprova.");
+                io.print(tr("Input non valido: incolla il code (o l'intero URL del callback). Riprova.", "Invalid input: paste the code (or the entire callback URL). Try again."));
             }
             continue;
         }
@@ -148,14 +148,14 @@ export async function runManualCodeFallback(io, flow, opts = {}) {
             result = { ok: false, error: err instanceof Error ? err.message : String(err) };
         }
         if (result.ok && result.apiKey) {
-            io.print("Autenticazione completata: API key ottenuta e salvata.");
+            io.print(tr("Autenticazione completata: API key ottenuta e salvata.", "Authentication complete: API key obtained and saved."));
             return { ok: true, apiKey: result.apiKey, attempts };
         }
-        lastError = result.error ?? "scambio fallito";
+        lastError = result.error ?? tr("scambio fallito", "exchange failed");
         if (attempts < maxAttempts) {
-            io.print(`Scambio fallito: ${lastError}. Verifica di aver copiato il code giusto e riprova.`);
+            io.print(tr("Scambio fallito: {error}. Verifica di aver copiato il code giusto e riprova.", "Exchange failed: {error}. Check that you copied the correct code and try again.", { error: lastError }));
         }
     }
-    io.print("Tentativi esauriti: login manuale non riuscito.");
+    io.print(tr("Tentativi esauriti: login manuale non riuscito.", "No attempts left: manual sign-in failed."));
     return { ok: false, error: lastError || "exhausted", attempts };
 }

package/dist/providers/registry.js

@@ -3,6 +3,7 @@ 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 { cachedCliModels } from "./cli-models.js";
 import { readOpenRouterCreds } from "./openrouter-auth.js";
 import { PROVIDER_CATALOG } from "./catalog.js";
 import { retryConfigFromEnv, withRetry } from "./retry.js";
@@ -202,11 +203,11 @@ export function defaultRegistry(env, opts = {}) {
     if (opts.detectOAuth !== false) {
         const claude = readClaudeCreds(env);
         if (claude)
-            add(new AnthropicOAuthProvider(claude, env));
+            add(new AnthropicOAuthProvider(claude, env, undefined, cachedCliModels("claude", env)));
         if (env["TALOS_DISABLE_CHATGPT_OAUTH"] !== "1") {
             const codex = readCodexCreds(env);
             if (codex)
-                add(new OpenAIOAuthProvider(codex, env));
+                add(new OpenAIOAuthProvider(codex, env, undefined, cachedCliModels("codex", env)));
         }
     }
     return reg;

package/dist/providers/retry.d.ts

@@ -1,5 +1,6 @@
 import type { CompletionRequest, ModelTurn, PlanLimits, Provider } from "../core/types.js";
 export interface RetryConfig {
+    readonly autoResumeSession?: boolean;
     readonly maxRetries: number;
     readonly baseDelayMs: number;
     readonly timeoutMs: number;
@@ -25,12 +26,14 @@ export declare class RetryProvider implements Provider {
     get id(): string;
     get label(): string | undefined;
     get models(): readonly string[];
+    get modelLabels(): Provider["modelLabels"];
     get supportsFastMode(): boolean;
     private get netMax();
     private get netDelay();
     private get overloadMaxAttempts();
     private overloadDelay;
     private waitForOverload;
+    private waitForSessionReset;
     complete(req: CompletionRequest): Promise<ModelTurn>;
     private backoff;
 }