@pasko70/pibo 3.4.3 → 3.5.0

package/dist/apps/chat/telemetry-retention-service.js

@@ -1,3 +1,5 @@
+import { AsyncTelemetryMaintenance } from "../../data/async-telemetry-maintenance.js";
+import { TelemetryMaintenance } from "../../data/telemetry-maintenance.js";
 import { telemetryRetentionCutoff, } from "../../core/telemetry-retention-settings.js";
 export const TELEMETRY_RETENTION_CLASSES = [
     "live",
@@ -7,14 +9,33 @@ export const TELEMETRY_RETENTION_CLASSES = [
     "incident",
 ];
 export const DEFAULT_TELEMETRY_RETENTION_MAINTENANCE_INTERVAL_MS = 24 * 60 * 60 * 1000;
+/** Bounded recovery: back off a failing maintenance job, then leave it visible instead of respawning. */
+export const TELEMETRY_RETENTION_MAINTENANCE_FAILURE_LIMIT = 8;
+export const TELEMETRY_RETENTION_MAINTENANCE_MAX_RETRY_MS = 30_000;
+export async function disposeTelemetryRetentionMaintenance(state) {
+    state.disposed = true;
+    if (state.timer)
+        clearTimeout(state.timer);
+    state.timer = undefined;
+    state.running = false;
+    await state.worker?.close();
+    state.worker = undefined;
+}
 export function pruneTelemetryOlderThan(input) {
     const cutoff = telemetryRetentionCutoff(input.days, input.now);
-    const results = TELEMETRY_RETENTION_CLASSES.map((retentionClass) => input.dataStore.telemetry.prune({ retentionClass, before: cutoff, apply: input.apply }));
+    const results = [];
+    for (const retentionClass of TELEMETRY_RETENTION_CLASSES) {
+        const result = input.dataStore.telemetry.prune({ retentionClass, before: cutoff, apply: input.apply });
+        results.push(result);
+        if (result.completed === false)
+            break;
+    }
     return {
         cutoff,
         days: input.days,
         applied: input.apply === true,
         results,
+        completed: results.every(result => result.completed !== false),
         rowsDeleted: results.reduce((sum, result) => sum + result.rowsDeleted, 0),
         bytesMatched: results.reduce((sum, result) => sum + result.bytesMatched, 0),
     };
@@ -27,6 +48,8 @@ export function isTelemetryRetentionMaintenanceDue(input) {
     return !(input.state.lastCheckedAt && now.getTime() - input.state.lastCheckedAt < intervalMs);
 }
 export function maybeRunTelemetryRetentionMaintenance(input) {
+    if (input.state.disposed)
+        return;
     if (!input.settings.enabled)
         return;
     if (input.state.running)
@@ -39,19 +62,70 @@ export function maybeRunTelemetryRetentionMaintenance(input) {
         input.state.lastCheckedAt = now.getTime();
         return;
     }
-    if (hasActiveRuntimeWork(input.context))
-        return;
     input.state.lastCheckedAt = now.getTime();
     input.state.running = true;
-    setTimeout(() => {
+    const cutoff = telemetryRetentionCutoff(input.settings.days, now);
+    const local = input.dataStore.path === ":memory:" ? new TelemetryMaintenance(input.dataStore.db) : undefined;
+    let consecutiveFailures = 0;
+    const run = async () => {
+        let failed = false;
         try {
-            pruneTelemetryOlderThan({ dataStore: input.dataStore, days: input.settings.days, now, apply: true });
-            input.onPruned?.(now.toISOString());
+            if (input.state.disposed)
+                return;
+            if (local) {
+                if (!local.status() || local.status()?.status === "completed" || local.status()?.status === "cancelled")
+                    local.start(cutoff);
+                local.step();
+            }
+            else if (!input.state.worker) {
+                input.state.worker = new AsyncTelemetryMaintenance(input.dataStore.path);
+                await input.state.worker.command("start", cutoff);
+            }
+            const status = local?.status() ?? await input.state.worker.command("status");
+            if (input.state.disposed)
+                return;
+            if (status?.status === "completed") {
+                input.onPruned?.(now.toISOString());
+                input.state.running = false;
+                await input.state.worker?.close();
+                input.state.worker = undefined;
+                return;
+            }
+            if (status?.status === "cancelled" || status?.status === "paused") {
+                input.state.running = false;
+                await input.state.worker?.close();
+                input.state.worker = undefined;
+                return;
+            }
+        }
+        catch {
+            failed = true;
+            input.state.failures = (input.state.failures ?? 0) + 1;
+            await input.state.worker?.close();
+            input.state.worker = undefined;
+        }
+        if (input.state.disposed)
+            return;
+        if (!failed) {
+            consecutiveFailures = 0;
+            input.state.timer = setTimeout(() => { input.state.timer = undefined; void run(); }, local ? 25 : 250);
+            input.state.timer.unref?.();
+            return;
         }
-        finally {
+        // A persistent failure must not respawn a worker thread every 250 ms forever. Back off, then stop
+        // with the failure count visible so a later due check retries instead of burning one worker per attempt.
+        consecutiveFailures++;
+        if (consecutiveFailures >= TELEMETRY_RETENTION_MAINTENANCE_FAILURE_LIMIT) {
             input.state.running = false;
+            input.state.timer = undefined;
+            return;
         }
-    }, 0).unref?.();
+        const backoffMs = Math.min(TELEMETRY_RETENTION_MAINTENANCE_MAX_RETRY_MS, 250 * 2 ** (consecutiveFailures - 1));
+        input.state.timer = setTimeout(() => { input.state.timer = undefined; void run(); }, backoffMs);
+        input.state.timer.unref?.();
+    };
+    input.state.timer = setTimeout(() => { input.state.timer = undefined; void run(); }, 0);
+    input.state.timer.unref?.();
 }
 export function isPersistentRetentionDue(lastPrunedAt, now, intervalMs) {
     if (!lastPrunedAt)
@@ -67,3 +141,34 @@ export function hasActiveRuntimeWork(context) {
         ?? [];
     return statuses.some((status) => Boolean(status?.processing || status?.streaming || (status?.queuedMessages ?? 0) > 0));
 }
+/** Explicit HTTP maintenance keeps SQL off the gateway and yields between every bounded batch. */
+export async function pruneTelemetryOlderThanAsync(input) {
+    if (input.dataStore.path === ":memory:")
+        return pruneTelemetryOlderThan(input);
+    const cutoff = telemetryRetentionCutoff(input.days), worker = new AsyncTelemetryMaintenance(input.dataStore.path);
+    const abort = () => { void worker.close(); };
+    input.signal?.addEventListener("abort", abort, { once: true });
+    try {
+        if (input.signal?.aborted)
+            throw Error("Maintenance request cancelled");
+        if (!input.apply) {
+            const results = await worker.preview(cutoff);
+            return { cutoff, days: input.days, applied: false, results, rowsDeleted: 0, bytesMatched: results.reduce((n, r) => n + r.bytesMatched, 0), completed: true };
+        }
+        let status = await worker.command("start", cutoff);
+        if (status?.status === "paused")
+            status = await worker.command("resume");
+        const until = Date.now() + 30000;
+        while (status?.status === "running" && Date.now() < until) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+            status = await worker.command("status");
+        }
+        if (status?.status === "running")
+            status = await worker.command("pause");
+        return { cutoff: status?.cutoff ?? cutoff, days: input.days, applied: true, results: [], rowsDeleted: status?.deleted ?? 0, bytesMatched: 0, completed: status?.status === "completed" };
+    }
+    finally {
+        input.signal?.removeEventListener("abort", abort);
+        await worker.close();
+    }
+}

package/dist/apps/chat/trace-response-cache.js

@@ -0,0 +1,46 @@
+/** Exact encoded responses; bounded independently from reconstructed trace caches. */
+export class TraceResponseCache {
+    maximumBytes;
+    maximumEntries;
+    entries = new Map();
+    bytes = 0;
+    constructor(maximumBytes = 8 * 1024 * 1024, maximumEntries = 32) {
+        this.maximumBytes = maximumBytes;
+        this.maximumEntries = maximumEntries;
+    }
+    get(key, request) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return;
+        this.entries.delete(key);
+        this.entries.set(key, entry);
+        const headers = new Headers(entry.headers);
+        headers.set("server-timing", 'trace_cache;desc="watermark-hit"');
+        const etag = headers.get("etag");
+        const requested = request.headers.get("if-none-match");
+        if (etag && requested?.split(',').some(v => v.trim() === '*' || v.trim() === etag || v.trim() === 'W/' + etag))
+            return new Response(null, { status: 304, headers });
+        return new Response(entry.body.slice(), { status: entry.status, headers });
+    }
+    async set(key, response) {
+        if (response.status !== 200 || !response.headers.get("content-type")?.includes("json"))
+            return;
+        const body = new Uint8Array(await response.clone().arrayBuffer());
+        const bytes = body.byteLength + Buffer.byteLength(key);
+        if (bytes > Math.min(this.maximumBytes, 1024 * 1024))
+            return;
+        const previous = this.entries.get(key);
+        if (previous)
+            this.bytes -= previous.bytes;
+        this.entries.delete(key);
+        this.entries.set(key, { body, headers: [...response.headers.entries()], status: response.status, bytes });
+        this.bytes += bytes;
+        while (this.bytes > this.maximumBytes || this.entries.size > this.maximumEntries) {
+            const oldest = this.entries.keys().next().value;
+            this.bytes -= this.entries.get(oldest).bytes;
+            this.entries.delete(oldest);
+        }
+    }
+    clear() { this.entries.clear(); this.bytes = 0; }
+    status() { return { entries: this.entries.size, bytes: this.bytes, maximumBytes: this.maximumBytes, maximumEntries: this.maximumEntries }; }
+}

package/dist/apps/chat/trace-v2.js

@@ -148,17 +148,21 @@ export function looksLikeImagePayloadPreview(value) {
     return /"type"\s*:\s*"(?:image|input_image|output_image|image_url)"/i.test(value)
         || /"mime(?:Type|_type)"\s*:\s*"image\//i.test(value);
 }
-export function readTracePayloadChunk(input) {
+export async function readTracePayloadChunk(input) {
     const parsed = parseTracePayloadRef(input.ref);
     if (!parsed)
         return undefined;
     const payload = input.payloadStore.getPayload(parsed.payloadId);
     if (!payload)
         return undefined;
-    const bytes = Buffer.from(input.payloadStore.readPayloadBytes(parsed.payloadId));
-    const offset = Math.max(0, Math.min(input.offset, bytes.byteLength));
+    const offset = Math.max(0, Math.min(input.offset, payload.byteSize));
     const limit = Math.max(1, Math.min(input.limit, TRACE_V2_PAYLOAD_MAX_LIMIT_BYTES));
-    const chunk = bytes.subarray(offset, Math.min(bytes.byteLength, offset + limit));
+    const bytes = await input.payloadStore.readPayloadRange(parsed.payloadId, offset, limit + 3);
+    let length = Math.min(limit, bytes.length);
+    // Include a complete UTF-8 code point at the boundary; cursors remain byte offsets.
+    while (length < bytes.length && (bytes[length] & 0xc0) === 0x80)
+        length++;
+    const chunk = bytes.subarray(0, length);
     const preview = payload.previewText ?? "";
     const traceRef = {
         ref: input.ref,
@@ -168,7 +172,7 @@ export function readTracePayloadChunk(input) {
         truncatedPreview: Buffer.byteLength(preview, "utf8") < payload.byteSize,
         hash: payload.sha256,
     };
-    const nextOffset = offset + chunk.byteLength < bytes.byteLength ? offset + chunk.byteLength : undefined;
+    const nextOffset = offset + chunk.byteLength < payload.byteSize ? offset + chunk.byteLength : undefined;
     return {
         ref: traceRef,
         offset,
@@ -248,6 +252,8 @@ function compactTraceNode(node, payloadStore, piboSessionId, depth) {
         completedAt: node.completedAt,
         durationMs: node.durationMs,
         toolMetrics: node.toolMetrics,
+        modelInferences: node.modelInferences,
+        compactionStats: node.compactionStats,
         orderKey: node.orderKey,
         depth,
         hasChildren: node.children.length > 0,
@@ -268,7 +274,7 @@ function compactTraceNode(node, payloadStore, piboSessionId, depth) {
     });
 }
 function inlinePayloadForNodeValue(node, kind, value) {
-    return inlinePayloadForValue(value, inlinePayloadByteLimit(node, kind));
+    return node.payloadRefs?.[kind] ? undefined : inlinePayloadForValue(value, inlinePayloadByteLimit(node, kind));
 }
 function inlinePayloadByteLimit(node, kind) {
     if ((node.type === "user.message" || node.type === "assistant.message" || node.type === "model.reasoning") && kind !== "error") {

package/dist/apps/chat/trace.js

@@ -5,7 +5,7 @@ import { isBuiltInHistoryReconciliationProof } from "../../agent-runtimes/histor
 import { buildTraceViewFromEvents, traceNodesFromHistoryEntries } from "../../shared/trace-engine.js";
 import { chatWebSessionSidebarOrder, isChatWebSessionArchived, isChatWebSessionPinned } from "./session-metadata.js";
 import { workflowSessionKindFromMetadata } from "../../sessions/workflow-session-kind.js";
-export const TRACE_PROJECTION_VERSION = "runtime-history-v2-incomplete-status";
+export const TRACE_PROJECTION_VERSION = "runtime-history-v2-debug-metrics";
 export { compareTraceNodes, sortTraceNodes, nestTraceNodes, flattenTraceNodes, mapTraceNodesById, buildTraceViewFromEvents, traceNodesFromHistoryEntries, } from "../../shared/trace-engine.js";
 export const TRACE_TRANSCRIPT_TAIL_MAX_BYTES = PI_HISTORY_TAIL_MAX_BYTES;
 export const TRACE_TRANSCRIPT_HISTORY_PAGE_MAX_BYTES = PI_HISTORY_PAGE_MAX_BYTES;