@pasko70/pibo 1.7.11 → 1.8.0

package/dist/core/runtime-telemetry.js

@@ -1,16 +1,26 @@
 import { BestEffortTelemetryService, } from "../data/telemetry.js";
 import { isTerminalProviderStatus } from "./provider-telemetry.js";
 const TERMINAL_TURN_STATUSES = new Set(["ok", "error", "aborted", "timeout"]);
+const DEFAULT_PROGRESS_FLUSH_INTERVAL_MS = 1_000;
 export class PiboRuntimeTelemetryRecorder {
     store;
     onError;
     telemetry;
     providerEventMode;
+    progressFlushIntervalMs;
+    pendingProviderProgress = new Map();
+    providerRequestCache = new Map();
+    lastProviderFlushAtMs = new Map();
+    lastProgressWriteAtMs = new Map();
     constructor(store, onError, options = {}) {
         this.store = store;
         this.onError = onError;
         this.telemetry = new BestEffortTelemetryService(store, onError);
         this.providerEventMode = options.providerEventMode ?? "aggregate";
+        const progressFlushIntervalMs = options.progressFlushIntervalMs;
+        this.progressFlushIntervalMs = typeof progressFlushIntervalMs === "number" && Number.isFinite(progressFlushIntervalMs) && progressFlushIntervalMs >= 0
+            ? progressFlushIntervalMs
+            : DEFAULT_PROGRESS_FLUSH_INTERVAL_MS;
     }
     recordOutput(event, context = {}) {
         if (!this.store)
@@ -32,6 +42,15 @@ export class PiboRuntimeTelemetryRecorder {
             this.onError?.(error);
         }
     }
+    recordMessagesInterrupted(messages, context = {}, reason = "message interrupted") {
+        if (!this.store)
+            return;
+        for (const message of messages) {
+            if (!message.id)
+                continue;
+            this.recordTurnTerminal({ piboSessionId: message.piboSessionId, eventId: message.id }, context, "aborted", "abort", reason, "runtime_abort");
+        }
+    }
     recordOutputUnsafe(event, context) {
         switch (event.type) {
             case "message_queued":
@@ -44,15 +63,19 @@ export class PiboRuntimeTelemetryRecorder {
                 this.recordMessageFinished(event, context);
                 return;
             case "assistant_delta":
-            case "assistant_message":
                 this.recordProviderStreamProgress(event, context, "assistant_text", "assistant text progress");
                 return;
+            case "assistant_message":
+                this.recordProviderStreamProgress(event, context, "assistant_text", "assistant text progress", true);
+                return;
             case "thinking_started":
+                this.recordProviderStreamProgress(event, context, "reasoning", "reasoning progress", true);
+                return;
             case "thinking_delta":
                 this.recordProviderStreamProgress(event, context, "reasoning", "reasoning progress");
                 return;
             case "thinking_finished": {
-                this.recordProviderStreamProgress(event, context, "reasoning", "reasoning finished");
+                this.recordProviderStreamProgress(event, context, "reasoning", "reasoning finished", true);
                 const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, undefined, context) ?? this.activeTurnContext(event.piboSessionId, context);
                 this.finishOpenPhasesByName(turn?.turnId, "reasoning", "ok");
                 return;
@@ -61,15 +84,19 @@ export class PiboRuntimeTelemetryRecorder {
                 this.recordToolArgsPhase(event, context);
                 return;
             case "tool_execution_started":
+                this.recordToolExecutionPhase(event, context, true);
+                return;
             case "tool_execution_updated":
-                this.recordToolExecutionPhase(event, context);
+                this.recordToolExecutionPhase(event, context, false);
                 return;
             case "tool_execution_finished":
                 this.recordToolExecutionFinished(event, context);
                 return;
-            case "session_error":
-                this.recordTurnTerminal(event, context, "error", "error", event.error);
+            case "session_error": {
+                const status = terminalTurnStatusForSessionError(event);
+                this.recordTurnTerminal(event, context, status, status === "aborted" ? "abort" : status === "timeout" ? "timeout" : "error", event.error, event.errorDetails?.category ?? event.errorDetails?.errorClass);
                 return;
+            }
             case "execution_result":
                 this.recordExecutionResult(event, context);
                 return;
@@ -82,43 +109,52 @@ export class PiboRuntimeTelemetryRecorder {
         if (!summary)
             return;
         const turn = context.activeEventId
-            ? this.turnContextForEvent(piboSessionId, context.activeEventId, undefined, context)
+            ? this.progressTurnContextForEvent(piboSessionId, context.activeEventId, context)
             : this.activeTurnContext(piboSessionId, context);
         if (!turn)
             return;
-        const providerRequest = this.activeProviderRequestForTurn(turn.turnId);
-        if (!providerRequest)
-            return;
         const now = new Date().toISOString();
-        if (summary.upstreamResponseId && summary.upstreamResponseId !== providerRequest.upstreamResponseId) {
-            this.upsertProviderRequestFromExisting(providerRequest, { upstreamResponseId: summary.upstreamResponseId });
+        if (summary.assistantEventType === "start") {
+            this.flushProviderProgress(turn.turnId, now, { force: true, includeLatest: true });
+            this.clearProviderProgress(turn.turnId);
         }
-        const providerEventInput = {
-            providerRequestId: providerRequest.providerRequestId,
-            piboSessionId: turn.piboSessionId,
-            turnId: turn.turnId,
-            phaseId: providerRequest.phaseId,
-            receivedAt: now,
-            eventType: summary.eventType,
-            byteSize: summary.byteSize,
-            parseStatus: summary.parseStatus,
-            normalizedType: summary.normalizedType,
-            normalizedEventDelta: 0,
-            eventId: turn.eventId,
-            itemId: summary.itemId,
-            toolCallId: summary.toolCallId,
-            safeFields: summary.safeFields,
-        };
-        if (this.providerEventMode === "detailed") {
-            this.telemetry.appendProviderEventSummary(providerEventInput);
+        const providerRequest = this.providerEventMode === "detailed"
+            ? this.providerRequestForTurn(turn.turnId, { includeLatest: summary.messageEnded, refresh: summary.messageEnded })
+            : this.accumulateProviderEvent(turn, summary, now);
+        if (!providerRequest) {
+            if (summary.messageEnded)
+                this.clearProviderProgress(turn.turnId);
+            return;
         }
-        else {
-            this.telemetry.recordProviderEventSummary(providerEventInput);
+        if (this.providerEventMode === "detailed") {
+            this.telemetry.appendProviderEventSummary({
+                providerRequestId: providerRequest.providerRequestId,
+                piboSessionId: turn.piboSessionId,
+                turnId: turn.turnId,
+                phaseId: providerRequest.phaseId,
+                receivedAt: now,
+                eventType: summary.eventType,
+                byteSize: summary.byteSize,
+                parseStatus: summary.parseStatus,
+                normalizedType: summary.normalizedType,
+                normalizedEventDelta: 0,
+                eventId: turn.eventId,
+                itemId: summary.itemId,
+                toolCallId: summary.toolCallId,
+                safeFields: summary.safeFields,
+            });
         }
         if (summary.toolCallId && summary.assistantEventType?.startsWith("toolcall_")) {
-            this.recordPiToolCallProgress(turn, providerRequest.providerRequestId, summary, now);
+            const forceToolProgress = summary.assistantEventType !== "toolcall_delta";
+            if (this.shouldPersistProgress(`${turn.turnId}:tool_args:${summary.toolCallId}`, forceToolProgress)) {
+                this.recordPiToolCallProgress(turn, providerRequest.providerRequestId, summary, now);
+            }
         }
-        this.startOrProgressPhase(turn, "provider_stream", now, "provider event metadata", { providerRequestId: providerRequest.providerRequestId });
+        if (!summary.messageEnded && !isTerminalProviderStatus(providerRequest.status) && !summary.normalizedType && this.shouldPersistProgress(`${turn.turnId}:provider_stream:${providerRequest.providerRequestId}`)) {
+            this.startOrProgressPhase(turn, "provider_stream", now, "provider event metadata", { providerRequestId: providerRequest.providerRequestId });
+        }
+        if (summary.messageEnded)
+            this.clearProviderProgress(turn.turnId);
     }
     recordMessageQueued(event, context) {
         const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, event.source, context);
@@ -197,23 +233,32 @@ export class PiboRuntimeTelemetryRecorder {
         this.recordTurnTerminal(event, context, "ok", "finish", "message finished");
     }
     recordExecutionResult(event, context) {
-        if (event.action === "abort" || event.action === "dispose" || event.action === "kill_all") {
+        if (event.action === "abort" || event.action === "dispose" || event.action === "kill" || event.action === "kill_all") {
             this.recordTurnTerminal(event, context, "aborted", "abort", `${event.action} requested`);
             return;
         }
-        if (event.action === "clear_queue") {
-            this.recordTurnProgress(event, context, "queued", "clear_queue requested");
-        }
     }
-    recordProviderStreamProgress(event, context, phaseName, summary) {
-        const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, undefined, context) ?? this.activeTurnContext(event.piboSessionId, context);
+    recordProviderStreamProgress(event, context, phaseName, summary, force = false) {
+        const turn = event.eventId
+            ? this.progressTurnContextForEvent(event.piboSessionId, event.eventId, context)
+            : this.activeTurnContext(event.piboSessionId, context);
         if (!turn)
             return;
         const now = new Date().toISOString();
-        const providerRequest = this.activeProviderRequestForTurn(turn.turnId);
+        const providerRequest = this.accumulateNormalizedProviderProgress(turn, now, force);
+        const progressKey = `${turn.turnId}:${phaseName}:${providerRequest?.providerRequestId ?? "none"}`;
+        if (!this.shouldPersistProgress(progressKey, force))
+            return;
+        const storedTurn = this.store?.getTurn(turn.turnId);
+        if (storedTurn && TERMINAL_TURN_STATUSES.has(storedTurn.status)) {
+            this.clearTurnProgress(turn.turnId);
+            return;
+        }
         this.closeOpenPhasesByName(turn.turnId, "message_started", "ok", now);
-        this.progressProviderRequest(providerRequest, now);
-        this.startOrProgressPhase(turn, "provider_stream", now, "normalized provider stream progress", { providerRequestId: providerRequest?.providerRequestId });
+        const providerStreamKey = `${turn.turnId}:provider_stream:${providerRequest?.providerRequestId ?? "none"}`;
+        if ((!providerRequest || !isTerminalProviderStatus(providerRequest.status)) && this.shouldPersistProgress(providerStreamKey, force)) {
+            this.startOrProgressPhase(turn, "provider_stream", now, "normalized provider stream progress", { providerRequestId: providerRequest?.providerRequestId });
+        }
         this.startOrProgressPhase(turn, phaseName, now, summary, { updateTurn: true, providerRequestId: providerRequest?.providerRequestId });
     }
     recordToolArgsPhase(event, context) {
@@ -224,8 +269,8 @@ export class PiboRuntimeTelemetryRecorder {
         this.closeOpenPhasesByName(turn.turnId, "message_started", "ok", now);
         this.closeOpenPhasesByName(turn.turnId, "assistant_text", "ok", now);
         this.closeOpenPhasesByName(turn.turnId, "reasoning", "ok", now);
-        const providerRequest = this.activeProviderRequestForTurn(turn.turnId) ?? this.latestProviderRequestForTurn(turn.turnId);
-        this.progressProviderRequest(providerRequest && !isTerminalProviderStatus(providerRequest.status) ? providerRequest : undefined, now);
+        const providerRequest = this.accumulateNormalizedProviderProgress(turn, now, true)
+            ?? this.providerRequestForTurn(turn.turnId, { includeLatest: true });
         this.upsertToolCallArgs(turn, {
             toolCallId: event.toolCallId,
             toolName: event.toolName,
@@ -244,10 +289,19 @@ export class PiboRuntimeTelemetryRecorder {
             this.telemetry.finishPhase(phase.phaseId, { status: "ok", endedAt: now, lastProgressAt: now, summary: "tool arguments complete" });
         }
     }
-    recordToolExecutionPhase(event, context) {
-        const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, undefined, context) ?? this.activeTurnContext(event.piboSessionId, context);
+    recordToolExecutionPhase(event, context, force) {
+        const turn = event.eventId
+            ? this.progressTurnContextForEvent(event.piboSessionId, event.eventId, context)
+            : this.activeTurnContext(event.piboSessionId, context);
         if (!turn)
             return;
+        if (!this.shouldPersistProgress(`${turn.turnId}:tool_execution:${event.toolCallId}`, force))
+            return;
+        const storedTurn = this.store?.getTurn(turn.turnId);
+        if (storedTurn && TERMINAL_TURN_STATUSES.has(storedTurn.status)) {
+            this.clearTurnProgress(turn.turnId);
+            return;
+        }
         const now = new Date().toISOString();
         const existing = this.store?.getToolCall(event.toolCallId);
         const args = toolArgsMetadata(event.args, true);
@@ -362,19 +416,19 @@ export class PiboRuntimeTelemetryRecorder {
             eventId: turn.eventId,
         });
     }
-    recordTurnProgress(event, context, phaseName, summary) {
-        const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, undefined, context) ?? this.activeTurnContext(event.piboSessionId, context);
+    recordTurnTerminal(event, context, status, phaseName, summary, errorCategory) {
+        const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, undefined, context, { includeTerminal: true }) ?? this.activeTurnContext(event.piboSessionId, context);
         if (!turn)
             return;
-        this.startOrProgressPhase(turn, phaseName, new Date().toISOString(), summary, { updateTurn: true });
-    }
-    recordTurnTerminal(event, context, status, phaseName, summary) {
-        const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, undefined, context) ?? this.activeTurnContext(event.piboSessionId, context);
-        if (!turn)
+        const existingTurn = this.store?.getTurn(turn.turnId);
+        if (existingTurn && TERMINAL_TURN_STATUSES.has(existingTurn.status)) {
+            this.clearTurnProgress(turn.turnId);
             return;
+        }
         const now = new Date().toISOString();
+        this.flushProviderProgress(turn.turnId, now, { force: true, includeLatest: true });
         this.finishOpenPhases(turn.turnId, terminalPhaseStatus(status), now);
-        this.finishActiveProviderRequests(turn.turnId, providerStatusForTurnStatus(status), now, summary);
+        this.finishActiveProviderRequests(turn.turnId, providerStatusForTurnStatus(status), now, summary, errorCategory);
         this.finishActiveToolCalls(turn.turnId, status, now, summary);
         this.telemetry.upsertPhase({
             phaseId: phaseId(turn.turnId, phaseName),
@@ -403,8 +457,12 @@ export class PiboRuntimeTelemetryRecorder {
             queueDepth: turn.queueDepth,
             summary: safeSummary(summary),
         });
+        this.clearTurnProgress(turn.turnId);
     }
     startOrProgressPhase(turn, phaseName, now, summary, options = {}) {
+        const storedTurn = this.store?.getTurn(turn.turnId);
+        if (storedTurn && TERMINAL_TURN_STATUSES.has(storedTurn.status))
+            return undefined;
         const existing = this.openPhaseByName(turn.turnId, phaseName);
         const phase = this.telemetry.upsertPhase({
             phaseId: existing?.phaseId ?? this.nextPhaseId(turn.turnId, phaseName),
@@ -438,22 +496,20 @@ export class PiboRuntimeTelemetryRecorder {
         return phase;
     }
     openPhaseByName(turnId, phaseName) {
-        const timeline = this.store?.getTurnTimeline(turnId, { limit: 100 });
-        return timeline?.phases.find((phase) => phase.name === phaseName && phase.status === "open");
+        return this.store?.getOpenPhaseForTurn(turnId, phaseName);
     }
     nextPhaseId(turnId, phaseName) {
         const base = phaseId(turnId, phaseName);
-        const phases = this.store?.getTurnTimeline(turnId, { limit: 100 })?.phases.filter((phase) => phase.name === phaseName) ?? [];
-        if (phases.length === 0)
+        const count = this.store?.countPhasesForTurn(turnId, phaseName) ?? 0;
+        if (count === 0)
             return base;
-        return `${base}:${phases.length + 1}`;
+        return `${base}:${count + 1}`;
     }
     finishOpenPhasesByName(turnId, phaseName, status, now = new Date().toISOString(), summary) {
         if (!turnId)
             return;
-        const timeline = this.store?.getTurnTimeline(turnId, { limit: 100 });
-        for (const phase of timeline?.phases ?? []) {
-            if (phase.name !== phaseName || phase.status !== "open")
+        for (const phase of this.store?.listOpenPhasesForTurn(turnId) ?? []) {
+            if (phase.name !== phaseName)
                 continue;
             this.telemetry.finishPhase(phase.phaseId, { status, endedAt: now, lastProgressAt: now, summary });
         }
@@ -462,39 +518,117 @@ export class PiboRuntimeTelemetryRecorder {
         this.finishOpenPhasesByName(turnId, phaseName, status, now, summary);
     }
     finishOpenPhases(turnId, status, now) {
-        const timeline = this.store?.getTurnTimeline(turnId, { limit: 100 });
-        for (const phase of timeline?.phases ?? []) {
-            if (phase.status !== "open")
-                continue;
+        for (const phase of this.store?.listOpenPhasesForTurn(turnId) ?? []) {
             this.telemetry.finishPhase(phase.phaseId, { status, endedAt: now, lastProgressAt: now });
         }
     }
     activeProviderRequestForTurn(turnId) {
-        const timeline = this.store?.getTurnTimeline(turnId, { limit: 100 });
-        return [...(timeline?.providerRequests ?? [])].reverse().find((request) => !isTerminalProviderStatus(request.status));
+        return this.store?.getActiveProviderRequestForTurn(turnId);
     }
     latestProviderRequestForTurn(turnId) {
-        const timeline = this.store?.getTurnTimeline(turnId, { limit: 100 });
-        return timeline?.providerRequests.at(-1);
+        return this.store?.getLatestProviderRequestForTurn(turnId);
+    }
+    providerRequestForTurn(turnId, options = {}) {
+        const cached = this.providerRequestCache.get(turnId);
+        if (!options.refresh && cached && (options.includeLatest || !isTerminalProviderStatus(cached.status)))
+            return cached;
+        const request = this.activeProviderRequestForTurn(turnId)
+            ?? (options.includeLatest ? this.latestProviderRequestForTurn(turnId) : undefined);
+        if (request)
+            this.providerRequestCache.set(turnId, request);
+        else
+            this.providerRequestCache.delete(turnId);
+        return request;
+    }
+    accumulateProviderEvent(turn, summary, now) {
+        const pending = this.pendingProviderProgress.get(turn.turnId) ?? emptyPendingProviderProgress();
+        pending.lastRawEventAt = now;
+        pending.upstreamResponseId = summary.upstreamResponseId ?? pending.upstreamResponseId;
+        pending.rawEventCount += 1;
+        pending.parseErrorCount += summary.parseStatus === "invalid_json" ? 1 : 0;
+        pending.unknownEventCount += summary.parseStatus === "unknown_type" ? 1 : 0;
+        pending.bytesReceived += summary.byteSize;
+        pending.eventTypeCounts[summary.eventType] = (pending.eventTypeCounts[summary.eventType] ?? 0) + 1;
+        this.pendingProviderProgress.set(turn.turnId, pending);
+        return this.flushProviderProgress(turn.turnId, now, {
+            force: summary.messageEnded,
+            includeLatest: summary.messageEnded,
+            refresh: summary.messageEnded,
+        });
     }
-    progressProviderRequest(request, now) {
+    accumulateNormalizedProviderProgress(turn, now, force = false) {
+        const request = this.providerRequestForTurn(turn.turnId, { includeLatest: force });
         if (!request)
-            return;
-        this.upsertProviderRequestFromExisting(request, {
-            status: "streaming",
-            lastNormalizedEventAt: now,
-            normalizedEventCount: request.normalizedEventCount + 1,
+            return undefined;
+        const pending = this.pendingProviderProgress.get(turn.turnId) ?? emptyPendingProviderProgress();
+        pending.lastNormalizedEventAt = now;
+        pending.normalizedEventCount += 1;
+        this.pendingProviderProgress.set(turn.turnId, pending);
+        const flushNow = force || request.status === "started" || request.status === "headers";
+        return this.flushProviderProgress(turn.turnId, now, { force: flushNow, includeLatest: force }) ?? request;
+    }
+    flushProviderProgress(turnId, now, options = {}) {
+        const pending = this.pendingProviderProgress.get(turnId);
+        const request = this.providerRequestForTurn(turnId, options);
+        if (!pending)
+            return request;
+        const nowMs = Date.now();
+        const lastFlushAtMs = this.lastProviderFlushAtMs.get(turnId);
+        if (!options.force && lastFlushAtMs !== undefined && nowMs - lastFlushAtMs < this.progressFlushIntervalMs)
+            return request;
+        if (!request) {
+            const turn = this.store?.getTurn(turnId);
+            if (turn && TERMINAL_TURN_STATUSES.has(turn.status))
+                this.clearTurnProgress(turnId);
+            return undefined;
+        }
+        const updated = this.telemetry.recordProviderProgress({
+            providerRequestId: request.providerRequestId,
+            status: pending.normalizedEventCount > 0 ? "streaming" : undefined,
+            lastRawEventAt: pending.lastRawEventAt,
+            lastNormalizedEventAt: pending.lastNormalizedEventAt,
+            upstreamResponseId: pending.upstreamResponseId,
+            rawEventCount: pending.rawEventCount,
+            normalizedEventCount: pending.normalizedEventCount,
+            parseErrorCount: pending.parseErrorCount,
+            unknownEventCount: pending.unknownEventCount,
+            bytesReceived: pending.bytesReceived,
+            eventTypeCounts: pending.eventTypeCounts,
+            updatedAt: now,
         });
+        this.pendingProviderProgress.delete(turnId);
+        this.lastProviderFlushAtMs.set(turnId, nowMs);
+        if (updated)
+            this.providerRequestCache.set(turnId, updated);
+        return updated ?? request;
+    }
+    shouldPersistProgress(key, force = false) {
+        const nowMs = Date.now();
+        const lastWriteAtMs = this.lastProgressWriteAtMs.get(key);
+        if (!force && lastWriteAtMs !== undefined && nowMs - lastWriteAtMs < this.progressFlushIntervalMs)
+            return false;
+        this.lastProgressWriteAtMs.set(key, nowMs);
+        return true;
     }
-    finishActiveProviderRequests(turnId, status, now, summary) {
-        const timeline = this.store?.getTurnTimeline(turnId, { limit: 100 });
-        for (const request of timeline?.providerRequests ?? []) {
-            if (isTerminalProviderStatus(request.status))
-                continue;
+    clearProviderProgress(turnId) {
+        this.pendingProviderProgress.delete(turnId);
+        this.providerRequestCache.delete(turnId);
+        this.lastProviderFlushAtMs.delete(turnId);
+    }
+    clearTurnProgress(turnId) {
+        this.clearProviderProgress(turnId);
+        const prefix = `${turnId}:`;
+        for (const key of this.lastProgressWriteAtMs.keys()) {
+            if (key.startsWith(prefix))
+                this.lastProgressWriteAtMs.delete(key);
+        }
+    }
+    finishActiveProviderRequests(turnId, status, now, summary, errorCategory) {
+        for (const request of this.store?.listActiveProviderRequestsForTurn(turnId) ?? []) {
             this.upsertProviderRequestFromExisting(request, {
                 status,
                 completedAt: now,
-                errorCategory: status === "error" ? "runtime_error" : undefined,
+                errorCategory: status === "error" ? errorCategory ?? "runtime_error" : undefined,
                 errorMessage: status === "error" ? safeSummary(summary) : undefined,
             });
         }
@@ -502,10 +636,7 @@ export class PiboRuntimeTelemetryRecorder {
     finishActiveToolCalls(turnId, status, now, summary) {
         if (status === "ok")
             return;
-        const timeline = this.store?.getTurnTimeline(turnId, { limit: 100 });
-        for (const toolCall of timeline?.toolCalls ?? []) {
-            if (isTerminalToolCallStatus(toolCall.status))
-                continue;
+        for (const toolCall of this.store?.listActiveToolCallsForTurn(turnId) ?? []) {
             const terminalStatus = terminalToolCallStatus(status);
             this.telemetry.upsertToolCall({
                 toolCallId: toolCall.toolCallId,
@@ -566,20 +697,34 @@ export class PiboRuntimeTelemetryRecorder {
             retentionClass: request.retentionClass,
         });
     }
-    turnContextForEvent(piboSessionId, eventId, source, context) {
-        if (!eventId)
-            return undefined;
-        const rootSessionId = rootSessionIdFor(context.session, piboSessionId);
+    progressTurnContextForEvent(piboSessionId, eventId, context) {
         return {
             turnId: turnIdForEvent(eventId),
             eventId,
             piboSessionId,
-            rootSessionId,
+            rootSessionId: rootSessionIdFor(context.session, piboSessionId),
             roomId: roomIdFor(context.session),
-            source: telemetrySource(source),
+            source: "system",
             queueDepth: context.status?.queuedMessages,
         };
     }
+    turnContextForEvent(piboSessionId, eventId, source, context, options = {}) {
+        if (!eventId)
+            return undefined;
+        const turnId = turnIdForEvent(eventId);
+        const existing = this.store?.getTurn(turnId);
+        if (!options.includeTerminal && existing && TERMINAL_TURN_STATUSES.has(existing.status))
+            return undefined;
+        return {
+            turnId,
+            eventId,
+            piboSessionId,
+            rootSessionId: existing?.rootSessionId ?? rootSessionIdFor(context.session, piboSessionId),
+            roomId: existing?.roomId ?? roomIdFor(context.session),
+            source: existing?.source ?? telemetrySource(source),
+            queueDepth: context.status?.queuedMessages ?? existing?.queueDepth,
+        };
+    }
     activeTurnContext(piboSessionId, context) {
         const detail = this.store?.getSessionTelemetry(piboSessionId, { limit: 10 });
         const active = detail?.activeTurn;
@@ -596,6 +741,16 @@ export class PiboRuntimeTelemetryRecorder {
         };
     }
 }
+function emptyPendingProviderProgress() {
+    return {
+        rawEventCount: 0,
+        normalizedEventCount: 0,
+        parseErrorCount: 0,
+        unknownEventCount: 0,
+        bytesReceived: 0,
+        eventTypeCounts: {},
+    };
+}
 function providerEventSummaryForPiEvent(event) {
     if (!event || typeof event !== "object")
         return undefined;
@@ -636,6 +791,7 @@ function providerEventSummaryForPiEvent(event) {
     const byteSize = safeJsonByteSize(safeFields);
     return {
         eventType,
+        messageEnded: candidate.type === "message_end",
         assistantEventType: assistantType,
         parseStatus,
         normalizedType: normalizedTypeForPiAssistantEvent(assistantType),
@@ -717,8 +873,12 @@ function toolStatusForPiAssistantEvent(type, argsBytes, existingStatus) {
         return argsBytes > 0 ? "args_partial" : existingStatus ?? "args_started";
     return existingStatus ?? "args_started";
 }
-function isTerminalToolCallStatus(status) {
-    return status === "ok" || status === "error" || status === "aborted" || status === "timeout";
+function terminalTurnStatusForSessionError(event) {
+    if (event.errorDetails?.category === "runtime_abort" || event.errorDetails?.errorClass === "runtime_abort")
+        return "aborted";
+    if (event.errorDetails?.code === "timeout")
+        return "timeout";
+    return "error";
 }
 function terminalToolCallStatus(status) {
     if (status === "aborted")