alvin-bot 4.5.1 → 4.7.0

package/dist/services/session.js

@@ -27,15 +27,20 @@ export function getSession(key) {
             totalCost: 0,
             costByProvider: {},
             queriesByProvider: {},
-            effort: "high",
+            effort: "medium",
             voiceReply: false,
             messageCount: 0,
             toolUseCount: 0,
             totalInputTokens: 0,
             totalOutputTokens: 0,
+            lastTurnInputTokens: 0,
+            compactionCount: 0,
+            checkpointHintsInjected: 0,
+            sdkSubTaskCount: 0,
             history: [],
             language: "en",
             messageQueue: [],
+            lastSdkHistoryIndex: -1,
         };
         sessions.set(k, session);
     }
@@ -56,7 +61,12 @@ export function resetSession(key) {
     session.toolUseCount = 0;
     session.totalInputTokens = 0;
     session.totalOutputTokens = 0;
+    session.lastTurnInputTokens = 0;
+    session.compactionCount = 0;
+    session.checkpointHintsInjected = 0;
+    session.sdkSubTaskCount = 0;
     session.history = [];
+    session.lastSdkHistoryIndex = -1;
     session.startedAt = Date.now();
     // Reset budget warning flags so the user gets fresh warnings in the new session.
     session._budgetWarned80 = false;
@@ -138,13 +148,21 @@ export function stopSessionCleanup() {
         cleanupTimer = null;
     }
 }
-/** Add a message to conversation history (for non-SDK providers). */
+/** Add a message to conversation history. Unified across all provider types
+ * — SDK providers resume from their filesystem session but we still track the
+ * transcript here so failovers (and the B2 bridge-message) have context. */
 export function addToHistory(key, message) {
     const session = getSession(key);
     session.history.push(message);
-    // Trim oldest messages if history gets too long
+    // Trim oldest messages if history gets too long. Adjust lastSdkHistoryIndex
+    // by the number of dropped entries so it keeps pointing at the correct
+    // (now shifted) assistant turn — or collapses to -1 if it falls off the front.
     if (session.history.length > MAX_HISTORY) {
+        const dropped = session.history.length - MAX_HISTORY;
         session.history = session.history.slice(-MAX_HISTORY);
+        if (session.lastSdkHistoryIndex >= 0) {
+            session.lastSdkHistoryIndex = Math.max(-1, session.lastSdkHistoryIndex - dropped);
+        }
     }
 }
 /** Get all active sessions (for web UI session browser). */

package/dist/services/subagent-delivery.js

