@pasko70/pibo 3.0.1 → 3.1.0

package/dist/apps/chat/data/session-query-service.js

@@ -6,10 +6,10 @@ export class ChatSessionQueryService {
     constructor(store) {
         this.store = store;
     }
-    upsertSession(session, status = "idle") {
+    upsertSession(session, status = "idle", lastActivityAt = session.updatedAt) {
         const roomId = chatRoomIdFromMetadata(session.metadata) ?? "room_default";
-        this.store.sessions.upsertSession({ session, roomId, status, lastActivityAt: session.updatedAt });
-        this.upsertNavigation(session, roomId, status, session.updatedAt);
+        this.store.sessions.upsertSession({ session, roomId, status, lastActivityAt });
+        this.upsertNavigation(session, roomId, status, lastActivityAt);
     }
     upsertSessionsIfChanged(sessions) {
         let written = 0;
@@ -24,11 +24,32 @@ export class ChatSessionQueryService {
         }
         return { checked: sessions.length, written, skipped };
     }
-    recordEvent(event, session) {
-        if (session)
-            this.upsertSession(session, statusFromOutputEvent(event));
+    recordEvent(event, session, _streamId, createdAt = new Date().toISOString()) {
+        if (session) {
+            const status = statusFromOutputEvent(event);
+            if (status)
+                this.upsertSession(session, status, createdAt);
+            else
+                this.touchSession(session, createdAt);
+        }
         return undefined;
     }
+    touchSession(session, lastActivityAt) {
+        const roomId = chatRoomIdFromMetadata(session.metadata) ?? "room_default";
+        this.store.sessions.upsertSession({ session, roomId, lastActivityAt });
+        this.store.navigation.upsertSession({
+            roomId,
+            sessionId: session.id,
+            rootSessionId: rootSessionId(session),
+            parentId: session.parentId,
+            originId: session.originId,
+            title: session.title || "Untitled Session",
+            profile: session.profile,
+            lastActivityAt,
+            sortKey: lastActivityAt,
+            updatedAt: lastActivityAt,
+        });
+    }
     listSessions() {
         const rows = this.store.db.prepare(`
 			SELECT s.*, b.runtime_instance_id, b.runtime_adapter_id, b.native_session_id, b.binding_state
@@ -121,12 +142,14 @@ export class ChatSessionQueryService {
             && row.status === status
             && row.metadata_json === metadataJson
             && row.created_at === session.createdAt
-            && row.updated_at === session.updatedAt
-            && row.last_activity_at === session.updatedAt
+            && row.updated_at >= session.updatedAt
+            && row.last_activity_at >= session.updatedAt
             && row.navigation_status === status
             && row.navigation_title === title
-            && row.navigation_sort_key === session.updatedAt
-            && row.navigation_updated_at === session.updatedAt;
+            && row.navigation_sort_key !== null
+            && row.navigation_sort_key >= session.updatedAt
+            && row.navigation_updated_at !== null
+            && row.navigation_updated_at >= session.updatedAt;
     }
     upsertNavigation(session, roomId, status, now) {
         this.store.navigation.upsertSession({

package/dist/apps/chat/data/timeline-query-service.js

@@ -99,43 +99,40 @@ export class ChatTimelineQueryService {
 		`).all(...values, TRACE_RECONCILIATION_ENTRY_CAP + 1);
         if (rows.length > TRACE_RECONCILIATION_ENTRY_CAP)
             return false;
-        const lifecycles = new Map();
-        const invocations = [];
-        for (const row of rows) {
-            const lifecycle = lifecycles.get(row.event_id) ?? { nextOrdinal: 0 };
-            lifecycles.set(row.event_id, lifecycle);
-            if (row.type === "tool_execution_started") {
-                if (lifecycle.active)
+        if (nodeIdentity.qualifier) {
+            let hasPersistedOrdinal = false;
+            const explicitlyAttached = rows.some((row) => {
+                let attributes;
+                try {
+                    const parsed = JSON.parse(row.attributes_json);
+                    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+                        return false;
+                    attributes = parsed;
+                }
+                catch {
                     return false;
-                lifecycle.active = {
-                    eventId: row.event_id,
-                    invocationOrdinal: lifecycle.nextOrdinal,
-                    payloadMatches: false,
-                };
-                lifecycle.nextOrdinal += 1;
-                invocations.push(lifecycle.active);
-            }
-            else if (!lifecycle.active) {
-                lifecycle.active = {
-                    eventId: row.event_id,
-                    invocationOrdinal: lifecycle.nextOrdinal,
-                    payloadMatches: false,
-                };
-                lifecycle.nextOrdinal += 1;
-                invocations.push(lifecycle.active);
-            }
-            if (row.type !== "tool_execution_started"
-                && payloadMatchesEventRow(this.store, payload.sha256, input.payloadId, row))
-                lifecycle.active.payloadMatches = true;
-            if (row.type === "tool_execution_finished")
-                lifecycle.active = undefined;
-        }
-        if (!nodeIdentity.qualifier) {
-            return invocations.length === 1 && invocations[0].payloadMatches;
+                }
+                const ordinal = attributes.toolInvocationOrdinal;
+                if (Number.isSafeInteger(ordinal))
+                    hasPersistedOrdinal = true;
+                return Number.isSafeInteger(ordinal)
+                    && Number(ordinal) === nodeIdentity.qualifier.invocationOrdinal
+                    && row.event_id === nodeIdentity.qualifier.eventId
+                    && row.type !== "tool_execution_started"
+                    && payloadMatchesEventRow(this.store, payload.sha256, input.payloadId, row);
+            });
+            if (explicitlyAttached || hasPersistedOrdinal)
+                return explicitlyAttached;
+            if (nodeIdentity.qualifier.invocationOrdinal !== 0)
+                return false;
+            const inferred = inferLegacyToolInvocations(this.store, rows, payload.sha256, input.payloadId);
+            return !inferred.ambiguous
+                && inferred.invocations.length === 1
+                && inferred.invocations[0].eventId === nodeIdentity.qualifier.eventId
+                && inferred.invocations[0].payloadMatches;
         }
-        const exact = invocations.filter((invocation) => invocation.eventId === nodeIdentity.qualifier.eventId
-            && invocation.invocationOrdinal === nodeIdentity.qualifier.invocationOrdinal);
-        return exact.length === 1 && exact[0].payloadMatches;
+        const inferred = inferLegacyToolInvocations(this.store, rows, payload.sha256, input.payloadId);
+        return !inferred.ambiguous && inferred.invocations.length === 1 && inferred.invocations[0].payloadMatches;
     }
     countEventsByType(input = {}) {
         const clauses = [];
@@ -199,3 +196,31 @@ function payloadMatchesEventRow(store, payloadSha256, payloadId, row) {
         return false;
     return store.payloads.findBySha256(inlineSha256)?.id === payloadId;
 }
+function inferLegacyToolInvocations(store, rows, payloadSha256, payloadId) {
+    const activeByEvent = new Map();
+    const invocations = [];
+    let ambiguous = false;
+    for (const row of rows) {
+        let active = activeByEvent.get(row.event_id);
+        if (row.type === "tool_execution_started") {
+            if (active) {
+                ambiguous = true;
+                continue;
+            }
+            active = { eventId: row.event_id, payloadMatches: false };
+            activeByEvent.set(row.event_id, active);
+            invocations.push(active);
+        }
+        else if (!active) {
+            active = { eventId: row.event_id, payloadMatches: false };
+            activeByEvent.set(row.event_id, active);
+            invocations.push(active);
+        }
+        if (row.type !== "tool_execution_started" && payloadMatchesEventRow(store, payloadSha256, payloadId, row)) {
+            active.payloadMatches = true;
+        }
+        if (row.type === "tool_execution_finished")
+            activeByEvent.delete(row.event_id);
+    }
+    return { ambiguous, invocations };
+}

package/dist/apps/chat/loop-api.js

@@ -2,7 +2,7 @@ import { PiboWebHttpError, readJsonBody, responseJson } from '../../web/http.js'
 import { getPiboLoopService } from '../../loops/channel.js';
 import { listLoopJobTemplates } from '../../loops/templates.js';
 import { isPiboThinkingLevel } from '../../core/thinking.js';
-import { normalizeLoopStopPolicy } from '../../loops/store.js';
+import { normalizeLoopStopPolicy, PiboLoopActiveRunModeChangeError } from '../../loops/store.js';
 import { isPiboRoomArchived } from './types/rooms.js';
 const CHAT_WEB_API_PREFIX = '/api/chat';
 function requireSameOriginJsonRequest(request) { const contentType = request.headers.get('content-type')?.split(';')[0]?.trim().toLowerCase(); if (contentType !== 'application/json')
@@ -184,7 +184,15 @@ export async function handleChatLoopApiRequest(options) {
             throw new PiboWebHttpError('Loop job not found', 404);
         if ((patch.mode ?? existing.mode) === 'ralph' && ((patch.tokenBudget !== undefined && patch.tokenBudget !== null) || (patch.tokenReserve !== undefined && patch.tokenReserve !== null)))
             throw new PiboWebHttpError('tokenBudget and tokenReserve are only available for goal mode', 400);
-        const job = loopStore.updateJob(resource.id, patch);
+        let job;
+        try {
+            job = loopStore.updateJob(resource.id, patch);
+        }
+        catch (error) {
+            if (error instanceof PiboLoopActiveRunModeChangeError)
+                throw new PiboWebHttpError(error.message, 409);
+            throw error;
+        }
         if (!job)
             throw new PiboWebHttpError('Loop job not found', 404);
         return responseJson({ job: serializeJob(job) });

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(":");
 }