@vascend/talos 0.1.4 → 0.1.6

package/dist/horizon/engine.js

@@ -9,7 +9,9 @@ import { runKingdomForHost } from "../vascend/kingdom-run.js";
 import { FileCoordinationHub, fileActor } from "../core/file-coordination.js";
 import { listSessions, sessionFilePath } from "../core/session.js";
 import { defaultRegistry, resolveStartupModel } from "../providers/registry.js";
+import { refreshCliModels } from "../providers/cli-models.js";
 import { listVibeModes, parseVibeMode, VIBE_MODE_IDS } from "../core/vibe-modes.js";
+import { fusionAvailability, fusionUnavailableMessage, parseFusion } from "../core/fusion.js";
 import { contextProjectKey, loadContextFrame, renderContextFrame, resetContextFrame, updateContextPins, } from "../vascend/context-fabric.js";
 import { AsyncQueue } from "./async-queue.js";
 import { MCP_APP_MIME_TYPE, MCP_PROTOCOL_VERSION, MCP_UI_EXTENSION_ID } from "../mcp/protocol.js";
@@ -32,6 +34,7 @@ export const HORIZON_CAPABILITIES = Object.freeze({
         abort: true,
         inputs: Object.freeze(["text", "content-parts"]),
         ephemeralContext: true,
+        turnSystem: true,
         // L'host puo' consegnare messaggi a turno in corso: entrano al primo
         // confine sicuro e l'evento `user_message` ne annuncia la presa in carico.
         midTurnInput: true,
@@ -48,6 +51,12 @@ export const HORIZON_CAPABILITIES = Object.freeze({
         receipts: true,
     }),
     vibe: Object.freeze({ routing: Object.freeze(["auto", "explicit"]), modes: Object.freeze([...VIBE_MODE_IDS]) }),
+    fusion: Object.freeze({
+        decider: "jev",
+        decisions: Object.freeze(["route", "focus", "gate"]),
+        gateModes: Object.freeze(["guard", "auto"]),
+        plans: "paid",
+    }),
     permissions: Object.freeze({ default: "deny", hostGate: true }),
     fileCoordination: Object.freeze({
         modes: Object.freeze(["viewing", "editing", "writing"]),
@@ -62,6 +71,15 @@ export const HORIZON_CAPABILITIES = Object.freeze({
         apps: Object.freeze({ extension: MCP_UI_EXTENSION_ID, mimeType: MCP_APP_MIME_TYPE }),
     }),
 });
+export class HorizonFusionUnavailableError extends Error {
+    reason;
+    code = "HORIZON_FUSION_UNAVAILABLE";
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+        this.name = "HorizonFusionUnavailableError";
+    }
+}
 export class HorizonStateError extends Error {
     code = "HORIZON_INVALID_STATE";
     constructor(message) {
@@ -191,6 +209,15 @@ export class HorizonEngine {
         const effective = resolveStartupModel(providers, requested).model;
         return modelCatalog(providers, effective);
     }
+    /**
+     * Come {@link inspectModels}, ma prima rilegge i modelli dai CLI ufficiali
+     * installati (claude, codex) quando sono cambiati: un Claude Code aggiornato
+     * espone subito i suoi modelli nuovi.
+     */
+    static async inspectModelsLive(options = {}) {
+        await refreshCliModels(options.env ?? process.env);
+        return HorizonEngine.inspectModels(options);
+    }
     get state() {
         return this.stateValue;
     }
@@ -257,6 +284,32 @@ export class HorizonEngine {
         this.harness.config = { ...this.harness.config, vibeMode: selection };
         return this.vibe();
     }
+    /**
+     * Stato Fusion. `tier` e' il piano della sessione Vascend dell'host, se lo
+     * conosce: serve solo a decidere cosa mostrare, il backend lo riverifica.
+     */
+    fusion(tier) {
+        this.assertOpen();
+        const availability = fusionAvailability(this.harness.env, tier, Boolean(this.options.fusionProxy));
+        return {
+            config: this.harness.config.fusion ?? null,
+            available: availability.ok,
+            channel: availability.channel,
+            ...(availability.ok ? {} : { reason: availability.reason, message: fusionUnavailableMessage(availability.reason) }),
+        };
+    }
+    /** Attiva (true o configurazione) o spegne (null/false) Fusion per i turni successivi. */
+    setFusion(value, tier) {
+        this.assertMutable();
+        const config = parseFusion(value) ?? null;
+        if (config) {
+            const availability = fusionAvailability(this.harness.env, tier, Boolean(this.options.fusionProxy));
+            if (!availability.ok)
+                throw new HorizonFusionUnavailableError(availability.reason, fusionUnavailableMessage(availability.reason));
+        }
+        this.harness.config = { ...this.harness.config, fusion: config };
+        return this.fusion(tier);
+    }
     contextStatus() {
         this.assertOpen();
         return this.contextSnapshot(this.currentFrame());
@@ -369,6 +422,7 @@ export class HorizonEngine {
                     ...base,
                     inbox,
                     spawnKingdom,
+                    ...(this.options.fusionProxy ? { jevProxy: this.options.fusionProxy } : {}),
                     ...(this.options.fileCoordination ? { fileCoordination: this.options.fileCoordination } : {}),
                     ...(options.fsRoots !== undefined ? { fsRoots: options.fsRoots } : {}),
                     ...(ephemeralContext !== undefined ? { ephemeralContext } : {}),
@@ -490,6 +544,7 @@ export class HorizonEngine {
             messages: this.harness.session.history().length,
             model: this.harness.config.model,
             vibeMode: this.harness.config.vibeMode,
+            fusion: this.harness.config.fusion ?? null,
         };
     }
     currentFrame() {
@@ -535,11 +590,13 @@ function errorMessage(value) {
     return value instanceof Error ? value.message : String(value);
 }
 function modelDescriptor(provider, modelId) {
+    const known = provider.modelLabels?.get(modelId);
     return {
         id: `${provider.id}/${modelId}`,
         modelId,
         providerId: provider.id,
         providerLabel: provider.label ?? provider.id,
+        ...(known ? { label: known.label, ...(known.description ? { description: known.description } : {}) } : {}),
     };
 }
 const DEFAULT_MODEL = "anthropic/claude-sonnet-4-6";

package/dist/horizon/index.d.ts

@@ -1,4 +1,4 @@
-export { HORIZON_CAPABILITIES, HorizonContextUnavailableError, HorizonEngine, HorizonSessionNotFoundError, HorizonStateError, routeWorkerModels, } from "./engine.js";
+export { HORIZON_CAPABILITIES, HorizonContextUnavailableError, HorizonFusionUnavailableError, HorizonEngine, HorizonSessionNotFoundError, HorizonStateError, routeWorkerModels, } from "./engine.js";
 export { HorizonMainTeam, needsGuideArbitration } from "./main-team.js";
-export type { HorizonCapabilityDescriptor, HorizonContextStatus, HorizonEngineOptions, HorizonEngineState, HorizonModelCatalog, HorizonModelDescriptor, HorizonModelInspectionOptions, HorizonProviderDescriptor, HorizonRuntime, HorizonSessionListItem, HorizonSessionSnapshot, HorizonTurn, HorizonTurnInput, HorizonTurnOptions, HorizonTurnResult, HorizonTurnStatus, HorizonVibeStatus, } from "./types.js";
+export type { HorizonCapabilityDescriptor, HorizonContextStatus, HorizonEngineOptions, HorizonEngineState, HorizonModelCatalog, HorizonModelDescriptor, HorizonModelInspectionOptions, HorizonProviderDescriptor, HorizonRuntime, HorizonSessionListItem, HorizonSessionSnapshot, HorizonTurn, HorizonTurnInput, HorizonTurnOptions, HorizonTurnResult, HorizonTurnStatus, HorizonVibeStatus, HorizonFusionStatus, } from "./types.js";
 export type { HorizonGuideCooperation, HorizonGuideDecision, HorizonGuideDecisionRecord, HorizonGuideDecisionRequest, HorizonGuidePlan, HorizonGuideTask, HorizonGuideVerdict, HorizonMainExchange, HorizonMainRef, HorizonMainTeamConfig, HorizonMainTeamEvent, HorizonMainTeamResult, HorizonMainTeamTurn, HorizonTeamRef, HorizonAgentPurpose, } from "./main-team.js";

package/dist/horizon/index.js

@@ -1,2 +1,2 @@
-export { HORIZON_CAPABILITIES, HorizonContextUnavailableError, HorizonEngine, HorizonSessionNotFoundError, HorizonStateError, routeWorkerModels, } from "./engine.js";
+export { HORIZON_CAPABILITIES, HorizonContextUnavailableError, HorizonFusionUnavailableError, HorizonEngine, HorizonSessionNotFoundError, HorizonStateError, routeWorkerModels, } from "./engine.js";
 export { HorizonMainTeam, needsGuideArbitration } from "./main-team.js";

package/dist/horizon/types.d.ts

@@ -3,6 +3,7 @@ import type { Harness } from "../core/bootstrap.js";
 import type { ContextLease, ContextReceipt } from "../vascend/context-fabric.js";
 import type { AgentEvent, ContentPart, ModelTurn } from "../core/types.js";
 import type { VibeModeId, VibeModeSelection, VibeModeSpec } from "../core/vibe-modes.js";
+import type { FusionConfig, FusionGateMode } from "../core/fusion.js";
 import type { FileCoordinationContext } from "../core/file-coordination.js";
 import type { ExecutionTarget } from "../core/execution-target.js";
 /** Lifecycle osservabile del facade headless. */
@@ -20,6 +21,11 @@ export interface HorizonEngineOptions {
     readonly env?: NodeJS.ProcessEnv;
     /** Evidenza host non persistente applicata ai turni, salvo override locale. */
     readonly ephemeralContext?: string;
+    /**
+     * Trasporto Jev per Fusion sul canale client: l'host inoltra il corpo
+     * all'endpoint Fusion di Vascend con la propria sessione.
+     */
+    readonly fusionProxy?: import("../fusion/jev.js").JevProxy;
     /** Permission gate dell'host. In assenza, Horizon nega ogni azione. */
     readonly confirm?: AgentDeps["confirm"];
     /** Canale headless per le domande del modello. In assenza, non viene esposto. */
@@ -105,6 +111,7 @@ export interface HorizonSessionSnapshot {
     readonly messages: number;
     readonly model: string;
     readonly vibeMode: VibeModeSelection;
+    readonly fusion: FusionConfig | null;
 }
 export interface HorizonSessionListItem {
     readonly id: string;
@@ -122,6 +129,9 @@ export interface HorizonModelDescriptor {
     readonly modelId: string;
     readonly providerId: string;
     readonly providerLabel: string;
+    /** Nome del modello secondo il provider (es. "Opus 5.5"), quando noto. */
+    readonly label?: string;
+    readonly description?: string;
 }
 /** Provider attivo nel registro Talos, senza credenziali o dettagli sensibili. */
 export interface HorizonProviderDescriptor {
@@ -174,6 +184,7 @@ export interface HorizonCapabilityDescriptor {
         readonly abort: true;
         readonly inputs: readonly ["text", "content-parts"];
         readonly ephemeralContext: true;
+        readonly turnSystem: true;
     };
     readonly mainTeam: {
         readonly agents: readonly [1, 2];
@@ -190,6 +201,12 @@ export interface HorizonCapabilityDescriptor {
         readonly routing: readonly ["auto", "explicit"];
         readonly modes: readonly VibeModeId[];
     };
+    readonly fusion: {
+        readonly decider: "jev";
+        readonly decisions: readonly ["route", "focus", "gate"];
+        readonly gateModes: readonly FusionGateMode[];
+        readonly plans: "paid";
+    };
     readonly permissions: {
         readonly default: "deny";
         readonly hostGate: true;
@@ -227,6 +244,18 @@ export interface HorizonRuntime {
     }): Promise<Harness>;
     runTurn(deps: AgentDeps, input: HorizonTurnInput, sink: (event: AgentEvent) => void, signal: AbortSignal): Promise<void>;
 }
+/**
+ * Fusion per l'host: configurazione attiva e disponibilita' su questa
+ * installazione. `available: false` spiega perche' (chiave dev mancante,
+ * login assente, piano free): l'host mostra la voce ma non la attiva.
+ */
+export interface HorizonFusionStatus {
+    readonly config: FusionConfig | null;
+    readonly available: boolean;
+    readonly channel: "dev" | "client";
+    readonly reason?: "missing_openrouter" | "missing_login" | "free_plan";
+    readonly message?: string;
+}
 export interface HorizonVibeStatus {
     readonly selected: VibeModeSelection;
     readonly modes: readonly VibeModeSpec[];

package/dist/index.js

@@ -10,6 +10,7 @@ import { startRepl } from "./tui/repl.js";
 import { startRpc } from "./rpc/server.js";
 import { proxyUrl } from "./providers/registry.js";
 import { CliArgumentError, cliHelp, parseCliArgs } from "./core/cli-args.js";
+import { InvalidConfigError } from "./core/config.js";
 function readStdin() {
     try {
         return readFileSync(0, "utf8").trim();
@@ -102,6 +103,11 @@ async function main() {
         process.exitCode = doctorExitCode(report);
         return;
     }
+    const { prepareStartupConfig } = await import("./tui/config-recovery.js");
+    if (!await prepareStartupConfig({ cwd: args.cwd, model: args.model, env }, args.mode === "tui" && Boolean(process.stdin.isTTY && process.stdout.isTTY))) {
+        process.exitCode = 2;
+        return;
+    }
     const trustPrompt = args.mode === "tui" && !args.approve && !args.noApprove
         ? (resources) => askTrust(resources)
         : undefined;
@@ -230,6 +236,12 @@ main().catch((err) => {
         process.stdout.write(`\n  ${err.message}\n\n`, () => process.exit(130));
         return;
     }
+    if (err instanceof InvalidConfigError) {
+        process.stderr.write(`errore: ${err.message}\n` +
+            `Correggi o ripristina il file JSON, quindi riavvia Talos. Il login non è stato avviato.\n`);
+        process.exitCode = 2;
+        return;
+    }
     const report = writeCrashReport(err, "main");
     process.stderr.write(`fatale: ${err instanceof Error ? err.stack ?? err.message : String(err)}\n`);
     if (report)

package/dist/providers/anthropic-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 AnthropicOAuthProvider implements Provider {
@@ -5,9 +6,13 @@ export declare class AnthropicOAuthProvider implements Provider {
     private readonly env;
     private readonly now;
     readonly id = "claude-code";
-    readonly label = "Claude Code (abbonamento)";
-    readonly models: readonly ["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"];
-    constructor(creds: OAuthCreds, env: NodeJS.ProcessEnv, now?: () => number);
+    readonly label = "Claude Code";
+    readonly models: readonly string[];
+    readonly modelLabels?: ReadonlyMap<string, {
+        readonly label: string;
+        readonly description?: string;
+    }>;
+    constructor(creds: OAuthCreds, env: NodeJS.ProcessEnv, now?: () => number, cliModels?: readonly CliModel[]);
     private ensureToken;
     complete(req: CompletionRequest): Promise<ModelTurn>;
 }

package/dist/providers/anthropic-oauth.js

@@ -1,6 +1,6 @@
 import { messaggioErroreTurno } from "../core/image-limits.js";
 import { planLimitsFromHeaders } from "./plan-limits.js";
-import { toApiMessages, parseStream, applyMessageCache, wants1m, CONTEXT_1M_BETA } from "./anthropic.js";
+import { claudePrompt, claudeCacheTtl, parseStream, wants1m, CONTEXT_1M_BETA } from "./anthropic.js";
 import { anthropicEffort } from "./effort.js";
 import { resolveMaxTokens } from "../core/model-limits.js";
 import { ANTHROPIC_MODELS } from "./catalog.js";
@@ -28,12 +28,18 @@ export class AnthropicOAuthProvider {
     env;
     now;
     id = "claude-code";
-    label = "Claude Code (abbonamento)";
-    models = ANTHROPIC_MODELS;
-    constructor(creds, env, now = () => Date.now()) {
+    label = "Claude Code";
+    models;
+    modelLabels;
+    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) : ANTHROPIC_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) {
@@ -74,18 +80,15 @@ export class AnthropicOAuthProvider {
                 stopReason: "error",
             };
         }
+        const prompt = claudePrompt(req, claudeCacheTtl(this.env));
         const body = {
             model: req.model,
             max_tokens: resolveMaxTokens(req.maxTokens, `anthropic/${req.model}`),
             system: [
                 { type: "text", text: CLAUDE_CODE_SYSTEM },
-                { type: "text", text: req.system, cache_control: { type: "ephemeral" } },
-                ...(req.turnContext ? [{
-                        type: "text",
-                        text: `[HORIZON_TURN_CONTEXT]\n${req.turnContext}\n[/HORIZON_TURN_CONTEXT]`,
-                    }] : []),
+                ...prompt.system,
             ],
-            messages: applyMessageCache(toApiMessages(req)),
+            messages: prompt.messages,
             stream: true,
             tools: req.tools.map((t) => ({
                 name: t.name,

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>;