@@ -0,0 +1,266 @@
+/**
+ * Sub-Agent Delivery Router (I3) — context-aware rendering of sub-agent
+ * results into Telegram. Source decides the delivery path:
+ *   - implicit → no-op (main stream already shows the Task-tool result)
+ *   - user     → banner+final as a new message in parentChatId
+ *   - cron     → banner+final in chatId from the CronJob target
+ *
+ * The caller is responsible for passing a correct `parentChatId` on the
+ * SubAgentInfo. Lookup of the bot API is lazy so we can unit-test the
+ * module with a fake bot via __setBotApiForTest.
+ */
+import { getVisibility } from "./subagents.js";
+const MAX_TG_CHUNK = 3800; // below Telegram's 4096 limit with headroom
+const FILE_UPLOAD_THRESHOLD = 20_000; // switch to .md file upload above this
+let injectedApi = null;
+let runtimeApi = null;
+/** Test-only hook for injecting a fake bot API. Production code must NEVER call this. */
+export function __setBotApiForTest(api) {
+    injectedApi = api;
+}
+/** Wire the grammy bot API once at startup (called from src/index.ts). */
+export function attachBotApi(api) {
+    runtimeApi = api;
+}
+function getBotApi() {
+    return injectedApi ?? runtimeApi;
+}
+function formatTokens(n) {
+    if (n < 1000)
+        return `${n}`;
+    return `${(n / 1000).toFixed(1)}k`;
+}
+function formatDuration(ms) {
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    const rem = s - m * 60;
+    return `${m}m ${rem}s`;
+}
+function statusIcon(status) {
+    switch (status) {
+        case "completed": return "✅";
+        case "timeout": return "⏱️";
+        case "cancelled": return "⚠️";
+        case "error": return "❌";
+    }
+}
+function buildBanner(info, result) {
+    const icon = statusIcon(result.status);
+    const dur = formatDuration(result.duration);
+    const ti = formatTokens(result.tokensUsed.input);
+    const to = formatTokens(result.tokensUsed.output);
+    return `${icon} *${info.name}* ${result.status} · ${dur} · ${ti} in / ${to} out`;
+}
+// ── A4 Live-Stream ──────────────────────────────────────────
+/**
+ * Per-spawn live-stream state. Edits a single Telegram message as the
+ * sub-agent produces text, throttled to ~800ms between edits. Posts a
+ * separate banner message at finalize so the user gets a completion
+ * notification (edits don't trigger Telegram notifications).
+ *
+ * The live message uses plain text (no parse_mode) so half-formed
+ * markdown during streaming can never crash the edit. The final banner
+ * does use markdown.
+ */
+const LIVE_EDIT_THROTTLE_MS = 800;
+const LIVE_INITIAL_TEXT = (name) => `⏳ ${name} thinking…`;
+export class LiveStream {
+    api;
+    chatId;
+    agentName;
+    messageId = null;
+    lastEditAt = 0;
+    pendingText = null;
+    pendingTimer = null;
+    started = false;
+    failed = false;
+    constructor(api, chatId, agentName) {
+        this.api = api;
+        this.chatId = chatId;
+        this.agentName = agentName;
+    }
+    /** Post the initial placeholder message. Called before the first chunk. */
+    async start() {
+        if (!this.api.editMessageText) {
+            this.failed = true;
+            console.warn(`[subagent-live] bot api has no editMessageText — falling back`);
+            return;
+        }
+        try {
+            const initial = LIVE_INITIAL_TEXT(this.agentName);
+            const msg = await this.api.sendMessage(this.chatId, initial);
+            const msgId = msg.message_id;
+            if (typeof msgId === "number") {
+                this.messageId = msgId;
+                this.lastEditAt = Date.now();
+                this.started = true;
+            }
+            else {
+                console.warn(`[subagent-live] sendMessage returned no message_id`);
+                this.failed = true;
+            }
+        }
+        catch (err) {
+            console.error(`[subagent-live] start failed:`, err);
+            this.failed = true;
+        }
+    }
+    /**
+     * Record a new accumulated text state. Will schedule a throttled edit
+     * ~800ms after the previous edit. Later updates that arrive before
+     * the throttled flush coalesce — only the latest text is used.
+     */
+    update(text) {
+        if (!this.started || this.failed || this.messageId === null)
+            return;
+        this.pendingText = text;
+        if (this.pendingTimer)
+            return;
+        const elapsed = Date.now() - this.lastEditAt;
+        const delay = Math.max(0, LIVE_EDIT_THROTTLE_MS - elapsed);
+        this.pendingTimer = setTimeout(() => {
+            this.flush().catch((err) => {
+                console.warn(`[subagent-live] scheduled flush failed:`, err);
+            });
+        }, delay);
+    }
+    async flush() {
+        this.pendingTimer = null;
+        if (!this.pendingText || this.messageId === null || this.failed)
+            return;
+        if (!this.api.editMessageText) {
+            this.failed = true;
+            return;
+        }
+        // Cap edit length — Telegram rejects >4096 chars
+        const body = this.pendingText.slice(0, MAX_TG_CHUNK);
+        const display = `⏳ ${this.agentName}\n\n${body}`;
+        try {
+            await this.api.editMessageText(this.chatId, this.messageId, display);
+            this.lastEditAt = Date.now();
+        }
+        catch (err) {
+            // "message is not modified" is harmless (same content as before)
+            const msg = err instanceof Error ? err.message : String(err);
+            if (!/not modified/i.test(msg)) {
+                console.warn(`[subagent-live] edit failed:`, msg);
+            }
+        }
+        this.pendingText = null;
+    }
+    /**
+     * Flush any pending edit, then post the final banner as a new message
+     * so the user gets a notification. The live-stream message stays in
+     * place as the body; the banner is a separate message above/below it.
+     */
+    async finalize(info, result) {
+        if (this.pendingTimer) {
+            clearTimeout(this.pendingTimer);
+            this.pendingTimer = null;
+        }
+        if (this.pendingText) {
+            await this.flush();
+        }
+        this.started = false;
+        if (this.failed)
+            return;
+        // One last edit to remove the "thinking…" header (replace with final text)
+        if (this.messageId !== null && this.api.editMessageText) {
+            const finalBody = (result.output?.trim() || "(empty output)").slice(0, MAX_TG_CHUNK);
+            const finalDisplay = `${info.name}\n\n${finalBody}`;
+            try {
+                await this.api.editMessageText(this.chatId, this.messageId, finalDisplay);
+            }
+            catch {
+                // If the final edit fails, the "thinking…" header stays —
+                // the banner below will still communicate completion.
+            }
+        }
+        // Post the banner as a new message (notification-triggering)
+        const banner = buildBanner(info, result);
+        try {
+            await this.api.sendMessage(this.chatId, banner, { parse_mode: "Markdown" });
+        }
+        catch (err) {
+            console.error(`[subagent-live] finalize banner failed:`, err);
+            this.failed = true;
+            throw err;
+        }
+    }
+}
+/**
+ * Factory for LiveStream — returns null if the bot api isn't attached
+ * yet, or if the api doesn't support editMessageText. Callers check
+ * the return value and fall back to normal delivery if null.
+ */
+export function createLiveStream(chatId, agentName) {
+    const api = getBotApi();
+    if (!api || !api.editMessageText) {
+        console.warn(`[subagent-live] no compatible bot api — live mode unavailable`);
+        return null;
+    }
+    return new LiveStream(api, chatId, agentName);
+}
+// ── Main delivery entry point ───────────────────────────────
+/**
+ * Main delivery entry point. Resolves the effective visibility (override →
+ * config default), then dispatches to the source-specific renderer.
+ *
+ * Errors are logged but never thrown — delivery must not break the sub-agent
+ * lifecycle. A failed Telegram send falls through silently.
+ */
+export async function deliverSubAgentResult(info, result, opts = {}) {
+    // Implicit spawns: the Task-tool bridge in the main stream has already
+    // surfaced the output; extra delivery would be duplication.
+    if (info.source === "implicit")
+        return;
+    const effective = opts.visibility ?? getVisibility();
+    if (effective === "silent")
+        return;
+    // "live" mode is handled inline by runSubAgent via LiveStream. If we
+    // get here with "live" visibility it means the live-stream path wasn't
+    // applicable (wrong source, missing editMessageText, etc.) — fall
+    // through to the normal banner+final behavior below.
+    const api = getBotApi();
+    if (!api) {
+        console.warn(`[subagent-delivery] no bot api available for ${info.name}`);
+        return;
+    }
+    if (!info.parentChatId) {
+        console.warn(`[subagent-delivery] missing parentChatId for ${info.name} (source=${info.source})`);
+        return;
+    }
+    const banner = buildBanner(info, result);
+    const body = result.output?.trim() || `(empty output)`;
+    try {
+        // Case 1: very long output → file upload with a short banner
+        if (body.length > FILE_UPLOAD_THRESHOLD) {
+            await api.sendMessage(info.parentChatId, banner, { parse_mode: "Markdown" });
+            try {
+                const { InputFile } = await import("grammy");
+                const buf = Buffer.from(body, "utf-8");
+                await api.sendDocument(info.parentChatId, new InputFile(buf, `${info.name}.md`));
+            }
+            catch (err) {
+                console.error(`[subagent-delivery] file upload failed:`, err);
+                await api.sendMessage(info.parentChatId, body.slice(0, MAX_TG_CHUNK));
+            }
+            return;
+        }
+        // Case 2: fits in a single message → banner + body joined
+        if (body.length + banner.length + 2 <= MAX_TG_CHUNK) {
+            await api.sendMessage(info.parentChatId, `${banner}\n\n${body}`, { parse_mode: "Markdown" });
+            return;
+        }
+        // Case 3: medium output → banner as its own message, body chunked
+        await api.sendMessage(info.parentChatId, banner, { parse_mode: "Markdown" });
+        for (let i = 0; i < body.length; i += MAX_TG_CHUNK) {
+            await api.sendMessage(info.parentChatId, body.slice(i, i + MAX_TG_CHUNK));
+        }
+    }
+    catch (err) {
+        console.error(`[subagent-delivery] send failed for ${info.name}:`, err);
+    }
+}

