@poolzin/pool-bot 2026.2.25 → 2026.2.26

package/dist/infra/provider-usage.fetch.gemini.js

@@ -1,4 +1,4 @@
-import { fetchJson } from "./provider-usage.fetch.shared.js";
+import { buildUsageHttpErrorSnapshot, fetchJson } from "./provider-usage.fetch.shared.js";
 import { clampPercent, PROVIDER_LABELS } from "./provider-usage.shared.js";
 export async function fetchGeminiUsage(token, timeoutMs, fetchFn, provider) {
     const res = await fetchJson("https://cloudcode-pa.googleapis.com/v1internal:retrieveUserQuota", {
@@ -10,20 +10,19 @@ export async function fetchGeminiUsage(token, timeoutMs, fetchFn, provider) {
         body: "{}",
     }, timeoutMs, fetchFn);
     if (!res.ok) {
-        return {
+        return buildUsageHttpErrorSnapshot({
             provider,
-            displayName: PROVIDER_LABELS[provider],
-            windows: [],
-            error: `HTTP ${res.status}`,
-        };
+            status: res.status,
+        });
     }
     const data = (await res.json());
     const quotas = {};
     for (const bucket of data.buckets || []) {
         const model = bucket.modelId || "unknown";
         const frac = bucket.remainingFraction ?? 1;
-        if (!quotas[model] || frac < quotas[model])
+        if (!quotas[model] || frac < quotas[model]) {
             quotas[model] = frac;
+        }
     }
     const windows = [];
     let proMin = 1;
@@ -34,24 +33,28 @@ export async function fetchGeminiUsage(token, timeoutMs, fetchFn, provider) {
         const lower = model.toLowerCase();
         if (lower.includes("pro")) {
             hasPro = true;
-            if (frac < proMin)
+            if (frac < proMin) {
                 proMin = frac;
+            }
         }
         if (lower.includes("flash")) {
             hasFlash = true;
-            if (frac < flashMin)
+            if (frac < flashMin) {
                 flashMin = frac;
+            }
         }
     }
-    if (hasPro)
+    if (hasPro) {
         windows.push({
             label: "Pro",
             usedPercent: clampPercent((1 - proMin) * 100),
         });
-    if (hasFlash)
+    }
+    if (hasFlash) {
         windows.push({
             label: "Flash",
             usedPercent: clampPercent((1 - flashMin) * 100),
         });
+    }
     return { provider, displayName: PROVIDER_LABELS[provider], windows };
 }

package/dist/infra/provider-usage.fetch.shared.js

@@ -1,6 +1,7 @@
+import { PROVIDER_LABELS } from "./provider-usage.shared.js";
 export async function fetchJson(url, init, timeoutMs, fetchFn) {
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const timer = setTimeout(controller.abort.bind(controller), timeoutMs);
     try {
         return await fetchFn(url, { ...init, signal: controller.signal });
     }
@@ -8,3 +9,31 @@ export async function fetchJson(url, init, timeoutMs, fetchFn) {
         clearTimeout(timer);
     }
 }
+export function parseFiniteNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string") {
+        const parsed = Number.parseFloat(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+export function buildUsageErrorSnapshot(provider, error) {
+    return {
+        provider,
+        displayName: PROVIDER_LABELS[provider],
+        windows: [],
+        error,
+    };
+}
+export function buildUsageHttpErrorSnapshot(options) {
+    const tokenExpiredStatuses = options.tokenExpiredStatuses ?? [];
+    if (tokenExpiredStatuses.includes(options.status)) {
+        return buildUsageErrorSnapshot(options.provider, "Token expired");
+    }
+    const suffix = options.message?.trim() ? `: ${options.message.trim()}` : "";
+    return buildUsageErrorSnapshot(options.provider, `HTTP ${options.status}${suffix}`);
+}

package/dist/infra/provider-usage.fetch.zai.js

@@ -1,4 +1,4 @@
-import { fetchJson } from "./provider-usage.fetch.shared.js";
+import { buildUsageHttpErrorSnapshot, fetchJson } from "./provider-usage.fetch.shared.js";
 import { clampPercent, PROVIDER_LABELS } from "./provider-usage.shared.js";
 export async function fetchZaiUsage(apiKey, timeoutMs, fetchFn) {
     const res = await fetchJson("https://api.z.ai/api/monitor/usage/quota/limit", {
@@ -9,12 +9,10 @@ export async function fetchZaiUsage(apiKey, timeoutMs, fetchFn) {
         },
     }, timeoutMs, fetchFn);
     if (!res.ok) {
-        return {
+        return buildUsageHttpErrorSnapshot({
             provider: "zai",
-            displayName: PROVIDER_LABELS.zai,
-            windows: [],
-            error: `HTTP ${res.status}`,
-        };
+            status: res.status,
+        });
     }
     const data = (await res.json());
     if (!data.success || data.code !== 200) {
@@ -31,12 +29,15 @@ export async function fetchZaiUsage(apiKey, timeoutMs, fetchFn) {
         const percent = clampPercent(limit.percentage || 0);
         const nextReset = limit.nextResetTime ? new Date(limit.nextResetTime).getTime() : undefined;
         let windowLabel = "Limit";
-        if (limit.unit === 1)
+        if (limit.unit === 1) {
             windowLabel = `${limit.number}d`;
-        else if (limit.unit === 3)
+        }
+        else if (limit.unit === 3) {
             windowLabel = `${limit.number}h`;
-        else if (limit.unit === 5)
+        }
+        else if (limit.unit === 5) {
             windowLabel = `${limit.number}m`;
+        }
         if (limit.type === "TOKENS_LIMIT") {
             windows.push({
                 label: `Tokens (${windowLabel})`,

package/dist/infra/retry-policy.js

@@ -1,4 +1,5 @@
 import { RateLimitError } from "@buape/carbon";
+import { createSubsystemLogger } from "../logging/subsystem.js";
 import { formatErrorMessage } from "./errors.js";
 import { resolveRetryConfig, retryAsync } from "./retry.js";
 export const DISCORD_RETRY_DEFAULTS = {
@@ -13,6 +14,7 @@ export const TELEGRAM_RETRY_DEFAULTS = {
     maxDelayMs: 30_000,
     jitter: 0.1,
 };
+const log = createSubsystemLogger("retry-policy");
 const TELEGRAM_RETRY_RE = /429|timeout|connect|reset|closed|unavailable|temporarily/i;
 function getTelegramRetryAfterMs(err) {
     if (!err || typeof err !== "object")
@@ -43,7 +45,7 @@ export function createDiscordRetryRunner(params) {
             ? (info) => {
                 const labelText = info.label ?? "request";
                 const maxRetries = Math.max(1, info.maxAttempts - 1);
-                console.warn(`discord ${labelText} rate limited, retry ${info.attempt}/${maxRetries} in ${info.delayMs}ms`);
+                log.warn(`discord ${labelText} rate limited, retry ${info.attempt}/${maxRetries} in ${info.delayMs}ms`);
             }
             : undefined,
     });
@@ -64,7 +66,7 @@ export function createTelegramRetryRunner(params) {
         onRetry: params.verbose
             ? (info) => {
                 const maxRetries = Math.max(1, info.maxAttempts - 1);
-                console.warn(`telegram send retry ${info.attempt}/${maxRetries} for ${info.label ?? label ?? "request"} in ${info.delayMs}ms: ${formatErrorMessage(info.err)}`);
+                log.warn(`telegram send retry ${info.attempt}/${maxRetries} for ${info.label ?? label ?? "request"} in ${info.delayMs}ms: ${formatErrorMessage(info.err)}`);
             }
             : undefined,
     });

package/dist/infra/retry.js

@@ -1,15 +1,16 @@
+import { sleep } from "../utils.js";
 const DEFAULT_RETRY_CONFIG = {
     attempts: 3,
     minDelayMs: 300,
     maxDelayMs: 30_000,
     jitter: 0,
 };
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 const asFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
 const clampNumber = (value, fallback, min, max) => {
     const next = asFiniteNumber(value);
-    if (next === undefined)
+    if (next === undefined) {
         return fallback;
+    }
     const floor = typeof min === "number" ? min : Number.NEGATIVE_INFINITY;
     const ceiling = typeof max === "number" ? max : Number.POSITIVE_INFINITY;
     return Math.min(Math.max(next, floor), ceiling);
@@ -22,8 +23,9 @@ export function resolveRetryConfig(defaults = DEFAULT_RETRY_CONFIG, overrides) {
     return { attempts, minDelayMs, maxDelayMs, jitter };
 }
 function applyJitter(delayMs, jitter) {
-    if (jitter <= 0)
+    if (jitter <= 0) {
         return delayMs;
+    }
     const offset = (Math.random() * 2 - 1) * jitter;
     return Math.max(0, Math.round(delayMs * (1 + offset)));
 }
@@ -37,8 +39,9 @@ export async function retryAsync(fn, attemptsOrOptions = 3, initialDelayMs = 300
             }
             catch (err) {
                 lastErr = err;
-                if (i === attempts - 1)
+                if (i === attempts - 1) {
                     break;
+                }
                 const delay = initialDelayMs * 2 ** i;
                 await sleep(delay);
             }
@@ -61,8 +64,9 @@ export async function retryAsync(fn, attemptsOrOptions = 3, initialDelayMs = 300
         }
         catch (err) {
             lastErr = err;
-            if (attempt >= maxAttempts || !shouldRetry(err, attempt))
+            if (attempt >= maxAttempts || !shouldRetry(err, attempt)) {
                 break;
+            }
             const retryAfterMs = options.retryAfterMs?.(err);
             const hasRetryAfter = typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs);
             const baseDelay = hasRetryAfter

package/dist/infra/session-cost-usage.js

@@ -2,7 +2,9 @@ import fs from "node:fs";
 import path from "node:path";
 import readline from "node:readline";
 import { normalizeUsage } from "../agents/usage.js";
+import { stripInboundMetadata } from "../auto-reply/reply/strip-inbound-meta.js";
 import { resolveSessionFilePath, resolveSessionTranscriptsDirForAgent, } from "../config/sessions/paths.js";
+import { stripEnvelope, stripMessageIdHints } from "../shared/chat-envelope.js";
 import { countToolResults, extractToolCallNames } from "../utils/transcript-tools.js";
 import { estimateUsageCost, resolveModelCostConfig } from "../utils/usage-format.js";
 const emptyTotals = () => ({
@@ -105,7 +107,7 @@ const computeLatencyStats = (values) => {
     if (!values.length) {
         return undefined;
     }
-    const sorted = [...values].sort((a, b) => a - b);
+    const sorted = values.toSorted((a, b) => a - b);
     const total = sorted.reduce((sum, v) => sum + v, 0);
     const count = sorted.length;
     const p95Index = Math.max(0, Math.ceil(count * 0.95) - 1);
@@ -144,33 +146,47 @@ const applyCostTotal = (totals, costTotal) => {
     }
     totals.totalCost += costTotal;
 };
-async function scanTranscriptFile(params) {
-    const fileStream = fs.createReadStream(params.filePath, { encoding: "utf-8" });
+async function* readJsonlRecords(filePath) {
+    const fileStream = fs.createReadStream(filePath, { encoding: "utf-8" });
     const rl = readline.createInterface({ input: fileStream, crlfDelay: Infinity });
-    for await (const line of rl) {
-        const trimmed = line.trim();
-        if (!trimmed) {
-            continue;
-        }
-        try {
-            const parsed = JSON.parse(trimmed);
-            const entry = parseTranscriptEntry(parsed);
-            if (!entry) {
+    try {
+        for await (const line of rl) {
+            const trimmed = line.trim();
+            if (!trimmed) {
                 continue;
             }
-            if (entry.usage && entry.costTotal === undefined) {
-                const cost = resolveModelCostConfig({
-                    provider: entry.provider,
-                    model: entry.model,
-                    config: params.config,
-                });
-                entry.costTotal = estimateUsageCost({ usage: entry.usage, cost });
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (!parsed || typeof parsed !== "object") {
+                    continue;
+                }
+                yield parsed;
+            }
+            catch {
+                // Ignore malformed lines
             }
-            params.onEntry(entry);
         }
-        catch {
-            // Ignore malformed lines
+    }
+    finally {
+        rl.close();
+        fileStream.destroy();
+    }
+}
+async function scanTranscriptFile(params) {
+    for await (const parsed of readJsonlRecords(params.filePath)) {
+        const entry = parseTranscriptEntry(parsed);
+        if (!entry) {
+            continue;
         }
+        if (entry.usage && entry.costTotal === undefined) {
+            const cost = resolveModelCostConfig({
+                provider: entry.provider,
+                model: entry.model,
+                config: params.config,
+            });
+            entry.costTotal = estimateUsageCost({ usage: entry.usage, cost });
+        }
+        params.onEntry(entry);
     }
 }
 async function scanUsageFile(params) {
@@ -257,7 +273,7 @@ export async function loadCostUsageSummary(params) {
     }
     const daily = Array.from(dailyMap.entries())
         .map(([date, bucket]) => Object.assign({ date }, bucket))
-        .sort((a, b) => a.date.localeCompare(b.date));
+        .toSorted((a, b) => a.date.localeCompare(b.date));
     // Calculate days for backwards compatibility in response
     const days = Math.ceil((untilTime - sinceTime) / (24 * 60 * 60 * 1000)) + 1;
     return {
@@ -294,15 +310,8 @@ export async function discoverAllSessions(params) {
         // Try to read first user message for label extraction
         let firstUserMessage;
         try {
-            const fileStream = fs.createReadStream(filePath, { encoding: "utf-8" });
-            const rl = readline.createInterface({ input: fileStream, crlfDelay: Infinity });
-            for await (const line of rl) {
-                const trimmed = line.trim();
-                if (!trimmed) {
-                    continue;
-                }
+            for await (const parsed of readJsonlRecords(filePath)) {
                 try {
-                    const parsed = JSON.parse(trimmed);
                     const message = parsed.message;
                     if (message?.role === "user") {
                         const content = message.content;
@@ -329,8 +338,6 @@ export async function discoverAllSessions(params) {
                     // Skip malformed lines
                 }
             }
-            rl.close();
-            fileStream.destroy();
         }
         catch {
             // Ignore read errors
@@ -343,11 +350,15 @@ export async function discoverAllSessions(params) {
         });
     }
     // Sort by mtime descending (most recent first)
-    return discovered.sort((a, b) => b.mtime - a.mtime);
+    return discovered.toSorted((a, b) => b.mtime - a.mtime);
 }
 export async function loadSessionCostSummary(params) {
     const sessionFile = params.sessionFile ??
-        (params.sessionId ? resolveSessionFilePath(params.sessionId, params.sessionEntry) : undefined);
+        (params.sessionId
+            ? resolveSessionFilePath(params.sessionId, params.sessionEntry, {
+                agentId: params.agentId,
+            })
+            : undefined);
     if (!sessionFile || !fs.existsSync(sessionFile)) {
         return null;
     }
@@ -527,8 +538,8 @@ export async function loadSessionCostSummary(params) {
     // Convert daily map to sorted array
     const dailyBreakdown = Array.from(dailyMap.entries())
         .map(([date, data]) => ({ date, tokens: data.tokens, cost: data.cost }))
-        .sort((a, b) => a.date.localeCompare(b.date));
-    const dailyMessageCounts = Array.from(dailyMessageMap.values()).sort((a, b) => a.date.localeCompare(b.date));
+        .toSorted((a, b) => a.date.localeCompare(b.date));
+    const dailyMessageCounts = Array.from(dailyMessageMap.values()).toSorted((a, b) => a.date.localeCompare(b.date));
     const dailyLatency = Array.from(dailyLatencyMap.entries())
         .map(([date, values]) => {
         const stats = computeLatencyStats(values);
@@ -538,19 +549,19 @@ export async function loadSessionCostSummary(params) {
         return { date, ...stats };
     })
         .filter((entry) => Boolean(entry))
-        .sort((a, b) => a.date.localeCompare(b.date));
-    const dailyModelUsage = Array.from(dailyModelUsageMap.values()).sort((a, b) => a.date.localeCompare(b.date) || b.cost - a.cost);
+        .toSorted((a, b) => a.date.localeCompare(b.date));
+    const dailyModelUsage = Array.from(dailyModelUsageMap.values()).toSorted((a, b) => a.date.localeCompare(b.date) || b.cost - a.cost);
     const toolUsage = toolUsageMap.size
         ? {
             totalCalls: Array.from(toolUsageMap.values()).reduce((sum, count) => sum + count, 0),
             uniqueTools: toolUsageMap.size,
             tools: Array.from(toolUsageMap.entries())
                 .map(([name, count]) => ({ name, count }))
-                .sort((a, b) => b.count - a.count),
+                .toSorted((a, b) => b.count - a.count),
         }
         : undefined;
     const modelUsage = modelUsageMap.size
-        ? Array.from(modelUsageMap.values()).sort((a, b) => {
+        ? Array.from(modelUsageMap.values()).toSorted((a, b) => {
             const costDiff = b.totals.totalCost - a.totals.totalCost;
             if (costDiff !== 0) {
                 return costDiff;
@@ -566,7 +577,7 @@ export async function loadSessionCostSummary(params) {
         durationMs: firstActivity !== undefined && lastActivity !== undefined
             ? Math.max(0, lastActivity - firstActivity)
             : undefined,
-        activityDates: Array.from(activityDatesSet).sort(),
+        activityDates: Array.from(activityDatesSet).toSorted(),
         dailyBreakdown,
         dailyMessageCounts,
         dailyLatency: dailyLatency.length ? dailyLatency : undefined,
@@ -580,7 +591,11 @@ export async function loadSessionCostSummary(params) {
 }
 export async function loadSessionUsageTimeSeries(params) {
     const sessionFile = params.sessionFile ??
-        (params.sessionId ? resolveSessionFilePath(params.sessionId, params.sessionEntry) : undefined);
+        (params.sessionId
+            ? resolveSessionFilePath(params.sessionId, params.sessionEntry, {
+                agentId: params.agentId,
+            })
+            : undefined);
     if (!sessionFile || !fs.existsSync(sessionFile)) {
         return null;
     }
@@ -617,18 +632,47 @@ export async function loadSessionUsageTimeSeries(params) {
         },
     });
     // Sort by timestamp
-    const sortedPoints = points.sort((a, b) => a.timestamp - b.timestamp);
+    const sortedPoints = points.toSorted((a, b) => a.timestamp - b.timestamp);
     // Optionally downsample if too many points
     const maxPoints = params.maxPoints ?? 100;
     if (sortedPoints.length > maxPoints) {
         const step = Math.ceil(sortedPoints.length / maxPoints);
         const downsampled = [];
+        let downsampledCumulativeTokens = 0;
+        let downsampledCumulativeCost = 0;
         for (let i = 0; i < sortedPoints.length; i += step) {
-            downsampled.push(sortedPoints[i]);
-        }
-        // Always include the last point
-        if (downsampled[downsampled.length - 1] !== sortedPoints[sortedPoints.length - 1]) {
-            downsampled.push(sortedPoints[sortedPoints.length - 1]);
+            const bucket = sortedPoints.slice(i, i + step);
+            const bucketLast = bucket[bucket.length - 1];
+            if (!bucketLast) {
+                continue;
+            }
+            let bucketInput = 0;
+            let bucketOutput = 0;
+            let bucketCacheRead = 0;
+            let bucketCacheWrite = 0;
+            let bucketTotalTokens = 0;
+            let bucketCost = 0;
+            for (const point of bucket) {
+                bucketInput += point.input;
+                bucketOutput += point.output;
+                bucketCacheRead += point.cacheRead;
+                bucketCacheWrite += point.cacheWrite;
+                bucketTotalTokens += point.totalTokens;
+                bucketCost += point.cost;
+            }
+            downsampledCumulativeTokens += bucketTotalTokens;
+            downsampledCumulativeCost += bucketCost;
+            downsampled.push({
+                timestamp: bucketLast.timestamp,
+                input: bucketInput,
+                output: bucketOutput,
+                cacheRead: bucketCacheRead,
+                cacheWrite: bucketCacheWrite,
+                totalTokens: bucketTotalTokens,
+                cost: bucketCost,
+                cumulativeTokens: downsampledCumulativeTokens,
+                cumulativeCost: downsampledCumulativeCost,
+            });
         }
         return { sessionId: params.sessionId, points: downsampled };
     }
@@ -636,21 +680,18 @@ export async function loadSessionUsageTimeSeries(params) {
 }
 export async function loadSessionLogs(params) {
     const sessionFile = params.sessionFile ??
-        (params.sessionId ? resolveSessionFilePath(params.sessionId, params.sessionEntry) : undefined);
+        (params.sessionId
+            ? resolveSessionFilePath(params.sessionId, params.sessionEntry, {
+                agentId: params.agentId,
+            })
+            : undefined);
     if (!sessionFile || !fs.existsSync(sessionFile)) {
         return null;
     }
     const logs = [];
     const limit = params.limit ?? 50;
-    const fileStream = fs.createReadStream(sessionFile, { encoding: "utf-8" });
-    const rl = readline.createInterface({ input: fileStream, crlfDelay: Infinity });
-    for await (const line of rl) {
-        const trimmed = line.trim();
-        if (!trimmed) {
-            continue;
-        }
+    for await (const parsed of readJsonlRecords(sessionFile)) {
         try {
-            const parsed = JSON.parse(trimmed);
             const message = parsed.message;
             if (!message) {
                 continue;
@@ -718,6 +759,13 @@ export async function loadSessionLogs(params) {
             if (!content) {
                 continue;
             }
+            content = stripInboundMetadata(content);
+            if (role === "user") {
+                content = stripMessageIdHints(stripEnvelope(content)).trim();
+            }
+            if (!content) {
+                continue;
+            }
             // Truncate very long content
             const maxLen = 2000;
             if (content.length > maxLen) {
@@ -771,7 +819,7 @@ export async function loadSessionLogs(params) {
         }
     }
     // Sort by timestamp and limit
-    const sortedLogs = logs.sort((a, b) => a.timestamp - b.timestamp);
+    const sortedLogs = logs.toSorted((a, b) => a.timestamp - b.timestamp);
     // Return most recent logs
     if (sortedLogs.length > limit) {
         return sortedLogs.slice(-limit);

package/dist/infra/session-maintenance-warning.js

@@ -1,7 +1,9 @@
 import { resolveSessionAgentId } from "../agents/agent-scope.js";
+import { createSubsystemLogger } from "../logging/subsystem.js";
 import { isDeliverableMessageChannel, normalizeMessageChannel } from "../utils/message-channel.js";
 import { resolveSessionDeliveryTarget } from "./outbound/targets.js";
 import { enqueueSystemEvent } from "./system-events.js";
+const log = createSubsystemLogger("session-maintenance");
 const warnedContexts = new Map();
 function shouldSendWarning() {
     return !process.env.VITEST && process.env.NODE_ENV !== "test";
@@ -83,7 +85,7 @@ export async function deliverSessionMaintenanceWarning(params) {
         });
     }
     catch (err) {
-        console.warn(`Failed to deliver session maintenance warning: ${String(err)}`);
+        log.warn(`Failed to deliver session maintenance warning: ${String(err)}`);
         enqueueSystemEvent(text, { sessionKey: params.sessionKey });
     }
 }