@pasko70/pibo 3.0.1 → 3.0.2

package/dist/apps/chat/output-compactor.js

@@ -1,62 +1,90 @@
 import { assistantOutputKey, isLiveOnlyOutputEvent, thinkingOutputKey, toolOutputKey } from "./output-event-policy.js";
+const MAX_TRACKED_COMPACTOR_SESSIONS = 1_024;
 export class OutputCompactor {
     assistantBuffers = new Map();
     thinkingBuffers = new Map();
     toolSnapshots = new Map();
+    sessionRecency = new Map();
+    sessionBufferCounts = new Map();
     compact(event) {
+        const prepared = this.prepare(event);
+        prepared.ack();
+        return prepared;
+    }
+    prepare(event) {
         const persistedEvents = [];
         const snapshots = [];
+        let liveEvents = [event];
+        const mutations = [];
         switch (event.type) {
             case "assistant_delta": {
                 const key = assistantOutputKey(event);
                 const previous = this.assistantBuffers.get(key);
-                const text = `${previous?.text ?? ""}${event.text}`;
-                this.assistantBuffers.set(key, { event, text });
-                snapshots.push({ ...event, text });
+                const next = { event, text: `${previous?.text ?? ""}${event.text}` };
+                mutations.push(() => this.setBuffer(this.assistantBuffers, key, next, event.piboSessionId));
+                snapshots.push({ ...event, text: next.text });
                 break;
             }
             case "assistant_message": {
                 const key = assistantOutputKey(event);
                 const buffered = this.assistantBuffers.get(key);
-                this.assistantBuffers.delete(key);
-                persistedEvents.push({ ...event, text: event.text || buffered?.text || "" });
+                const canonical = { ...event, text: event.text || buffered?.text || "" };
+                mutations.push(() => {
+                    this.deleteBuffer(this.assistantBuffers, key, buffered, event.piboSessionId);
+                });
+                persistedEvents.push(canonical);
+                liveEvents = [canonical];
                 break;
             }
             case "thinking_started": {
                 const key = thinkingOutputKey(event);
-                this.thinkingBuffers.set(key, { base: event, text: "" });
+                const next = { base: event, text: "" };
+                mutations.push(() => {
+                    if (!this.thinkingBuffers.has(key))
+                        this.setBuffer(this.thinkingBuffers, key, next, event.piboSessionId);
+                });
                 persistedEvents.push(event);
                 break;
             }
             case "thinking_delta": {
                 const key = thinkingOutputKey(event);
                 const previous = this.thinkingBuffers.get(key);
-                const text = `${previous?.text ?? ""}${event.text}`;
-                this.thinkingBuffers.set(key, { base: previous?.base ?? event, text });
-                snapshots.push({ ...event, text });
+                const next = { base: previous?.base ?? event, text: `${previous?.text ?? ""}${event.text}` };
+                mutations.push(() => this.setBuffer(this.thinkingBuffers, key, next, event.piboSessionId));
+                snapshots.push({ ...event, text: next.text });
                 break;
             }
             case "thinking_finished": {
                 const key = thinkingOutputKey(event);
                 const buffered = this.thinkingBuffers.get(key);
-                this.thinkingBuffers.delete(key);
-                persistedEvents.push({ ...event, text: event.text || buffered?.text || "" });
+                const canonical = { ...event, text: event.text || buffered?.text || "" };
+                mutations.push(() => {
+                    this.deleteBuffer(this.thinkingBuffers, key, buffered, event.piboSessionId);
+                });
+                persistedEvents.push(canonical);
+                liveEvents = [canonical];
                 break;
             }
             case "tool_execution_updated": {
-                this.toolSnapshots.set(toolOutputKey(event), event);
+                const key = toolOutputKey(event);
+                mutations.push(() => this.setBuffer(this.toolSnapshots, key, event, event.piboSessionId));
                 snapshots.push(event);
                 break;
             }
             case "tool_execution_finished": {
-                this.toolSnapshots.delete(toolOutputKey(event));
+                const key = toolOutputKey(event);
+                const previous = this.toolSnapshots.get(key);
+                mutations.push(() => {
+                    this.deleteBuffer(this.toolSnapshots, key, previous, event.piboSessionId);
+                });
                 persistedEvents.push(event);
                 break;
             }
             case "message_finished":
             case "session_error": {
-                persistedEvents.push(...this.flushForBoundary(event));
-                persistedEvents.push(event);
+                const flushed = this.prepareBoundaryFlush(event, mutations);
+                persistedEvents.push(...flushed, event);
+                liveEvents = [...flushed, event];
                 break;
             }
             default:
@@ -64,7 +92,23 @@ export class OutputCompactor {
                     persistedEvents.push(event);
                 break;
         }
-        return { liveEvents: [event], persistedEvents, snapshots };
+        let settled = false;
+        return {
+            liveEvents,
+            persistedEvents,
+            snapshots,
+            ack: () => {
+                if (settled)
+                    return;
+                settled = true;
+                for (const mutate of mutations)
+                    mutate();
+                this.touchSession(event.piboSessionId);
+            },
+            rollback: () => {
+                settled = true;
+            },
+        };
     }
     snapshotsForSession(piboSessionId) {
         const snapshots = [];
@@ -86,29 +130,68 @@ export class OutputCompactor {
         }
         return snapshots;
     }
-    flushForBoundary(event) {
+    disposeSession(piboSessionId) {
+        for (const [key, buffer] of this.assistantBuffers) {
+            if (buffer.event.piboSessionId === piboSessionId)
+                this.deleteBuffer(this.assistantBuffers, key, buffer, piboSessionId);
+        }
+        for (const [key, buffer] of this.thinkingBuffers) {
+            if (buffer.base.piboSessionId === piboSessionId)
+                this.deleteBuffer(this.thinkingBuffers, key, buffer, piboSessionId);
+        }
+        for (const [key, event] of this.toolSnapshots) {
+            if (event.piboSessionId === piboSessionId)
+                this.deleteBuffer(this.toolSnapshots, key, event, piboSessionId);
+        }
+        this.sessionBufferCounts.delete(piboSessionId);
+        this.sessionRecency.delete(piboSessionId);
+    }
+    disposeAll() {
+        this.assistantBuffers.clear();
+        this.thinkingBuffers.clear();
+        this.toolSnapshots.clear();
+        this.sessionRecency.clear();
+        this.sessionBufferCounts.clear();
+    }
+    debugState() {
+        return {
+            sessionCount: this.sessionRecency.size,
+            completedSessionCount: [...this.sessionRecency.keys()].filter((sessionId) => !this.sessionHasBuffers(sessionId)).length,
+            sessions: [...this.sessionRecency.keys()],
+            assistantBufferCount: this.assistantBuffers.size,
+            thinkingBufferCount: this.thinkingBuffers.size,
+            toolSnapshotCount: this.toolSnapshots.size,
+        };
+    }
+    prepareBoundaryFlush(event, mutations) {
         const flushed = [];
-        for (const [key, buffer] of Array.from(this.assistantBuffers.entries())) {
+        for (const [key, buffer] of this.assistantBuffers) {
             if (!matchesBoundary(buffer.event, event))
                 continue;
-            this.assistantBuffers.delete(key);
+            mutations.push(() => {
+                this.deleteBuffer(this.assistantBuffers, key, buffer, buffer.event.piboSessionId);
+            });
             flushed.push({
                 type: "assistant_message",
                 piboSessionId: buffer.event.piboSessionId,
                 eventId: buffer.event.eventId,
+                renderSequence: buffer.event.renderSequence,
                 assistantIndex: buffer.event.assistantIndex,
                 contentIndex: buffer.event.contentIndex,
                 text: buffer.text,
             });
         }
-        for (const [key, buffer] of Array.from(this.thinkingBuffers.entries())) {
+        for (const [key, buffer] of this.thinkingBuffers) {
             if (!matchesBoundary(buffer.base, event))
                 continue;
-            this.thinkingBuffers.delete(key);
+            mutations.push(() => {
+                this.deleteBuffer(this.thinkingBuffers, key, buffer, buffer.base.piboSessionId);
+            });
             flushed.push({
                 type: "thinking_finished",
                 piboSessionId: buffer.base.piboSessionId,
                 eventId: buffer.base.eventId,
+                renderSequence: buffer.base.renderSequence,
                 thinkingIndex: "thinkingIndex" in buffer.base ? buffer.base.thinkingIndex : undefined,
                 contentIndex: buffer.base.contentIndex,
                 text: buffer.text,
@@ -116,6 +199,46 @@ export class OutputCompactor {
         }
         return flushed;
     }
+    touchSession(piboSessionId) {
+        this.sessionRecency.delete(piboSessionId);
+        this.sessionRecency.set(piboSessionId, true);
+        let completedCount = [...this.sessionRecency.keys()].filter((sessionId) => !this.sessionHasBuffers(sessionId)).length;
+        while (completedCount > MAX_TRACKED_COMPACTOR_SESSIONS) {
+            let removed = false;
+            for (const sessionId of this.sessionRecency.keys()) {
+                if (this.sessionHasBuffers(sessionId))
+                    continue;
+                this.sessionRecency.delete(sessionId);
+                completedCount -= 1;
+                removed = true;
+                break;
+            }
+            if (!removed)
+                break;
+        }
+    }
+    sessionHasBuffers(piboSessionId) {
+        return (this.sessionBufferCounts.get(piboSessionId) ?? 0) > 0;
+    }
+    setBuffer(map, key, value, piboSessionId) {
+        if (!map.has(key))
+            this.sessionBufferCounts.set(piboSessionId, (this.sessionBufferCounts.get(piboSessionId) ?? 0) + 1);
+        setLatest(map, key, value);
+    }
+    deleteBuffer(map, key, expected, piboSessionId) {
+        if (expected === undefined || map.get(key) !== expected)
+            return;
+        map.delete(key);
+        const next = (this.sessionBufferCounts.get(piboSessionId) ?? 1) - 1;
+        if (next > 0)
+            this.sessionBufferCounts.set(piboSessionId, next);
+        else
+            this.sessionBufferCounts.delete(piboSessionId);
+    }
+}
+function setLatest(map, key, value) {
+    map.delete(key);
+    map.set(key, value);
 }
 function matchesBoundary(bufferEvent, boundary) {
     if (bufferEvent.piboSessionId !== boundary.piboSessionId)

package/dist/apps/chat/output-event-policy.js

@@ -2,7 +2,184 @@ export function isLiveOnlyOutputEvent(event) {
     return event.type === "assistant_delta" || event.type === "thinking_delta" || event.type === "tool_execution_updated";
 }
 export function isPersistableOutputEvent(event) {
-    return !isLiveOnlyOutputEvent(event);
+    return isPiboOutputEvent(event) && !isLiveOnlyOutputEvent(event);
+}
+export function isPiboOutputEvent(value) {
+    if (!isRecord(value) || typeof value.type !== "string" || typeof value.piboSessionId !== "string")
+        return false;
+    if (value.eventId !== undefined && typeof value.eventId !== "string")
+        return false;
+    if (value.renderSequence !== undefined && !isPositiveSafeInteger(value.renderSequence))
+        return false;
+    if (value.toolInvocationOrdinal !== undefined && !isNonNegativeSafeInteger(value.toolInvocationOrdinal))
+        return false;
+    if (value.provenance !== undefined && !isMessageProvenance(value.provenance))
+        return false;
+    switch (value.type) {
+        case "message_queued":
+            return typeof value.text === "string"
+                && isNonNegativeSafeInteger(value.queuedMessages)
+                && isOptionalEventSource(value.source);
+        case "message_steered":
+            return typeof value.text === "string"
+                && isOptionalEventSource(value.source)
+                && isOptionalString(value.activeEventId);
+        case "message_started":
+            return typeof value.text === "string" && isOptionalEventSource(value.source);
+        case "assistant_delta":
+        case "assistant_message":
+            return typeof value.text === "string"
+                && isOptionalNonNegativeSafeInteger(value.assistantIndex)
+                && isOptionalNonNegativeSafeInteger(value.contentIndex);
+        case "thinking_delta":
+            return typeof value.text === "string"
+                && isOptionalNonNegativeSafeInteger(value.thinkingIndex)
+                && isOptionalNonNegativeSafeInteger(value.contentIndex);
+        case "message_finished":
+            return isOptionalEventSource(value.source);
+        case "thinking_started":
+            return isOptionalNonNegativeSafeInteger(value.thinkingIndex) && isOptionalNonNegativeSafeInteger(value.contentIndex);
+        case "thinking_finished":
+            return isOptionalString(value.text)
+                && isOptionalNonNegativeSafeInteger(value.thinkingIndex)
+                && isOptionalNonNegativeSafeInteger(value.contentIndex);
+        case "tool_call":
+            return hasOwn(value, "args")
+                && typeof value.toolCallId === "string"
+                && typeof value.toolName === "string"
+                && typeof value.argsComplete === "boolean"
+                && isOptionalString(value.intent);
+        case "tool_execution_started":
+            return hasOwn(value, "args")
+                && typeof value.toolCallId === "string"
+                && typeof value.toolName === "string"
+                && isOptionalString(value.intent);
+        case "tool_execution_updated":
+            return hasOwn(value, "args")
+                && hasOwn(value, "partialResult")
+                && typeof value.toolCallId === "string"
+                && typeof value.toolName === "string"
+                && isOptionalString(value.intent);
+        case "tool_execution_finished":
+            return hasOwn(value, "result")
+                && typeof value.toolCallId === "string"
+                && typeof value.toolName === "string"
+                && typeof value.isError === "boolean"
+                && isOptionalString(value.intent);
+        case "subagent_session":
+            return typeof value.toolName === "string"
+                && typeof value.subagentName === "string"
+                && typeof value.childPiboSessionId === "string"
+                && isOptionalString(value.requestId)
+                && isOptionalString(value.toolCallId)
+                && isOptionalString(value.threadKey);
+        case "assistant_usage":
+            return isFiniteNumber(value.totalTokens)
+                && isOptionalNonNegativeSafeInteger(value.usageIndex)
+                && ["inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens", "reasoningTokens"].every((key) => isOptionalFiniteNumber(value[key]))
+                && isOptionalFiniteNumber(value.costUsd);
+        case "compaction_start":
+            return typeof value.reason === "string" && isOptionalNonNegativeSafeInteger(value.compactionIndex);
+        case "compaction_end":
+            return typeof value.reason === "string"
+                && typeof value.aborted === "boolean"
+                && isOptionalNonNegativeSafeInteger(value.compactionIndex)
+                && isOptionalString(value.errorMessage);
+        case "approval_requested":
+            return isApprovalRequest(value.request);
+        case "approval_resolved":
+        case "user_input_resolved":
+            return typeof value.requestId === "string" && isRuntimeRequestResolution(value.resolution);
+        case "user_input_requested":
+            return isUserInputRequest(value.request);
+        case "execution_result":
+            return typeof value.action === "string" && hasOwn(value, "result");
+        case "session_error":
+            return typeof value.error === "string" && (value.errorDetails === undefined || isRecord(value.errorDetails));
+        case "pi_event":
+            return hasOwn(value, "event");
+        default:
+            return false;
+    }
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function hasOwn(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
+function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function isOptionalFiniteNumber(value) {
+    return value === undefined || isFiniteNumber(value);
+}
+function isOptionalString(value) {
+    return value === undefined || typeof value === "string";
+}
+function isOptionalNonNegativeSafeInteger(value) {
+    return value === undefined || isNonNegativeSafeInteger(value);
+}
+function isPositiveSafeInteger(value) {
+    return Number.isSafeInteger(value) && value > 0;
+}
+function isNonNegativeSafeInteger(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+function isRuntimeRequestResolution(value) {
+    return value === "responded" || value === "cleared" || value === "aborted" || value === "expired";
+}
+function isOptionalEventSource(value) {
+    return value === undefined || value === "user" || value === "ui" || value === "service" || value === "actor";
+}
+function isMessageProvenance(value) {
+    if (!isRecord(value) || typeof value.kind !== "string")
+        return false;
+    if (value.kind === "loop-run") {
+        return typeof value.jobId === "string"
+            && typeof value.runId === "string"
+            && (value.cause === undefined || value.cause === "run-reminder")
+            && isOptionalString(value.rootEventId);
+    }
+    if (value.kind === "subagent-request") {
+        return typeof value.requestId === "string"
+            && typeof value.controllerPiboSessionId === "string"
+            && isOptionalString(value.loopJobId)
+            && isOptionalString(value.loopRunId);
+    }
+    return false;
+}
+function isApprovalRequest(value) {
+    return isRecord(value)
+        && typeof value.requestId === "string"
+        && typeof value.requestType === "string"
+        && isOptionalString(value.title)
+        && isOptionalString(value.detail)
+        && (value.decisions === undefined || (Array.isArray(value.decisions)
+            && value.decisions.every((decision) => isRecord(decision)
+                && typeof decision.id === "string"
+                && typeof decision.label === "string"
+                && isOptionalString(decision.description))));
+}
+function isUserInputRequest(value) {
+    return isRecord(value)
+        && typeof value.requestId === "string"
+        && Array.isArray(value.questions)
+        && isOptionalBoolean(value.blocking)
+        && value.questions.every((question) => isRecord(question)
+            && typeof question.id === "string"
+            && typeof question.question === "string"
+            && isOptionalString(question.header)
+            && isOptionalBoolean(question.multiSelect)
+            && isOptionalBoolean(question.allowFreeform)
+            && isOptionalBoolean(question.secret)
+            && (question.options === undefined || (Array.isArray(question.options)
+                && question.options.every((option) => isRecord(option)
+                    && typeof option.label === "string"
+                    && isOptionalString(option.description)))));
+}
+function isOptionalBoolean(value) {
+    return value === undefined || typeof value === "boolean";
 }
 export function assistantOutputKey(event) {
     const partIndex = event.assistantIndex ?? event.contentIndex ?? 0;
@@ -13,5 +190,5 @@ export function thinkingOutputKey(event) {
     return [event.piboSessionId, event.eventId ?? "", partIndex].join(":");
 }
 export function toolOutputKey(event) {
-    return [event.piboSessionId, event.eventId ?? "", event.toolCallId].join(":");
+    return [event.piboSessionId, event.eventId ?? "", event.toolCallId, event.toolInvocationOrdinal ?? 0].join(":");
 }

package/dist/apps/chat/stream.js

@@ -58,7 +58,7 @@ export function chatStreamFramesFromOutputEvent(event, state, options = {}) {
             }
             break;
         case "tool_call":
-            ensureToolCallStarted(frames, state, event.toolCallId, event.toolName, event.args, event.intent, eventId);
+            ensureToolCallStarted(frames, state, event.toolCallId, event.toolName, event.args, event.intent, eventId, event.toolInvocationOrdinal);
             frames.push({
                 type: "TOOL_CALL_ARGS",
                 toolCallId: event.toolCallId,
@@ -71,7 +71,7 @@ export function chatStreamFramesFromOutputEvent(event, state, options = {}) {
             });
             break;
         case "tool_execution_started": {
-            const started = ensureToolCallStarted(frames, state, event.toolCallId, event.toolName, event.args, event.intent, eventId);
+            const started = ensureToolCallStarted(frames, state, event.toolCallId, event.toolName, event.args, event.intent, eventId, event.toolInvocationOrdinal);
             if (!started && event.intent) {
                 frames.push({
                     type: "TOOL_CALL_START",
@@ -85,7 +85,7 @@ export function chatStreamFramesFromOutputEvent(event, state, options = {}) {
             break;
         }
         case "tool_execution_updated":
-            ensureToolCallStarted(frames, state, event.toolCallId, event.toolName, event.args, event.intent, eventId);
+            ensureToolCallStarted(frames, state, event.toolCallId, event.toolName, event.args, event.intent, eventId, event.toolInvocationOrdinal);
             frames.push({
                 type: "TOOL_CALL_ARGS",
                 toolCallId: event.toolCallId,
@@ -99,7 +99,7 @@ export function chatStreamFramesFromOutputEvent(event, state, options = {}) {
             });
             break;
         case "tool_execution_finished":
-            ensureToolCallStarted(frames, state, event.toolCallId, event.toolName, undefined, event.intent, eventId);
+            ensureToolCallStarted(frames, state, event.toolCallId, event.toolName, undefined, event.intent, eventId, event.toolInvocationOrdinal);
             frames.push({ type: "TOOL_CALL_RESULT", toolCallId: event.toolCallId, toolName: event.toolName, result: event.result, isError: event.isError, ...(event.intent ? { intent: event.intent } : {}), runId: eventId });
             break;
         case "subagent_session":
@@ -135,6 +135,14 @@ export function chatStreamFramesFromOutputEvent(event, state, options = {}) {
     }
     if (options.includeRawEvent ?? true)
         frames.push({ type: "RAW_EVENT", event });
+    if (event.renderSequence !== undefined) {
+        for (const frame of frames)
+            frame.renderSequence = event.renderSequence;
+    }
+    if (event.toolInvocationOrdinal !== undefined) {
+        for (const frame of frames)
+            frame.toolInvocationOrdinal = event.toolInvocationOrdinal;
+    }
     return frames;
 }
 function reasoningIdFromOutputEvent(event) {
@@ -162,10 +170,11 @@ function ensureReasoningStarted(frames, state, messageId, runId) {
     state.reasoningMessageIds.add(messageId);
     frames.push({ type: "REASONING_MESSAGE_START", messageId, runId });
 }
-function ensureToolCallStarted(frames, state, toolCallId, toolName, args, intent, runId) {
-    if (state.toolCallIds.has(toolCallId))
+function ensureToolCallStarted(frames, state, toolCallId, toolName, args, intent, runId, toolInvocationOrdinal) {
+    const invocationKey = JSON.stringify([runId ?? "", toolCallId, toolInvocationOrdinal ?? 0]);
+    if (state.toolCallIds.has(invocationKey))
         return false;
-    state.toolCallIds.add(toolCallId);
+    state.toolCallIds.add(invocationKey);
     frames.push({ type: "TOOL_CALL_START", toolCallId, toolName, args, ...(intent ? { intent } : {}), runId });
     return true;
 }

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

@@ -255,6 +255,7 @@ function compactTraceNode(node, payloadStore, piboSessionId, depth) {
         payloadRefs: Object.keys(payloadRefs).length ? payloadRefs : undefined,
         linkedPiboSessionId: node.linkedPiboSessionId,
         toolCallId: node.toolCallId,
+        toolInvocationOrdinal: node.toolInvocationOrdinal,
         runId: node.runId,
         intent: node.intent,
         eventId: node.eventId,