@pasko70/pibo 1.6.0 → 1.7.0

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

@@ -1,7 +1,8 @@
 import { createHash } from "node:crypto";
 import { patchTraceViewWithEvent } from "../../shared/trace-engine.js";
-export const DEFAULT_TRACE_EVENTS_PAGE_SIZE = 2_000;
-export const MAX_TRACE_EVENTS_PER_REQUEST = 50_000;
+export const DEFAULT_TRACE_EVENTS_PAGE_SIZE = 50;
+export const MAX_TRACE_EVENTS_PER_REQUEST = 1000;
+export const TRACE_CACHE_MAX_BYTES = 8 * 1024 * 1024;
 export function etagForVersion(version) {
     return `"${version}"`;
 }
@@ -80,15 +81,57 @@ export function annotateTracePage(trace, events, input) {
         hasOlderEvents: firstEventSequence !== undefined ? firstEventSequence > 1 : false,
     };
 }
-export function setTraceCache(cache, key, trace, maxEntries) {
+export function setTraceCache(cache, key, trace, maxEntries, maxBytes = TRACE_CACHE_MAX_BYTES) {
     if (trace.rawEvents.length > 0)
         return;
     cache.delete(key);
     cache.set(key, trace);
-    while (cache.size > maxEntries) {
+    while (cache.size > maxEntries || traceCacheEstimatedBytes(cache) > maxBytes) {
         const oldestKey = cache.keys().next().value;
         if (typeof oldestKey !== "string")
             break;
         cache.delete(oldestKey);
     }
 }
+export function traceCacheEstimatedBytes(cache) {
+    let bytes = 0;
+    for (const trace of cache.values())
+        bytes += estimateTraceViewBytes(trace);
+    return bytes;
+}
+export function estimateTraceViewBytes(trace) {
+    let bytes = 512;
+    bytes += byteLength(trace.piboSessionId) + byteLength(trace.piSessionId) + byteLength(trace.title) + byteLength(trace.version);
+    for (const node of flattenEstimateNodes(trace.nodes)) {
+        bytes += 256;
+        bytes += byteLength(node.id) + byteLength(node.parentId) + byteLength(node.title) + byteLength(node.summary);
+        bytes += estimatePayloadBytes(node.input) + estimatePayloadBytes(node.output) + byteLength(node.error);
+    }
+    return bytes;
+}
+function flattenEstimateNodes(nodes) {
+    const result = [];
+    const visit = (items) => {
+        for (const item of items) {
+            result.push(item);
+            visit(item.children);
+        }
+    };
+    visit(nodes);
+    return result;
+}
+function estimatePayloadBytes(value) {
+    if (value === undefined || value === null)
+        return 0;
+    if (typeof value === "string")
+        return byteLength(value);
+    try {
+        return byteLength(JSON.stringify(value));
+    }
+    catch {
+        return byteLength(String(value));
+    }
+}
+function byteLength(value) {
+    return value ? Buffer.byteLength(value, "utf8") : 0;
+}

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

@@ -0,0 +1,302 @@
+import { createHash } from "node:crypto";
+export const TRACE_V2_DEFAULT_TIMELINE_LIMIT = 50;
+export const TRACE_V2_MAX_TIMELINE_LIMIT = 240;
+export const TRACE_V2_TIMELINE_HARD_BYTES = 256 * 1024;
+export const TRACE_V2_PREVIEW_CHARS = 64;
+export const TRACE_V2_INLINE_PAYLOAD_MAX_BYTES = 8 * 1024;
+export const TRACE_V2_INLINE_TRANSCRIPT_PAYLOAD_MAX_BYTES = 64 * 1024;
+export const TRACE_V2_PAYLOAD_REF_THRESHOLD_BYTES = 4096;
+export const TRACE_V2_PAYLOAD_DEFAULT_LIMIT_BYTES = 64 * 1024;
+export const TRACE_V2_PAYLOAD_MAX_LIMIT_BYTES = 1024 * 1024;
+export const TRACE_V2_RAW_EVENTS_DEFAULT_LIMIT = 80;
+export const TRACE_V2_RAW_EVENTS_MAX_LIMIT = 500;
+export const TRACE_V2_RAW_EVENTS_HARD_BYTES = 256 * 1024;
+export function traceTimelinePageFromView(input) {
+    const byteLimit = input.byteLimit ?? TRACE_V2_TIMELINE_HARD_BYTES;
+    const nodes = compactTraceNodes({
+        nodes: input.trace.nodes,
+        payloadStore: input.payloadStore,
+        piboSessionId: input.trace.piboSessionId,
+        limit: Math.max(1, Math.min(input.limit, TRACE_V2_MAX_TIMELINE_LIMIT)),
+        fromTail: input.fromTail,
+    });
+    let page = {
+        piboSessionId: input.trace.piboSessionId,
+        piSessionId: input.trace.piSessionId,
+        title: input.trace.title,
+        version: input.trace.version,
+        latestStreamId: input.trace.latestStreamId,
+        projectionStatus: "ready",
+        cursor: {
+            before: input.trace.nextBeforeSequence !== undefined ? String(input.trace.nextBeforeSequence) : undefined,
+            after: input.trace.lastEventSequence !== undefined ? String(input.trace.lastEventSequence) : undefined,
+            hasOlder: input.trace.hasOlderEvents === true,
+            hasNewer: false,
+        },
+        nodes,
+        responseBudget: {
+            nodeLimit: input.limit,
+            byteLimit,
+            truncatedByBytes: false,
+        },
+        eventCount: input.trace.eventCount,
+        pageSize: input.trace.pageSize,
+        firstEventSequence: input.trace.firstEventSequence,
+        lastEventSequence: input.trace.lastEventSequence,
+        nextBeforeSequence: input.trace.nextBeforeSequence,
+        hasOlderEvents: input.trace.hasOlderEvents,
+    };
+    while (Buffer.byteLength(JSON.stringify(page), "utf8") > byteLimit && page.nodes.length > 1) {
+        page = {
+            ...page,
+            nodes: page.nodes.slice(Math.ceil(page.nodes.length / 4)),
+            responseBudget: { ...page.responseBudget, truncatedByBytes: true },
+        };
+    }
+    return page;
+}
+export function traceRawEventsPageFromEvents(input) {
+    const byteLimit = input.byteLimit ?? TRACE_V2_RAW_EVENTS_HARD_BYTES;
+    const limited = input.events.slice(-Math.max(1, Math.min(input.limit, TRACE_V2_RAW_EVENTS_MAX_LIMIT)));
+    let page = {
+        piboSessionId: input.piboSessionId,
+        cursor: {
+            before: limited[0]?.eventSequence !== undefined ? String(limited[0].eventSequence) : undefined,
+            hasOlder: (limited[0]?.eventSequence ?? 1) > 1,
+        },
+        limit: input.limit,
+        events: limited.map((event) => compactRawEvent(event, input.payloadStore, input.piboSessionId)),
+        responseBudget: {
+            byteLimit,
+            truncatedByBytes: false,
+        },
+    };
+    while (Buffer.byteLength(JSON.stringify(page), "utf8") > byteLimit && page.events.length > 1) {
+        page = {
+            ...page,
+            events: page.events.slice(Math.ceil(page.events.length / 4)),
+            responseBudget: { ...page.responseBudget, truncatedByBytes: true },
+        };
+    }
+    return page;
+}
+export function parseTracePayloadRef(ref) {
+    if (!ref.startsWith("trace_"))
+        return undefined;
+    try {
+        const parsed = JSON.parse(Buffer.from(ref.slice("trace_".length), "base64url").toString("utf8"));
+        if (!parsed || typeof parsed !== "object")
+            return undefined;
+        const record = parsed;
+        return typeof record.p === "string" && typeof record.id === "string"
+            ? { piboSessionId: record.p, payloadId: record.id }
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export 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 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 preview = payload.previewText ?? "";
+    const traceRef = {
+        ref: input.ref,
+        contentType: normalizeContentType(payload.contentType),
+        byteLength: payload.byteSize,
+        preview,
+        truncatedPreview: Buffer.byteLength(preview, "utf8") < payload.byteSize,
+        hash: payload.sha256,
+    };
+    const nextOffset = offset + chunk.byteLength < bytes.byteLength ? offset + chunk.byteLength : undefined;
+    return {
+        ref: traceRef,
+        offset,
+        limit,
+        data: chunk.toString("utf8"),
+        byteLength: chunk.byteLength,
+        nextOffset,
+        hasMore: nextOffset !== undefined,
+    };
+}
+function compactTraceNodes(input) {
+    const result = [];
+    const visit = (nodes, depth) => {
+        for (const node of nodes) {
+            result.push(compactTraceNode(node, input.payloadStore, input.piboSessionId, depth));
+            visit(node.children, depth + 1);
+        }
+    };
+    visit(input.nodes, 0);
+    return input.fromTail ? result.slice(-input.limit) : result.slice(0, input.limit);
+}
+function compactTraceNode(node, payloadStore, piboSessionId, depth) {
+    const outputKind = node.type === "model.reasoning" ? "reasoning" : "output";
+    const inlinePayloads = compactObject({
+        input: inlinePayloadForNodeValue(node, "input", node.input),
+        [outputKind]: inlinePayloadForNodeValue(node, outputKind, node.output),
+        error: inlinePayloadForNodeValue(node, "error", node.error),
+    });
+    const payloadRefs = compactObject({
+        input: inlinePayloads.input === undefined
+            ? payloadRefForValue({ store: payloadStore, piboSessionId, nodeId: node.id, kind: "input", value: node.input })
+            : undefined,
+        [outputKind]: inlinePayloads[outputKind] === undefined
+            ? payloadRefForValue({ store: payloadStore, piboSessionId, nodeId: node.id, kind: outputKind, value: node.output })
+            : undefined,
+        error: inlinePayloads.error === undefined
+            ? payloadRefForValue({ store: payloadStore, piboSessionId, nodeId: node.id, kind: "error", value: node.error })
+            : undefined,
+    });
+    const preview = previewForNode(node, payloadRefs);
+    return compactObject({
+        nodeId: node.id,
+        parentId: node.parentId,
+        piboSessionId: node.piboSessionId,
+        type: node.type,
+        status: node.status,
+        title: node.title,
+        startedAt: node.startedAt,
+        completedAt: node.completedAt,
+        durationMs: node.durationMs,
+        orderKey: node.orderKey,
+        depth,
+        hasChildren: node.children.length > 0,
+        childCount: node.children.length || undefined,
+        preview,
+        inlinePayloads: Object.keys(inlinePayloads).length ? inlinePayloads : undefined,
+        payloadRefs: Object.keys(payloadRefs).length ? payloadRefs : undefined,
+        linkedPiboSessionId: node.linkedPiboSessionId,
+        toolCallId: node.toolCallId,
+        runId: node.runId,
+        eventId: node.eventId,
+        entryId: node.entryId,
+        source: node.source,
+        stableKey: node.stableKey,
+    });
+}
+function inlinePayloadForNodeValue(node, kind, value) {
+    return inlinePayloadForValue(value, inlinePayloadByteLimit(node, kind));
+}
+function inlinePayloadByteLimit(node, kind) {
+    if ((node.type === "user.message" || node.type === "assistant.message" || node.type === "model.reasoning") && kind !== "error") {
+        return TRACE_V2_INLINE_TRANSCRIPT_PAYLOAD_MAX_BYTES;
+    }
+    return TRACE_V2_INLINE_PAYLOAD_MAX_BYTES;
+}
+function inlinePayloadForValue(value, maxBytes = TRACE_V2_INLINE_PAYLOAD_MAX_BYTES) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    const { bytes } = payloadBytes(value);
+    if (bytes.byteLength > maxBytes)
+        return undefined;
+    return toPayloadValue(value);
+}
+function payloadRefForValue(input) {
+    if (input.value === undefined || input.value === null || input.value === "")
+        return undefined;
+    const { text, bytes, contentType } = payloadBytes(input.value);
+    const preview = textPreview(text);
+    const truncatedPreview = normalizedPreviewText(text).length > preview.length;
+    if (!truncatedPreview && bytes.byteLength <= TRACE_V2_PAYLOAD_REF_THRESHOLD_BYTES) {
+        return undefined;
+    }
+    const payload = input.store.writePayload({
+        value: toPayloadValue(input.value),
+        contentType,
+        retentionClass: "trace_event",
+    });
+    return {
+        ref: encodeTracePayloadRef(input.piboSessionId, payload.id),
+        contentType: normalizeContentType(contentType),
+        byteLength: bytes.byteLength,
+        preview,
+        truncatedPreview,
+        hash: createHash("sha256").update(bytes).digest("hex"),
+    };
+}
+function previewForNode(node, payloadRefs) {
+    if (node.error) {
+        const text = textPreview(String(node.error));
+        return { text, source: "error", truncated: String(node.error).length > text.length };
+    }
+    const payloadPreview = payloadRefs.output?.preview ?? payloadRefs.reasoning?.preview ?? payloadRefs.input?.preview;
+    if (payloadPreview)
+        return { text: payloadPreview, source: "payload", truncated: true };
+    const candidate = node.output ?? node.summary ?? node.input ?? node.title;
+    const text = textPreview(textForPreview(candidate));
+    if (!text)
+        return undefined;
+    return { text, source: node.summary !== undefined && node.output === undefined ? "summary" : "payload", truncated: textForPreview(candidate).length > text.length };
+}
+function compactRawEvent(event, payloadStore, piboSessionId) {
+    const payloadRef = payloadRefForValue({ store: payloadStore, piboSessionId, nodeId: event.id, kind: "raw", value: event.payload });
+    if (!payloadRef)
+        return event;
+    return {
+        ...event,
+        payload: {
+            type: event.type,
+            payloadRef,
+            preview: payloadRef.preview,
+            byteLength: payloadRef.byteLength,
+            truncated: true,
+        },
+    };
+}
+function encodeTracePayloadRef(piboSessionId, payloadId) {
+    return `trace_${Buffer.from(JSON.stringify({ p: piboSessionId, id: payloadId }), "utf8").toString("base64url")}`;
+}
+function payloadBytes(value) {
+    if (typeof value === "string") {
+        const bytes = Buffer.from(value, "utf8");
+        return { text: value, bytes, contentType: "text/plain; charset=utf-8" };
+    }
+    const text = JSON.stringify(value);
+    return { text, bytes: Buffer.from(text, "utf8"), contentType: "application/json" };
+}
+function textForPreview(value) {
+    if (typeof value === "string")
+        return value;
+    if (value === undefined || value === null)
+        return "";
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function textPreview(value) {
+    return normalizedPreviewText(value).slice(0, TRACE_V2_PREVIEW_CHARS);
+}
+function normalizedPreviewText(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+function toPayloadValue(value) {
+    if (typeof value === "string")
+        return value;
+    return JSON.parse(JSON.stringify(value));
+}
+function normalizeContentType(contentType) {
+    if (contentType.includes("json"))
+        return "application/json";
+    if (contentType.startsWith("text/markdown"))
+        return "text/markdown";
+    if (contentType.startsWith("text/"))
+        return "text/plain";
+    if (contentType.includes("x-ndjson"))
+        return "application/x-ndjson";
+    return "application/octet-stream";
+}
+function compactObject(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}

package/dist/apps/chat/trace.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { parseSessionEntries, SessionManager } from "@mariozechner/pi-coding-agent";
@@ -7,6 +7,7 @@ import { buildTraceViewFromEvents } from "../../shared/trace-engine.js";
 import { isChatWebSessionArchived } from "./session-metadata.js";
 import { workflowSessionKindFromMetadata } from "../../sessions/workflow-session-kind.js";
 export { compareTraceNodes, sortTraceNodes, nestTraceNodes, flattenTraceNodes, mapTraceNodesById, buildTraceViewFromEvents, traceNodesFromEntries, } from "../../shared/trace-engine.js";
+export const TRACE_TRANSCRIPT_TAIL_MAX_BYTES = 2 * 1024 * 1024;
 export async function loadPiSessionMetadata(session, cwd = process.cwd()) {
     const piSession = await findPiSession(session, cwd);
     return metadataFromPiSession(piSession);
@@ -109,7 +110,7 @@ function sessionNodeStatus(indexedStatus) {
 }
 export async function buildTraceView(input) {
     const metadata = input.metadata ?? (await loadPiSessionMetadata(input.session, input.session.workspace ?? input.cwd));
-    const allEntries = metadata.sessionPath ? readEntries(metadata.sessionPath) : [];
+    const allEntries = input.transcriptEntries ?? (metadata.sessionPath ? readEntries(metadata.sessionPath) : []);
     const sessionStatus = input.status ?? "idle";
     const view = buildTraceViewFromEvents({
         session: {
@@ -145,6 +146,12 @@ export async function buildTraceView(input) {
         }),
     };
 }
+export async function loadPiSessionTailEntries(session, cwd = process.cwd(), maxBytes = TRACE_TRANSCRIPT_TAIL_MAX_BYTES) {
+    const metadata = await loadPiSessionMetadata(session, cwd);
+    if (!metadata.sessionPath)
+        return { metadata, entries: [] };
+    return { metadata, entries: readTailEntries(metadata.sessionPath, maxBytes) };
+}
 export function createTraceViewVersion(input) {
     const relevantSessions = input.sessions
         .map((session) => ({
@@ -295,6 +302,28 @@ function readEntries(path) {
     const content = readFileSync(path, "utf8");
     return parseSessionEntries(content).filter((entry) => entry.type !== "session");
 }
+export function readTailEntries(path, maxBytes = TRACE_TRANSCRIPT_TAIL_MAX_BYTES) {
+    if (!existsSync(path))
+        return [];
+    const stats = statSync(path);
+    if (stats.size <= maxBytes)
+        return readEntries(path);
+    const length = Math.max(1, Math.min(maxBytes, stats.size));
+    const start = stats.size - length;
+    const buffer = Buffer.alloc(length);
+    const fd = openSync(path, "r");
+    try {
+        const bytesRead = readSync(fd, buffer, 0, length, start);
+        let content = buffer.subarray(0, bytesRead).toString("utf8");
+        const firstNewline = content.indexOf("\n");
+        if (start > 0 && firstNewline >= 0)
+            content = content.slice(firstNewline + 1);
+        return parseSessionEntries(content).filter((entry) => entry.type !== "session");
+    }
+    finally {
+        closeSync(fd);
+    }
+}
 function annotateForkableUserMessageNodes(nodes, entries) {
     const candidates = userMessageForkCandidates(entries);
     if (!candidates.length)