package/dist/services/subagent-stats.js

@@ -0,0 +1,123 @@
+/**
+ * Sub-Agent Stats (H3) — rolling 24h aggregation of per-agent run data.
+ *
+ * Append-only JSON ring buffer persisted to ~/.alvin-bot/subagent-stats.json.
+ * On load, entries older than 24h are pruned. On each append, entries older
+ * than 24h are pruned.
+ *
+ * Used by /subagents stats to show run totals per source (user, cron, implicit)
+ * over the last 24 hours. No SQLite dependency — when a real SQLite migration
+ * lands we can swap the backend without touching the consumer API.
+ */
+import os from "os";
+import fs from "fs";
+import { resolve, dirname } from "path";
+const DATA_DIR = process.env.ALVIN_DATA_DIR || resolve(os.homedir(), ".alvin-bot");
+const STATS_FILE = resolve(DATA_DIR, "subagent-stats.json");
+const WINDOW_MS = 24 * 60 * 60 * 1000; // 24 hours
+const MAX_ENTRIES = 5000; // hard cap to prevent unbounded growth on high-frequency bots
+let cache = null;
+function load() {
+    if (cache)
+        return cache;
+    try {
+        const raw = fs.readFileSync(STATS_FILE, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) {
+            cache = [];
+            return cache;
+        }
+        // Prune stale entries (> 24h old) on load
+        const cutoff = Date.now() - WINDOW_MS;
+        cache = parsed.filter((e) => typeof e === "object" &&
+            e !== null &&
+            typeof e.completedAt === "number" &&
+            e.completedAt >= cutoff);
+        return cache;
+    }
+    catch {
+        cache = [];
+        return cache;
+    }
+}
+function save(entries) {
+    try {
+        fs.mkdirSync(dirname(STATS_FILE), { recursive: true });
+        fs.writeFileSync(STATS_FILE, JSON.stringify(entries, null, 0), "utf-8");
+    }
+    catch (err) {
+        console.error("[subagent-stats] failed to write:", err);
+    }
+}
+/**
+ * Record a completed sub-agent run. Called from runSubAgent.finally() via
+ * a side-effect hook. Automatically prunes entries older than 24h and
+ * keeps the file bounded at MAX_ENTRIES.
+ */
+export function recordSubAgentRun(info, result) {
+    const entries = load();
+    const cutoff = Date.now() - WINDOW_MS;
+    // Prune in-place
+    const pruned = entries.filter((e) => e.completedAt >= cutoff);
+    const newEntry = {
+        completedAt: Date.now(),
+        name: info.name,
+        source: (info.source ?? "implicit"),
+        status: result.status,
+        durationMs: result.duration,
+        inputTokens: result.tokensUsed.input,
+        outputTokens: result.tokensUsed.output,
+    };
+    pruned.push(newEntry);
+    // Enforce hard cap — oldest entries drop first
+    const final = pruned.length > MAX_ENTRIES ? pruned.slice(-MAX_ENTRIES) : pruned;
+    cache = final;
+    save(final);
+}
+/**
+ * Compute a summary of the last 24h of sub-agent runs. Safe to call
+ * concurrently with recordSubAgentRun — both read from the same cache.
+ */
+export function getSubAgentStats() {
+    const entries = load();
+    const cutoff = Date.now() - WINDOW_MS;
+    const recent = entries.filter((e) => e.completedAt >= cutoff);
+    const empty = () => ({
+        runs: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        totalDurationMs: 0,
+    });
+    const bySource = {
+        user: empty(),
+        cron: empty(),
+        implicit: empty(),
+    };
+    const byStatus = {
+        completed: 0,
+        timeout: 0,
+        error: 0,
+        cancelled: 0,
+    };
+    const total = empty();
+    for (const e of recent) {
+        const bucket = bySource[e.source] ?? bySource.implicit;
+        bucket.runs += 1;
+        bucket.inputTokens += e.inputTokens;
+        bucket.outputTokens += e.outputTokens;
+        bucket.totalDurationMs += e.durationMs;
+        total.runs += 1;
+        total.inputTokens += e.inputTokens;
+        total.outputTokens += e.outputTokens;
+        total.totalDurationMs += e.durationMs;
+        byStatus[e.status] = (byStatus[e.status] ?? 0) + 1;
+    }
+    return { windowHours: 24, total, bySource, byStatus };
+}
+/**
+ * Reset the in-memory cache — for test isolation. Does NOT delete the
+ * file; use ALVIN_DATA_DIR in tests to point at a fresh temp dir.
+ */
+export function __resetStatsCacheForTest() {
+    cache = null;
+}