@pasko70/pibo 1.9.9 → 1.9.10

package/dist/apps/chat/stream.js

@@ -0,0 +1,145 @@
+export function createChatStreamState() {
+    return {
+        textMessageIds: new Set(),
+        reasoningMessageIds: new Set(),
+        toolCallIds: new Set(),
+        transientFrameIndex: 0,
+    };
+}
+export function nextTransientChatStreamFrameId(state) {
+    return `live:${state.transientFrameIndex++}`;
+}
+export function chatStreamFramesFromOutputEvent(event, state, options = {}) {
+    const eventId = "eventId" in event && typeof event.eventId === "string" ? event.eventId : undefined;
+    const frames = [];
+    const reasoningMessageId = reasoningIdFromOutputEvent(event);
+    switch (event.type) {
+        case "message_started":
+            if (eventId) {
+                frames.push({
+                    type: "RUN_STARTED",
+                    runId: eventId,
+                    input: { text: event.text, source: event.source },
+                });
+            }
+            break;
+        case "message_finished":
+            if (eventId)
+                frames.push({ type: "RUN_FINISHED", runId: eventId });
+            break;
+        case "assistant_delta":
+            if (eventId && event.text.length > 0) {
+                const messageId = textMessageIdFromOutputEvent(event);
+                ensureTextMessageStarted(frames, state, messageId, eventId);
+                frames.push({ type: "TEXT_MESSAGE_CONTENT", messageId, runId: eventId, delta: event.text });
+            }
+            break;
+        case "assistant_message":
+            if (eventId) {
+                const messageId = textMessageIdFromOutputEvent(event);
+                ensureTextMessageStarted(frames, state, messageId, eventId);
+                frames.push({ type: "TEXT_MESSAGE_END", messageId, runId: eventId, finalText: event.text });
+            }
+            break;
+        case "thinking_started":
+            if (reasoningMessageId)
+                ensureReasoningStarted(frames, state, reasoningMessageId, eventId);
+            break;
+        case "thinking_delta":
+            if (reasoningMessageId && event.text.length > 0) {
+                ensureReasoningStarted(frames, state, reasoningMessageId, eventId);
+                frames.push({ type: "REASONING_MESSAGE_CONTENT", messageId: reasoningMessageId, runId: eventId, delta: event.text });
+            }
+            break;
+        case "thinking_finished":
+            if (reasoningMessageId) {
+                ensureReasoningStarted(frames, state, reasoningMessageId, eventId);
+                frames.push({ type: "REASONING_MESSAGE_END", messageId: reasoningMessageId, runId: eventId, finalText: event.text });
+            }
+            break;
+        case "tool_call":
+            ensureToolCallStarted(frames, state, event.toolCallId, event.toolName, event.args, eventId);
+            frames.push({
+                type: "TOOL_CALL_ARGS",
+                toolCallId: event.toolCallId,
+                toolName: event.toolName,
+                args: event.args,
+                argsComplete: event.argsComplete,
+                runId: eventId,
+                sourceEventType: "tool_call",
+            });
+            break;
+        case "tool_execution_started":
+            ensureToolCallStarted(frames, state, event.toolCallId, event.toolName, event.args, eventId);
+            break;
+        case "tool_execution_updated":
+            ensureToolCallStarted(frames, state, event.toolCallId, event.toolName, event.args, eventId);
+            frames.push({
+                type: "TOOL_CALL_ARGS",
+                toolCallId: event.toolCallId,
+                toolName: event.toolName,
+                args: event.args,
+                argsComplete: true,
+                runId: eventId,
+                partialResult: event.partialResult,
+                sourceEventType: "tool_execution_updated",
+            });
+            break;
+        case "tool_execution_finished":
+            ensureToolCallStarted(frames, state, event.toolCallId, event.toolName, undefined, eventId);
+            frames.push({ type: "TOOL_CALL_RESULT", toolCallId: event.toolCallId, toolName: event.toolName, result: event.result, isError: event.isError, runId: eventId });
+            break;
+        case "subagent_session":
+            frames.push({
+                type: "AGENT_DELEGATION",
+                toolCallId: event.toolCallId,
+                toolName: event.toolName,
+                subagentName: event.subagentName,
+                childPiboSessionId: event.childPiboSessionId,
+                threadKey: event.threadKey,
+            });
+            break;
+        case "execution_result":
+            frames.push({ type: "EXECUTION_RESULT", runId: eventId, eventId: event.eventId, action: event.action, result: event.result });
+            break;
+        case "session_error":
+            frames.push({ type: "RUN_ERROR", runId: eventId, message: event.error, errorDetails: event.errorDetails });
+            break;
+        default:
+            break;
+    }
+    if (options.includeRawEvent ?? true)
+        frames.push({ type: "RAW_EVENT", event });
+    return frames;
+}
+function reasoningIdFromOutputEvent(event) {
+    if (event.type !== "thinking_started" && event.type !== "thinking_delta" && event.type !== "thinking_finished") {
+        return undefined;
+    }
+    if (!event.eventId)
+        return undefined;
+    const partIndex = typeof event.thinkingIndex === "number" ? event.thinkingIndex : event.contentIndex;
+    return typeof partIndex === "number" ? `${event.eventId}:thinking:${partIndex}` : event.eventId;
+}
+function textMessageIdFromOutputEvent(event) {
+    const partIndex = typeof event.assistantIndex === "number" ? event.assistantIndex : event.contentIndex;
+    return partIndex === undefined || !event.eventId ? event.eventId ?? "" : `${event.eventId}:assistant:${partIndex}`;
+}
+function ensureTextMessageStarted(frames, state, messageId, runId) {
+    if (state.textMessageIds.has(messageId))
+        return;
+    state.textMessageIds.add(messageId);
+    frames.push({ type: "TEXT_MESSAGE_START", messageId, runId, role: "assistant" });
+}
+function ensureReasoningStarted(frames, state, messageId, runId) {
+    if (state.reasoningMessageIds.has(messageId))
+        return;
+    state.reasoningMessageIds.add(messageId);
+    frames.push({ type: "REASONING_MESSAGE_START", messageId, runId });
+}
+function ensureToolCallStarted(frames, state, toolCallId, toolName, args, runId) {
+    if (state.toolCallIds.has(toolCallId))
+        return;
+    state.toolCallIds.add(toolCallId);
+    frames.push({ type: "TOOL_CALL_START", toolCallId, toolName, args, runId });
+}

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

