@foxden-app/foxclaw 0.7.3 → 0.10.0

package/dist/store/database.js

@@ -7,7 +7,7 @@ export class BridgeStore {
     constructor(dbPath) {
         fs.mkdirSync(path.dirname(dbPath), { recursive: true });
         this.db = new DatabaseSync(dbPath);
-        this.db.exec(`
+        this.db.exec(`
       CREATE TABLE IF NOT EXISTS telegram_offsets (
         bot_key TEXT PRIMARY KEY,
         update_id INTEGER NOT NULL
@@ -18,23 +18,32 @@ export class BridgeStore {
         chat_id TEXT NOT NULL,
         updated_at INTEGER NOT NULL
       );
-      CREATE TABLE IF NOT EXISTS chat_bindings (
-        chat_id TEXT PRIMARY KEY,
-        thread_id TEXT NOT NULL,
-        cwd TEXT,
-        updated_at INTEGER NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS chat_settings (
-        chat_id TEXT PRIMARY KEY,
-        model TEXT,
+      CREATE TABLE IF NOT EXISTS chat_bindings (
+        chat_id TEXT PRIMARY KEY,
+        thread_id TEXT NOT NULL,
+        cwd TEXT,
+        updated_at INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS chat_settings (
+        chat_id TEXT PRIMARY KEY,
+        model TEXT,
         reasoning_effort TEXT,
         locale TEXT,
         access_preset TEXT,
         collaboration_mode TEXT,
         service_tier TEXT,
         active_turn_message_mode TEXT,
+        active_backend_id TEXT,
         updated_at INTEGER NOT NULL
       );
+      CREATE TABLE IF NOT EXISTS scope_backend_bindings (
+        scope_id TEXT NOT NULL,
+        backend_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
+        cwd TEXT,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (scope_id, backend_id)
+      );
       CREATE TABLE IF NOT EXISTS thread_cache (
         chat_id TEXT NOT NULL,
         idx INTEGER NOT NULL,
@@ -48,15 +57,15 @@ export class BridgeStore {
         updated_at INTEGER NOT NULL,
         PRIMARY KEY (chat_id, idx)
       );
-      CREATE TABLE IF NOT EXISTS pending_approvals (
-        local_id TEXT PRIMARY KEY,
-        server_request_id TEXT NOT NULL,
-        kind TEXT NOT NULL,
-        chat_id TEXT NOT NULL,
-        thread_id TEXT NOT NULL,
-        turn_id TEXT NOT NULL,
-        item_id TEXT NOT NULL,
-        approval_id TEXT,
+      CREATE TABLE IF NOT EXISTS pending_approvals (
+        local_id TEXT PRIMARY KEY,
+        server_request_id TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        item_id TEXT NOT NULL,
+        approval_id TEXT,
         reason TEXT,
         command TEXT,
         cwd TEXT,
@@ -64,7 +73,7 @@ export class BridgeStore {
         message_id INTEGER,
         created_at INTEGER NOT NULL,
         resolved_at INTEGER
-      );
+      );
       CREATE TABLE IF NOT EXISTS active_turn_previews (
         turn_id TEXT PRIMARY KEY,
         scope_id TEXT NOT NULL,
@@ -75,6 +84,11 @@ export class BridgeStore {
         created_at INTEGER NOT NULL,
         updated_at INTEGER NOT NULL
       );
+      CREATE TABLE IF NOT EXISTS watched_threads (
+        scope_id TEXT PRIMARY KEY,
+        thread_id TEXT NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
       CREATE TABLE IF NOT EXISTS pending_user_inputs (
         local_id TEXT PRIMARY KEY,
         server_request_id TEXT NOT NULL,
@@ -160,9 +174,9 @@ export class BridgeStore {
         direction TEXT NOT NULL,
         chat_id TEXT NOT NULL,
         event_type TEXT NOT NULL,
-        summary TEXT NOT NULL,
-        created_at INTEGER NOT NULL
-      );
+        summary TEXT NOT NULL,
+        created_at INTEGER NOT NULL
+      );
       CREATE TABLE IF NOT EXISTS weixin_context_tokens (
         scope_id TEXT PRIMARY KEY,
         context_token TEXT NOT NULL,
@@ -208,6 +222,15 @@ export class BridgeStore {
         delete_reason TEXT,
         invalid_delete_count INTEGER NOT NULL DEFAULT 0
       );
+      CREATE TABLE IF NOT EXISTS cumulative_token_usage (
+        backend_id TEXT PRIMARY KEY,
+        input_tokens INTEGER NOT NULL DEFAULT 0,
+        output_tokens INTEGER NOT NULL DEFAULT 0,
+        cached_tokens INTEGER NOT NULL DEFAULT 0,
+        total_tokens INTEGER NOT NULL DEFAULT 0,
+        turns_count INTEGER NOT NULL DEFAULT 0,
+        updated_at INTEGER NOT NULL
+      );
     `);
         this.ensureColumn('thread_cache', 'name', 'TEXT');
         this.ensureColumn('thread_cache', 'model_provider', 'TEXT');
@@ -218,6 +241,7 @@ export class BridgeStore {
         this.ensureColumn('chat_settings', 'collaboration_mode', 'TEXT');
         this.ensureColumn('chat_settings', 'service_tier', 'TEXT');
         this.ensureColumn('chat_settings', 'active_turn_message_mode', 'TEXT');
+        this.ensureColumn('chat_settings', 'active_backend_id', 'TEXT');
         this.ensureColumn('pending_approvals', 'payload_json', 'TEXT');
         this.ensureColumn('pending_user_inputs', 'status', "TEXT NOT NULL DEFAULT 'pending'");
         this.ensureColumn('pending_user_inputs', 'submitted_at', 'INTEGER');
@@ -226,12 +250,17 @@ export class BridgeStore {
         this.ensureColumn('codex_auth_candidates', 'state', "TEXT NOT NULL DEFAULT 'active'");
         this.ensureColumn('codex_auth_candidate_runtime', 'state', "TEXT NOT NULL DEFAULT 'active'");
         this.ensureColumn('codex_auth_quota_snapshots', 'plan_type', 'TEXT');
+        this.ensureColumn('codex_auth_quota_snapshots', 'quota_identity_id', "TEXT NOT NULL DEFAULT ''");
         this.ensureColumn('codex_auth_quota_snapshots', 'primary_window_duration_mins', 'REAL');
         this.ensureColumn('codex_auth_quota_snapshots', 'primary_resets_at', 'INTEGER');
         this.ensureColumn('codex_auth_quota_snapshots', 'secondary_window_duration_mins', 'REAL');
         this.ensureColumn('codex_auth_quota_snapshots', 'secondary_resets_at', 'INTEGER');
-        this.ensureColumn('codex_auth_quota_snapshots', 'quota_identity_id', "TEXT NOT NULL DEFAULT ''");
         this.ensureColumn('codex_auth_pool_history', 'invalid_delete_count', 'INTEGER NOT NULL DEFAULT 0');
+        this.ensureColumn('scope_backend_bindings', 'model', 'TEXT');
+        this.ensureColumn('scope_backend_bindings', 'reasoning_effort', 'TEXT');
+        this.ensureColumn('scope_backend_bindings', 'active_turn_message_mode', 'TEXT');
+        this.ensureColumn('scope_backend_bindings', 'service_tier', 'TEXT');
+        this.ensureColumn('scope_backend_bindings', 'access_preset', 'TEXT');
         this.db.prepare(`
       UPDATE codex_auth_quota_snapshots
       SET quota_identity_id = account_id
@@ -248,10 +277,10 @@ export class BridgeStore {
         return row?.update_id ?? 0;
     }
     setTelegramOffset(botKey, updateId) {
-        this.db.prepare(`
-      INSERT INTO telegram_offsets (bot_key, update_id)
-      VALUES (?, ?)
-      ON CONFLICT(bot_key) DO UPDATE SET update_id = excluded.update_id
+        this.db.prepare(`
+      INSERT INTO telegram_offsets (bot_key, update_id)
+      VALUES (?, ?)
+      ON CONFLICT(bot_key) DO UPDATE SET update_id = excluded.update_id
     `).run(botKey, updateId);
     }
     rememberTelegramPrivateScope(botId, scopeId, chatId) {
@@ -299,8 +328,28 @@ export class BridgeStore {
     clearBinding(chatId) {
         this.db.prepare('DELETE FROM chat_bindings WHERE chat_id = ?').run(chatId);
     }
+    getWatchedThread(chatId) {
+        const row = this.db.prepare('SELECT thread_id FROM watched_threads WHERE scope_id = ?').get(chatId);
+        return row?.thread_id ? String(row.thread_id) : null;
+    }
+    setWatchedThread(chatId, threadId) {
+        if (threadId) {
+            this.db.prepare(`
+        INSERT INTO watched_threads (scope_id, thread_id, updated_at)
+        VALUES (?, ?, ?)
+        ON CONFLICT(scope_id) DO UPDATE SET thread_id = excluded.thread_id, updated_at = excluded.updated_at
+      `).run(chatId, threadId, Date.now());
+        }
+        else {
+            this.db.prepare('DELETE FROM watched_threads WHERE scope_id = ?').run(chatId);
+        }
+    }
+    listWatchedThreads() {
+        const rows = this.db.prepare('SELECT scope_id, thread_id FROM watched_threads').all();
+        return rows.map((r) => ({ scopeId: String(r.scope_id), threadId: String(r.thread_id) }));
+    }
     getChatSettings(chatId) {
-        const row = this.db.prepare('SELECT chat_id, model, reasoning_effort, locale, access_preset, collaboration_mode, service_tier, active_turn_message_mode, updated_at FROM chat_settings WHERE chat_id = ?').get(chatId);
+        const row = this.db.prepare('SELECT chat_id, model, reasoning_effort, locale, access_preset, collaboration_mode, service_tier, active_turn_message_mode, active_backend_id, updated_at FROM chat_settings WHERE chat_id = ?').get(chatId);
         if (!row)
             return null;
         return {
@@ -312,33 +361,97 @@ export class BridgeStore {
             collaborationMode: normalizeCollaborationMode(row.collaboration_mode),
             serviceTier: row.service_tier === null ? null : String(row.service_tier),
             activeTurnMessageMode: normalizeActiveTurnMessageMode(row.active_turn_message_mode),
+            activeBackendId: row.active_backend_id === null || row.active_backend_id === undefined ? null : String(row.active_backend_id),
             updatedAt: Number(row.updated_at),
         };
     }
     setChatSettings(chatId, model, reasoningEffort, locale) {
         const current = this.getChatSettings(chatId);
         const nextLocale = locale === undefined ? current?.locale ?? null : locale;
-        this.writeChatSettings(chatId, model, reasoningEffort, nextLocale, current?.accessPreset ?? null, current?.collaborationMode ?? null, current?.serviceTier ?? null, current?.activeTurnMessageMode ?? null);
+        this.writeChatSettings(chatId, model, reasoningEffort, nextLocale, current?.accessPreset ?? null, current?.collaborationMode ?? null, current?.serviceTier ?? null, current?.activeTurnMessageMode ?? null, current?.activeBackendId ?? null);
     }
     setChatLocale(chatId, locale) {
         const current = this.getChatSettings(chatId);
-        this.writeChatSettings(chatId, current?.model ?? null, current?.reasoningEffort ?? null, locale, current?.accessPreset ?? null, current?.collaborationMode ?? null, current?.serviceTier ?? null, current?.activeTurnMessageMode ?? null);
+        this.writeChatSettings(chatId, current?.model ?? null, current?.reasoningEffort ?? null, locale, current?.accessPreset ?? null, current?.collaborationMode ?? null, current?.serviceTier ?? null, current?.activeTurnMessageMode ?? null, current?.activeBackendId ?? null);
     }
     setChatAccessPreset(chatId, accessPreset) {
         const current = this.getChatSettings(chatId);
-        this.writeChatSettings(chatId, current?.model ?? null, current?.reasoningEffort ?? null, current?.locale ?? null, accessPreset, current?.collaborationMode ?? null, current?.serviceTier ?? null, current?.activeTurnMessageMode ?? null);
+        this.writeChatSettings(chatId, current?.model ?? null, current?.reasoningEffort ?? null, current?.locale ?? null, accessPreset, current?.collaborationMode ?? null, current?.serviceTier ?? null, current?.activeTurnMessageMode ?? null, current?.activeBackendId ?? null);
     }
     setChatCollaborationMode(chatId, collaborationMode) {
         const current = this.getChatSettings(chatId);
-        this.writeChatSettings(chatId, current?.model ?? null, current?.reasoningEffort ?? null, current?.locale ?? null, current?.accessPreset ?? null, collaborationMode, current?.serviceTier ?? null, current?.activeTurnMessageMode ?? null);
+        this.writeChatSettings(chatId, current?.model ?? null, current?.reasoningEffort ?? null, current?.locale ?? null, current?.accessPreset ?? null, collaborationMode, current?.serviceTier ?? null, current?.activeTurnMessageMode ?? null, current?.activeBackendId ?? null);
     }
     setChatServiceTier(chatId, serviceTier) {
         const current = this.getChatSettings(chatId);
-        this.writeChatSettings(chatId, current?.model ?? null, current?.reasoningEffort ?? null, current?.locale ?? null, current?.accessPreset ?? null, current?.collaborationMode ?? null, serviceTier, current?.activeTurnMessageMode ?? null);
+        this.writeChatSettings(chatId, current?.model ?? null, current?.reasoningEffort ?? null, current?.locale ?? null, current?.accessPreset ?? null, current?.collaborationMode ?? null, serviceTier, current?.activeTurnMessageMode ?? null, current?.activeBackendId ?? null);
     }
     setChatActiveTurnMessageMode(chatId, activeTurnMessageMode) {
         const current = this.getChatSettings(chatId);
-        this.writeChatSettings(chatId, current?.model ?? null, current?.reasoningEffort ?? null, current?.locale ?? null, current?.accessPreset ?? null, current?.collaborationMode ?? null, current?.serviceTier ?? null, activeTurnMessageMode);
+        this.writeChatSettings(chatId, current?.model ?? null, current?.reasoningEffort ?? null, current?.locale ?? null, current?.accessPreset ?? null, current?.collaborationMode ?? null, current?.serviceTier ?? null, activeTurnMessageMode, current?.activeBackendId ?? null);
+    }
+    getActiveBackend(chatId) {
+        return this.getChatSettings(chatId)?.activeBackendId ?? null;
+    }
+    setActiveBackend(chatId, backendId) {
+        const current = this.getChatSettings(chatId);
+        this.writeChatSettings(chatId, current?.model ?? null, current?.reasoningEffort ?? null, current?.locale ?? null, current?.accessPreset ?? null, current?.collaborationMode ?? null, current?.serviceTier ?? null, current?.activeTurnMessageMode ?? null, backendId);
+    }
+    getScopeBackendBinding(scopeId, backendId) {
+        const row = this.db.prepare(`
+      SELECT thread_id, cwd, model, reasoning_effort, active_turn_message_mode, service_tier, access_preset
+      FROM scope_backend_bindings
+      WHERE scope_id = ? AND backend_id = ?
+    `).get(scopeId, backendId);
+        if (!row)
+            return null;
+        return {
+            threadId: String(row.thread_id),
+            cwd: row.cwd ? String(row.cwd) : null,
+            model: row.model === null || row.model === undefined ? null : String(row.model),
+            reasoningEffort: row.reasoning_effort === null || row.reasoning_effort === undefined ? null : String(row.reasoning_effort),
+            activeTurnMessageMode: row.active_turn_message_mode === null || row.active_turn_message_mode === undefined ? null : String(row.active_turn_message_mode),
+            serviceTier: row.service_tier === null || row.service_tier === undefined ? null : String(row.service_tier),
+            accessPreset: row.access_preset === null || row.access_preset === undefined ? null : String(row.access_preset),
+        };
+    }
+    setScopeBackendBinding(scopeId, backendId, threadId, cwd, settings) {
+        const current = this.getScopeBackendBinding(scopeId, backendId);
+        const model = settings && settings.model !== undefined ? settings.model : current?.model ?? null;
+        const reasoningEffort = settings && settings.reasoningEffort !== undefined ? settings.reasoningEffort : current?.reasoningEffort ?? null;
+        const activeTurnMessageMode = settings && settings.activeTurnMessageMode !== undefined ? settings.activeTurnMessageMode : current?.activeTurnMessageMode ?? null;
+        const serviceTier = settings && settings.serviceTier !== undefined ? settings.serviceTier : current?.serviceTier ?? null;
+        const accessPreset = settings && settings.accessPreset !== undefined ? settings.accessPreset : current?.accessPreset ?? null;
+        this.db.prepare(`
+      INSERT INTO scope_backend_bindings (
+        scope_id, backend_id, thread_id, cwd, model, reasoning_effort,
+        active_turn_message_mode, service_tier, access_preset, updated_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(scope_id, backend_id) DO UPDATE SET
+        thread_id = excluded.thread_id,
+        cwd = excluded.cwd,
+        model = excluded.model,
+        reasoning_effort = excluded.reasoning_effort,
+        active_turn_message_mode = excluded.active_turn_message_mode,
+        service_tier = excluded.service_tier,
+        access_preset = excluded.access_preset,
+        updated_at = excluded.updated_at
+    `).run(scopeId, backendId, threadId, cwd, model, reasoningEffort, activeTurnMessageMode, serviceTier, accessPreset, Date.now());
+    }
+    listScopeBackendBindings(scopeId) {
+        const rows = this.db.prepare(`
+      SELECT backend_id, thread_id, cwd, updated_at
+      FROM scope_backend_bindings
+      WHERE scope_id = ?
+      ORDER BY updated_at DESC
+    `).all(scopeId);
+        return rows.map((r) => ({
+            backendId: String(r.backend_id),
+            threadId: String(r.thread_id),
+            cwd: r.cwd ? String(r.cwd) : null,
+            updatedAt: Number(r.updated_at),
+        }));
     }
     findChatIdByThreadId(threadId) {
         const row = this.db.prepare('SELECT chat_id FROM chat_bindings WHERE thread_id = ?').get(threadId);
@@ -365,7 +478,7 @@ export class BridgeStore {
         });
     }
     getCachedThread(chatId, index) {
-        const row = this.db.prepare(`
+        const row = this.db.prepare(`
       SELECT idx, thread_id, name, preview, cwd, model_provider, status, archived, updated_at
       FROM thread_cache
       WHERE chat_id = ? AND idx = ?
@@ -385,11 +498,11 @@ export class BridgeStore {
         };
     }
     listCachedThreads(chatId) {
-        const rows = this.db.prepare(`
+        const rows = this.db.prepare(`
       SELECT idx, thread_id, name, preview, cwd, model_provider, status, archived, updated_at
       FROM thread_cache
       WHERE chat_id = ?
-      ORDER BY idx ASC
+      ORDER BY idx ASC
     `).all(chatId);
         return rows.map((row) => ({
             index: Number(row.idx),
@@ -404,7 +517,7 @@ export class BridgeStore {
         }));
     }
     savePendingApproval(record) {
-        this.db.prepare(`
+        this.db.prepare(`
       INSERT INTO pending_approvals (
         local_id, server_request_id, kind, chat_id, thread_id, turn_id, item_id, approval_id, reason, command, cwd, payload_json, message_id, created_at, resolved_at
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
@@ -833,10 +946,10 @@ export class BridgeStore {
             resolvedAt: row.resolved_at === null ? null : Number(row.resolved_at),
         };
     }
-    writeChatSettings(chatId, model, reasoningEffort, locale, accessPreset, collaborationMode, serviceTier, activeTurnMessageMode) {
+    writeChatSettings(chatId, model, reasoningEffort, locale, accessPreset, collaborationMode, serviceTier, activeTurnMessageMode, activeBackendId = null) {
         this.db.prepare(`
-      INSERT INTO chat_settings (chat_id, model, reasoning_effort, locale, access_preset, collaboration_mode, service_tier, active_turn_message_mode, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO chat_settings (chat_id, model, reasoning_effort, locale, access_preset, collaboration_mode, service_tier, active_turn_message_mode, active_backend_id, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(chat_id) DO UPDATE SET
         model = excluded.model,
         reasoning_effort = excluded.reasoning_effort,
@@ -845,8 +958,9 @@ export class BridgeStore {
         collaboration_mode = excluded.collaboration_mode,
         service_tier = excluded.service_tier,
         active_turn_message_mode = excluded.active_turn_message_mode,
+        active_backend_id = excluded.active_backend_id,
         updated_at = excluded.updated_at
-    `).run(chatId, model, reasoningEffort, locale, accessPreset, collaborationMode, serviceTier, activeTurnMessageMode, Date.now());
+    `).run(chatId, model, reasoningEffort, locale, accessPreset, collaborationMode, serviceTier, activeTurnMessageMode, activeBackendId, Date.now());
     }
     getWeixinContextToken(scopeId) {
         const row = this.db.prepare('SELECT context_token FROM weixin_context_tokens WHERE scope_id = ?').get(scopeId);
@@ -1071,6 +1185,91 @@ export class BridgeStore {
             updatedAt: Number(row.updated_at),
         }));
     }
+    recordTokenUsage(delta, backendId = 'default') {
+        const input = Math.max(0, Math.round(delta.inputTokens ?? 0));
+        const output = Math.max(0, Math.round(delta.outputTokens ?? 0));
+        const cached = Math.max(0, Math.round(delta.cachedTokens ?? 0));
+        const total = delta.totalTokens != null ? Math.max(0, Math.round(delta.totalTokens)) : input + output;
+        const now = Date.now();
+        this.db.prepare(`
+      INSERT INTO cumulative_token_usage (backend_id, input_tokens, output_tokens, cached_tokens, total_tokens, turns_count, updated_at)
+      VALUES (?, ?, ?, ?, ?, 1, ?)
+      ON CONFLICT(backend_id) DO UPDATE SET
+        input_tokens = cumulative_token_usage.input_tokens + excluded.input_tokens,
+        output_tokens = cumulative_token_usage.output_tokens + excluded.output_tokens,
+        cached_tokens = cumulative_token_usage.cached_tokens + excluded.cached_tokens,
+        total_tokens = cumulative_token_usage.total_tokens + excluded.total_tokens,
+        turns_count = cumulative_token_usage.turns_count + 1,
+        updated_at = excluded.updated_at
+    `).run(backendId, input, output, cached, total, now);
+    }
+    setBackendCumulativeTokenUsage(usage, backendId) {
+        const input = Math.max(0, Math.round(usage.inputTokens));
+        const output = Math.max(0, Math.round(usage.outputTokens));
+        const cached = Math.max(0, Math.round(usage.cachedTokens ?? 0));
+        const total = usage.totalTokens != null ? Math.max(0, Math.round(usage.totalTokens)) : input + output;
+        const turns = Math.max(0, Math.round(usage.turnsCount ?? 0));
+        const now = Date.now();
+        this.db.prepare(`
+      INSERT INTO cumulative_token_usage (backend_id, input_tokens, output_tokens, cached_tokens, total_tokens, turns_count, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(backend_id) DO UPDATE SET
+        input_tokens = excluded.input_tokens,
+        output_tokens = excluded.output_tokens,
+        cached_tokens = excluded.cached_tokens,
+        total_tokens = excluded.total_tokens,
+        turns_count = excluded.turns_count,
+        updated_at = excluded.updated_at
+    `).run(backendId, input, output, cached, total, turns, now);
+    }
+    getCumulativeTokenUsage(backendId) {
+        if (backendId && backendId !== 'all') {
+            const row = this.db.prepare(`
+        SELECT input_tokens, output_tokens, cached_tokens, total_tokens, turns_count
+        FROM cumulative_token_usage
+        WHERE backend_id = ?
+      `).get(backendId);
+            return {
+                inputTokens: Number(row?.input_tokens ?? 0),
+                outputTokens: Number(row?.output_tokens ?? 0),
+                cachedTokens: Number(row?.cached_tokens ?? 0),
+                totalTokens: Number(row?.total_tokens ?? 0),
+                turnsCount: Number(row?.turns_count ?? 0),
+            };
+        }
+        const row = this.db.prepare(`
+      SELECT
+        COALESCE(SUM(input_tokens), 0) AS input_tokens,
+        COALESCE(SUM(output_tokens), 0) AS output_tokens,
+        COALESCE(SUM(cached_tokens), 0) AS cached_tokens,
+        COALESCE(SUM(total_tokens), 0) AS total_tokens,
+        COALESCE(SUM(turns_count), 0) AS turns_count
+      FROM cumulative_token_usage
+    `).get();
+        return {
+            inputTokens: Number(row?.input_tokens ?? 0),
+            outputTokens: Number(row?.output_tokens ?? 0),
+            cachedTokens: Number(row?.cached_tokens ?? 0),
+            totalTokens: Number(row?.total_tokens ?? 0),
+            turnsCount: Number(row?.turns_count ?? 0),
+        };
+    }
+    getAllBackendTokenUsages() {
+        const rows = this.db.prepare(`
+      SELECT backend_id, input_tokens, output_tokens, cached_tokens, total_tokens, turns_count, updated_at
+      FROM cumulative_token_usage
+      ORDER BY total_tokens DESC
+    `).all();
+        return rows.map((r) => ({
+            backendId: r.backend_id,
+            inputTokens: Number(r.input_tokens),
+            outputTokens: Number(r.output_tokens),
+            cachedTokens: Number(r.cached_tokens),
+            totalTokens: Number(r.total_tokens),
+            turnsCount: Number(r.turns_count),
+            updatedAt: Number(r.updated_at),
+        }));
+    }
     ensureColumn(table, column, definition) {
         const columns = this.db.prepare(`PRAGMA table_info(${table})`).all();
         if (columns.some(entry => entry.name === column)) {

package/dist/store/token_usage.d.ts

@@ -0,0 +1,23 @@
+import type { AppLocale } from '../types.js';
+import type { BridgeStore } from './database.js';
+export interface CumulativeTokenTotals {
+    inputTokens: number;
+    outputTokens: number;
+    cachedTokens: number;
+    totalTokens: number;
+    turnsCount: number;
+}
+export interface CumulativeTokenUsageRecord extends CumulativeTokenTotals {
+    backendId: string;
+    updatedAt: number;
+}
+export interface TokenUsageDelta {
+    inputTokens?: number | undefined;
+    outputTokens?: number | undefined;
+    cachedTokens?: number | undefined;
+    totalTokens?: number | undefined;
+}
+export declare function formatMetricTokenCount(value: number): string;
+export declare function formatTokenUsageSummary(totals: CumulativeTokenTotals, locale?: AppLocale): string;
+export declare function formatBackendTokenUsageBreakdown(usages: CumulativeTokenUsageRecord[]): string;
+export declare function syncCodexLocalUsageToStore(store: BridgeStore, codexHome?: string): Promise<void>;

package/dist/store/token_usage.js

@@ -0,0 +1,61 @@
+import { readCodexLocalUsageStats } from '../codex_app/local_usage.js';
+export function formatMetricTokenCount(value) {
+    if (!Number.isFinite(value) || value <= 0) {
+        return '0';
+    }
+    if (value >= 1_000_000_000) {
+        const g = value / 1_000_000_000;
+        return `${Number.isInteger(g) ? g : Number(g.toFixed(2))}G`;
+    }
+    if (value >= 1_000_000) {
+        const m = value / 1_000_000;
+        return `${Number.isInteger(m) ? m : Number(m.toFixed(2))}M`;
+    }
+    if (value >= 1_000) {
+        const k = value / 1_000;
+        return `${Number.isInteger(k) ? k : Number(k.toFixed(1))}K`;
+    }
+    return String(Math.round(value));
+}
+export function formatTokenUsageSummary(totals, locale = 'zh') {
+    const total = formatMetricTokenCount(totals.totalTokens);
+    const input = formatMetricTokenCount(totals.inputTokens);
+    const output = formatMetricTokenCount(totals.outputTokens);
+    const cached = formatMetricTokenCount(totals.cachedTokens);
+    if (locale === 'zh') {
+        return `• **Token 用量**: 总计 ${total} (输入 ${input}, 输出 ${output}, 缓存 ${cached})`;
+    }
+    return `• **Token Usage**: Total ${total} (Input ${input}, Output ${output}, Cached ${cached})`;
+}
+export function formatBackendTokenUsageBreakdown(usages) {
+    if (usages.length <= 1)
+        return '';
+    const labels = {
+        antigravity: 'AGY',
+        codex: 'Codex',
+        opencode: 'OpenCode',
+    };
+    const parts = usages
+        .filter((u) => u.totalTokens > 0)
+        .map((u) => `${labels[u.backendId] || u.backendId}: ${formatMetricTokenCount(u.totalTokens)}`);
+    if (parts.length <= 1)
+        return '';
+    return `\n  └ ${parts.join(' · ')}`;
+}
+export async function syncCodexLocalUsageToStore(store, codexHome) {
+    try {
+        const stats = await readCodexLocalUsageStats(codexHome);
+        if (stats.totals.totalTokens > 0 || stats.turns > 0) {
+            store.setBackendCumulativeTokenUsage({
+                inputTokens: stats.totals.inputTokens,
+                outputTokens: stats.totals.outputTokens,
+                cachedTokens: stats.totals.cachedInputTokens,
+                totalTokens: stats.totals.totalTokens,
+                turnsCount: stats.turns,
+            }, 'codex');
+        }
+    }
+    catch {
+        // Non-fatal if codex home is unavailable
+    }
+}

package/dist/telegram/api.js

@@ -4,7 +4,18 @@ import https from 'node:https';
 import path from 'node:path';
 import { pipeline } from 'node:stream/promises';
 const DEFAULT_API_BASE_URL = 'https://api.telegram.org';
-export async function callTelegramApi(botToken, method, body) {
+function isTransientNetworkError(err) {
+    if (!err)
+        return false;
+    const msg = String(err.message || err);
+    return (msg.includes('Client network socket disconnected') ||
+        msg.includes('ECONNRESET') ||
+        msg.includes('ETIMEDOUT') ||
+        msg.includes('EAI_AGAIN') ||
+        msg.includes('ENOTFOUND') ||
+        msg.includes('socket hang up'));
+}
+function callTelegramApiOnce(botToken, method, body) {
     const payload = JSON.stringify(body);
     const endpoint = telegramApiUrl(botToken, method);
     return new Promise((resolve, reject) => {
@@ -39,6 +50,24 @@ export async function callTelegramApi(botToken, method, body) {
         request.end();
     });
 }
+export async function callTelegramApi(botToken, method, body) {
+    const maxAttempts = method === 'getUpdates' ? 1 : 3;
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await callTelegramApiOnce(botToken, method, body);
+        }
+        catch (err) {
+            lastError = err;
+            if (attempt < maxAttempts && isTransientNetworkError(err)) {
+                await new Promise((r) => setTimeout(r, 400 * attempt));
+                continue;
+            }
+            throw err;
+        }
+    }
+    throw lastError;
+}
 export async function callTelegramMultipartApi(botToken, method, fields, files) {
     const boundary = `foxclaw-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
     const parts = [];

package/dist/telegram/gateway.d.ts

@@ -100,6 +100,10 @@ export declare class TelegramGateway extends EventEmitter {
     downloadResolvedFile(remoteFilePath: string, destinationPath: string): Promise<number>;
     private resolveBotIdentity;
     private registerCommands;
+    setChatCommands(chatId: number | string, commands: Array<{
+        command: string;
+        description: string;
+    }>): Promise<void>;
     private pollLoop;
     private handleUpdate;
     private isAllowedChat;

package/dist/telegram/gateway.js

@@ -248,6 +248,17 @@ export class TelegramGateway extends EventEmitter {
             language_code: 'zh',
         });
     }
+    async setChatCommands(chatId, commands) {
+        try {
+            await callTelegramApi(this.botToken, 'setMyCommands', {
+                commands,
+                scope: { type: 'chat', chat_id: chatId },
+            });
+        }
+        catch (err) {
+            this.logger.warn('telegram.set_chat_commands_failed', { chatId, error: String(err) });
+        }
+    }
     async pollLoop() {
         let remoteInitialized = false;
         while (this.running) {

package/dist/types.d.ts

@@ -23,6 +23,7 @@ export interface ChatSessionSettings {
     collaborationMode: CollaborationModeValue | null;
     serviceTier: string | null;
     activeTurnMessageMode: ActiveTurnMessageMode | null;
+    activeBackendId?: string | null;
     updatedAt: number;
 }
 export type QueuedTurnInputStatus = 'queued' | 'processing' | 'completed' | 'cancelled' | 'failed';

package/dist/update.d.ts

@@ -12,6 +12,9 @@ export interface SelfUpdateStatus {
     codexUpdate?: string | null;
     codexFromVersion?: string | null;
     codexToVersion?: string | null;
+    agyUpdate?: string | null;
+    agyFromVersion?: string | null;
+    agyToVersion?: string | null;
     error: string | null;
     updatedAt: string;
 }
@@ -34,6 +37,7 @@ interface CreateSelfUpdateRuntimeOptions {
     statusPath: string;
     logPath: string;
     codexCliBin?: string;
+    agyCliBin?: string;
     pendingTimeoutMs?: number;
     now?: () => Date;
 }
@@ -44,6 +48,7 @@ interface PerformSelfUpdateOptions {
     notificationFile?: string;
     clusterBroadcastFile?: string;
     codexCliBin?: string;
+    agyCliBin?: string;
     env?: NodeJS.ProcessEnv;
 }
 export interface SelfUpdateLaunchCommand {
@@ -77,6 +82,7 @@ export declare function buildSelfUpdateLaunchCommand(options: {
     statusFile: string;
     logPath: string;
     codexCliBin?: string;
+    agyCliBin?: string;
     env?: NodeJS.ProcessEnv;
     platform?: NodeJS.Platform;
     systemdRunPath?: string | null;