@@ -0,0 +1,69 @@
+import { telemetryRetentionCutoff, } from "../../core/telemetry-retention-settings.js";
+export const TELEMETRY_RETENTION_CLASSES = [
+    "live",
+    "diagnostic",
+    "provider_event",
+    "payload_preview",
+    "incident",
+];
+export const DEFAULT_TELEMETRY_RETENTION_MAINTENANCE_INTERVAL_MS = 24 * 60 * 60 * 1000;
+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 }));
+    return {
+        cutoff,
+        days: input.days,
+        applied: input.apply === true,
+        results,
+        rowsDeleted: results.reduce((sum, result) => sum + result.rowsDeleted, 0),
+        bytesMatched: results.reduce((sum, result) => sum + result.bytesMatched, 0),
+    };
+}
+export function isTelemetryRetentionMaintenanceDue(input) {
+    if (input.state.running)
+        return false;
+    const now = input.now ?? new Date();
+    const intervalMs = input.intervalMs ?? DEFAULT_TELEMETRY_RETENTION_MAINTENANCE_INTERVAL_MS;
+    return !(input.state.lastCheckedAt && now.getTime() - input.state.lastCheckedAt < intervalMs);
+}
+export function maybeRunTelemetryRetentionMaintenance(input) {
+    if (!input.settings.enabled)
+        return;
+    if (input.state.running)
+        return;
+    const now = input.now ?? new Date();
+    const intervalMs = input.intervalMs ?? DEFAULT_TELEMETRY_RETENTION_MAINTENANCE_INTERVAL_MS;
+    if (input.state.lastCheckedAt && now.getTime() - input.state.lastCheckedAt < intervalMs)
+        return;
+    if (!isPersistentRetentionDue(input.settings.lastPrunedAt, now, intervalMs)) {
+        input.state.lastCheckedAt = now.getTime();
+        return;
+    }
+    if (hasActiveRuntimeWork(input.context))
+        return;
+    input.state.lastCheckedAt = now.getTime();
+    input.state.running = true;
+    setTimeout(() => {
+        try {
+            pruneTelemetryOlderThan({ dataStore: input.dataStore, days: input.settings.days, now, apply: true });
+            input.onPruned?.(now.toISOString());
+        }
+        finally {
+            input.state.running = false;
+        }
+    }, 0).unref?.();
+}
+export function isPersistentRetentionDue(lastPrunedAt, now, intervalMs) {
+    if (!lastPrunedAt)
+        return true;
+    const lastPrunedMs = Date.parse(lastPrunedAt);
+    if (!Number.isFinite(lastPrunedMs))
+        return true;
+    return now.getTime() - lastPrunedMs >= intervalMs;
+}
+export function hasActiveRuntimeWork(context) {
+    const statuses = context.channelContext.listSessionRuntimeStatuses?.()
+        ?? context.channelContext.listSessions?.().map((session) => context.channelContext.getSessionRuntimeStatus?.(session.id)).filter((status) => status !== undefined)
+        ?? [];
+    return statuses.some((status) => Boolean(status?.processing || status?.streaming || (status?.queuedMessages ?? 0) > 0));
+}

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

@@ -0,0 +1,307 @@
+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,
+    });
+    const transcriptTailCursor = input.fromTail ? input.transcriptTailCursor : undefined;
+    const hasOlder = input.trace.hasOlderEvents === true || transcriptTailCursor !== undefined;
+    const nextBeforeCursor = transcriptTailCursor ?? (hasOlder ? input.trace.nextBeforeCursor : undefined);
+    const nextBeforeSequence = transcriptTailCursor ? undefined : (hasOlder ? input.trace.nextBeforeSequence : undefined);
+    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: nextBeforeCursor ?? (nextBeforeSequence !== undefined ? String(nextBeforeSequence) : undefined),
+            after: input.trace.lastEventSequence !== undefined ? String(input.trace.lastEventSequence) : undefined,
+            hasOlder,
+            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,
+        nextBeforeCursor,
+        hasOlderEvents: hasOlder,
+    };
+    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));
+}