@pasko70/pibo 1.9.7 → 1.9.9

package/dist/core/runtime-telemetry.js

@@ -1,1059 +0,0 @@
-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;
-    writer;
-    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";
-        this.writer = options.writer;
-        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)
-            return;
-        const captured = captureTelemetryContext(context);
-        const capturedEvent = telemetryOutputEventSnapshot(event);
-        this.schedule(() => this.recordOutputUnsafe(capturedEvent, captured));
-    }
-    recordPiEvent(piboSessionId, event, context = {}) {
-        if (!this.store)
-            return;
-        const summary = providerEventSummaryForPiEvent(event);
-        if (!summary)
-            return;
-        const captured = captureTelemetryContext(context);
-        this.schedule(() => this.recordPiEventSummaryUnsafe(piboSessionId, summary, captured));
-    }
-    recordMessagesInterrupted(messages, context = {}, reason = "message interrupted") {
-        if (!this.store)
-            return;
-        const captured = captureTelemetryContext(context);
-        const interrupted = messages.flatMap((message) => message.id ? [{ piboSessionId: message.piboSessionId, eventId: message.id }] : []);
-        this.schedule(() => {
-            for (const message of interrupted) {
-                this.recordTurnTerminal(message, captured, "aborted", "abort", reason, "runtime_abort");
-            }
-        });
-    }
-    schedule(write) {
-        const guarded = () => {
-            try {
-                write();
-            }
-            catch (error) {
-                this.onError?.(error);
-            }
-        };
-        if (this.writer)
-            this.writer.enqueue(guarded, this.onError);
-        else
-            guarded();
-    }
-    recordOutputUnsafe(event, context) {
-        switch (event.type) {
-            case "message_queued":
-                this.recordMessageQueued(event, context);
-                return;
-            case "message_started":
-                this.recordMessageStarted(event, context);
-                return;
-            case "message_finished":
-                this.recordMessageFinished(event, context);
-                return;
-            case "assistant_delta":
-                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", true);
-                const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, undefined, context) ?? this.activeTurnContext(event.piboSessionId, context);
-                this.finishOpenPhasesByName(turn?.turnId, "reasoning", "ok", telemetryTimestamp(context));
-                return;
-            }
-            case "tool_call":
-                this.recordToolArgsPhase(event, context);
-                return;
-            case "tool_execution_started":
-                this.recordToolExecutionPhase(event, context, true);
-                return;
-            case "tool_execution_updated":
-                this.recordToolExecutionPhase(event, context, false);
-                return;
-            case "tool_execution_finished":
-                this.recordToolExecutionFinished(event, context);
-                return;
-            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;
-            default:
-                return;
-        }
-    }
-    recordPiEventSummaryUnsafe(piboSessionId, summary, context) {
-        const turn = context.activeEventId
-            ? this.progressTurnContextForEvent(piboSessionId, context.activeEventId, context)
-            : this.activeTurnContext(piboSessionId, context);
-        if (!turn)
-            return;
-        const now = telemetryTimestamp(context);
-        const nowMs = telemetryTimestampMs(context);
-        if (summary.assistantEventType === "start") {
-            this.flushProviderProgress(turn.turnId, now, { force: true, includeLatest: true, nowMs });
-            this.clearProviderProgress(turn.turnId);
-        }
-        const providerRequest = this.providerEventMode === "detailed"
-            ? this.providerRequestForTurn(turn.turnId, { includeLatest: summary.messageEnded, refresh: summary.messageEnded })
-            : this.accumulateProviderEvent(turn, summary, now, nowMs);
-        if (!providerRequest) {
-            if (summary.messageEnded)
-                this.clearProviderProgress(turn.turnId);
-            return;
-        }
-        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_")) {
-            const forceToolProgress = summary.assistantEventType !== "toolcall_delta";
-            if (this.shouldPersistProgress(`${turn.turnId}:tool_args:${summary.toolCallId}`, forceToolProgress, nowMs)) {
-                this.recordPiToolCallProgress(turn, providerRequest.providerRequestId, summary, now);
-            }
-        }
-        if (!summary.messageEnded && !isTerminalProviderStatus(providerRequest.status) && !summary.normalizedType && this.shouldPersistProgress(`${turn.turnId}:provider_stream:${providerRequest.providerRequestId}`, false, nowMs)) {
-            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);
-        if (!turn)
-            return;
-        const now = telemetryTimestamp(context);
-        const queueDepth = event.queuedMessages;
-        this.telemetry.upsertTurn({
-            turnId: turn.turnId,
-            piboSessionId: turn.piboSessionId,
-            rootSessionId: turn.rootSessionId,
-            roomId: turn.roomId,
-            inputEventId: turn.eventId,
-            eventId: turn.eventId,
-            source: turn.source,
-            status: "queued",
-            currentPhase: "queued",
-            queuedAt: now,
-            lastProgressAt: now,
-            queuedBehind: Math.max(0, queueDepth - 1),
-            queueDepth,
-            summary: "message queued",
-            metadata: sessionMetadata(context.session),
-        });
-        this.telemetry.upsertPhase({
-            phaseId: phaseId(turn.turnId, "queued"),
-            turnId: turn.turnId,
-            piboSessionId: turn.piboSessionId,
-            rootSessionId: turn.rootSessionId,
-            roomId: turn.roomId,
-            name: "queued",
-            status: "open",
-            startedAt: now,
-            lastProgressAt: now,
-            eventId: turn.eventId,
-            summary: "waiting in routed-session queue",
-        });
-    }
-    recordMessageStarted(event, context) {
-        const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, event.source, context);
-        if (!turn)
-            return;
-        const now = telemetryTimestamp(context);
-        this.telemetry.finishPhase(phaseId(turn.turnId, "queued"), { status: "ok", endedAt: now, lastProgressAt: now });
-        this.telemetry.upsertPhase({
-            phaseId: phaseId(turn.turnId, "message_started"),
-            turnId: turn.turnId,
-            piboSessionId: turn.piboSessionId,
-            rootSessionId: turn.rootSessionId,
-            roomId: turn.roomId,
-            name: "message_started",
-            status: "open",
-            startedAt: now,
-            lastProgressAt: now,
-            eventId: turn.eventId,
-            summary: "routed message started",
-        });
-        this.telemetry.upsertTurn({
-            turnId: turn.turnId,
-            piboSessionId: turn.piboSessionId,
-            rootSessionId: turn.rootSessionId,
-            roomId: turn.roomId,
-            inputEventId: turn.eventId,
-            eventId: turn.eventId,
-            source: turn.source,
-            status: "running",
-            currentPhase: "message_started",
-            startedAt: now,
-            lastProgressAt: now,
-            queueDepth: turn.queueDepth,
-            summary: "message processing started",
-            metadata: sessionMetadata(context.session),
-        });
-    }
-    recordMessageFinished(event, context) {
-        this.recordTurnTerminal(event, context, "ok", "finish", "message finished");
-    }
-    recordExecutionResult(event, context) {
-        if (event.action === "abort" || event.action === "dispose" || event.action === "kill" || event.action === "kill_all") {
-            this.recordTurnTerminal(event, context, "aborted", "abort", `${event.action} requested`);
-            return;
-        }
-    }
-    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 = telemetryTimestamp(context);
-        const providerRequest = this.accumulateNormalizedProviderProgress(turn, now, force, telemetryTimestampMs(context));
-        const progressKey = `${turn.turnId}:${phaseName}:${providerRequest?.providerRequestId ?? "none"}`;
-        if (!this.shouldPersistProgress(progressKey, force, telemetryTimestampMs(context)))
-            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);
-        const providerStreamKey = `${turn.turnId}:provider_stream:${providerRequest?.providerRequestId ?? "none"}`;
-        if ((!providerRequest || !isTerminalProviderStatus(providerRequest.status)) && this.shouldPersistProgress(providerStreamKey, force, telemetryTimestampMs(context))) {
-            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) {
-        const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, undefined, context) ?? this.activeTurnContext(event.piboSessionId, context);
-        if (!turn)
-            return;
-        const now = telemetryTimestamp(context);
-        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.accumulateNormalizedProviderProgress(turn, now, true, telemetryTimestampMs(context))
-            ?? this.providerRequestForTurn(turn.turnId, { includeLatest: true });
-        this.upsertToolCallArgs(turn, {
-            toolCallId: event.toolCallId,
-            toolName: event.toolName,
-            args: event.args,
-            argsComplete: event.argsComplete,
-            providerRequestId: providerRequest?.providerRequestId,
-            now,
-        });
-        this.startOrProgressPhase(turn, "provider_stream", now, "normalized provider stream progress", { providerRequestId: providerRequest?.providerRequestId });
-        const phase = this.startOrProgressPhase(turn, "tool_args", now, event.argsComplete ? "tool arguments complete" : "tool arguments in progress", {
-            providerRequestId: providerRequest?.providerRequestId,
-            toolCallId: event.toolCallId,
-            updateTurn: true,
-        });
-        if (event.argsComplete && phase) {
-            this.telemetry.finishPhase(phase.phaseId, { status: "ok", endedAt: now, lastProgressAt: now, summary: "tool arguments complete" });
-        }
-    }
-    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, telemetryTimestampMs(context)))
-            return;
-        const storedTurn = this.store?.getTurn(turn.turnId);
-        if (storedTurn && TERMINAL_TURN_STATUSES.has(storedTurn.status)) {
-            this.clearTurnProgress(turn.turnId);
-            return;
-        }
-        const now = telemetryTimestamp(context);
-        const existing = this.store?.getToolCall(event.toolCallId);
-        const args = toolArgsMetadata(event.args, true);
-        const providerRequestId = existing?.providerRequestId ?? this.latestProviderRequestForTurn(turn.turnId)?.providerRequestId;
-        this.closeOpenPhasesByName(turn.turnId, "tool_args", "ok", now);
-        this.telemetry.upsertToolCall({
-            toolCallId: event.toolCallId,
-            piboSessionId: turn.piboSessionId,
-            rootSessionId: turn.rootSessionId,
-            roomId: turn.roomId,
-            turnId: turn.turnId,
-            providerRequestId,
-            providerItemId: itemIdFromToolCallId(event.toolCallId),
-            toolName: event.toolName,
-            status: "executing",
-            argsStartedAt: existing?.argsStartedAt ?? now,
-            firstDeltaAt: existing?.firstDeltaAt ?? (args.argsBytes > 0 ? now : undefined),
-            lastDeltaAt: existing?.lastDeltaAt ?? (args.argsBytes > 0 ? now : undefined),
-            argsCompletedAt: existing?.argsCompletedAt ?? now,
-            executionStartedAt: existing?.executionStartedAt ?? now,
-            argsBytes: Math.max(existing?.argsBytes ?? 0, args.argsBytes),
-            parseStatus: args.parseStatus === "empty" ? existing?.parseStatus ?? "complete" : args.parseStatus,
-            safeArgKeys: args.safeArgKeys.length > 0 ? args.safeArgKeys : existing?.safeArgKeys,
-            eventId: turn.eventId,
-        });
-        this.startOrProgressPhase(turn, "tool_execution", now, event.type === "tool_execution_started" ? "tool execution started" : "tool execution progress", {
-            toolCallId: event.toolCallId,
-            updateTurn: true,
-        });
-    }
-    recordToolExecutionFinished(event, context) {
-        const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, undefined, context) ?? this.activeTurnContext(event.piboSessionId, context);
-        if (!turn)
-            return;
-        const now = telemetryTimestamp(context);
-        const existing = this.store?.getToolCall(event.toolCallId);
-        const executionStartedAt = existing?.executionStartedAt;
-        this.telemetry.upsertToolCall({
-            toolCallId: event.toolCallId,
-            piboSessionId: turn.piboSessionId,
-            rootSessionId: turn.rootSessionId,
-            roomId: turn.roomId,
-            turnId: turn.turnId,
-            providerRequestId: existing?.providerRequestId ?? this.latestProviderRequestForTurn(turn.turnId)?.providerRequestId,
-            providerItemId: existing?.providerItemId ?? itemIdFromToolCallId(event.toolCallId),
-            toolName: event.toolName,
-            status: event.isError ? "error" : "ok",
-            executionStartedAt,
-            executionEndedAt: now,
-            durationMs: durationMs(executionStartedAt, now),
-            argsBytes: existing?.argsBytes ?? 0,
-            parseStatus: existing?.parseStatus ?? "empty",
-            safeArgKeys: existing?.safeArgKeys ?? [],
-            eventId: turn.eventId,
-            errorCategory: event.isError ? "tool_error" : undefined,
-            errorMessage: event.isError ? safeErrorMessage(event.result) : undefined,
-        });
-        this.startOrProgressPhase(turn, "tool_execution", now, event.isError ? "tool execution failed" : "tool execution finished", {
-            toolCallId: event.toolCallId,
-            updateTurn: true,
-        });
-        this.closeOpenPhasesByName(turn.turnId, "tool_execution", event.isError ? "error" : "ok", now, event.isError ? "tool execution failed" : "tool execution finished");
-    }
-    recordPiToolCallProgress(turn, providerRequestId, summary, now) {
-        if (!summary.toolCallId)
-            return;
-        const existing = this.store?.getToolCall(summary.toolCallId);
-        const argsBytes = Math.max(existing?.argsBytes ?? 0, summary.argsBytes ?? 0, numericSafeField(summary.safeFields.deltaBytes));
-        const status = toolStatusForPiAssistantEvent(summary.assistantEventType, argsBytes, existing?.status);
-        const parseStatus = summary.assistantEventType === "toolcall_end" ? "complete" : argsBytes > 0 ? existing?.parseStatus === "complete" ? "complete" : "partial" : existing?.parseStatus ?? "empty";
-        this.telemetry.upsertToolCall({
-            toolCallId: summary.toolCallId,
-            piboSessionId: turn.piboSessionId,
-            rootSessionId: turn.rootSessionId,
-            roomId: turn.roomId,
-            turnId: turn.turnId,
-            providerRequestId,
-            providerItemId: summary.itemId ?? itemIdFromToolCallId(summary.toolCallId),
-            toolName: summary.toolName ?? existing?.toolName ?? "tool",
-            status,
-            argsStartedAt: existing?.argsStartedAt ?? now,
-            firstDeltaAt: existing?.firstDeltaAt ?? (argsBytes > 0 ? now : undefined),
-            lastDeltaAt: argsBytes > 0 ? now : existing?.lastDeltaAt,
-            argsCompletedAt: summary.assistantEventType === "toolcall_end" ? now : existing?.argsCompletedAt,
-            argsBytes,
-            parseStatus,
-            safeArgKeys: summary.safeArgKeys && summary.safeArgKeys.length > 0 ? summary.safeArgKeys : existing?.safeArgKeys ?? [],
-            eventId: turn.eventId,
-        });
-    }
-    upsertToolCallArgs(turn, input) {
-        const existing = this.store?.getToolCall(input.toolCallId);
-        const args = toolArgsMetadata(input.args, input.argsComplete);
-        const hasArgsProgress = args.argsBytes > 0;
-        this.telemetry.upsertToolCall({
-            toolCallId: input.toolCallId,
-            piboSessionId: turn.piboSessionId,
-            rootSessionId: turn.rootSessionId,
-            roomId: turn.roomId,
-            turnId: turn.turnId,
-            providerRequestId: input.providerRequestId,
-            providerItemId: itemIdFromToolCallId(input.toolCallId),
-            toolName: input.toolName,
-            status: input.argsComplete ? "args_complete" : hasArgsProgress ? "args_partial" : "args_started",
-            argsStartedAt: existing?.argsStartedAt ?? input.now,
-            firstDeltaAt: existing?.firstDeltaAt ?? (hasArgsProgress ? input.now : undefined),
-            lastDeltaAt: hasArgsProgress ? input.now : existing?.lastDeltaAt,
-            argsCompletedAt: input.argsComplete ? input.now : existing?.argsCompletedAt,
-            argsBytes: Math.max(existing?.argsBytes ?? 0, args.argsBytes),
-            parseStatus: args.parseStatus,
-            safeArgKeys: args.safeArgKeys.length > 0 ? args.safeArgKeys : existing?.safeArgKeys ?? [],
-            eventId: turn.eventId,
-        });
-    }
-    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;
-        const existingTurn = this.store?.getTurn(turn.turnId);
-        if (existingTurn && TERMINAL_TURN_STATUSES.has(existingTurn.status)) {
-            this.clearTurnProgress(turn.turnId);
-            return;
-        }
-        const now = telemetryTimestamp(context);
-        this.flushProviderProgress(turn.turnId, now, { force: true, includeLatest: true, nowMs: telemetryTimestampMs(context) });
-        this.finishOpenPhases(turn.turnId, terminalPhaseStatus(status), now);
-        this.finishActiveProviderRequests(turn.turnId, providerStatusForTurnStatus(status), now, summary, errorCategory);
-        this.finishActiveToolCalls(turn.turnId, status, now, summary);
-        this.telemetry.upsertPhase({
-            phaseId: phaseId(turn.turnId, phaseName),
-            turnId: turn.turnId,
-            piboSessionId: turn.piboSessionId,
-            rootSessionId: turn.rootSessionId,
-            roomId: turn.roomId,
-            name: phaseName,
-            status: terminalPhaseStatus(status),
-            startedAt: now,
-            endedAt: now,
-            lastProgressAt: now,
-            eventId: turn.eventId,
-            summary: safeSummary(summary),
-        });
-        this.telemetry.upsertTurn({
-            turnId: turn.turnId,
-            piboSessionId: turn.piboSessionId,
-            rootSessionId: turn.rootSessionId,
-            roomId: turn.roomId,
-            eventId: turn.eventId,
-            status,
-            currentPhase: phaseName,
-            completedAt: now,
-            lastProgressAt: now,
-            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),
-            turnId: turn.turnId,
-            piboSessionId: turn.piboSessionId,
-            rootSessionId: turn.rootSessionId,
-            roomId: turn.roomId,
-            name: phaseName,
-            status: "open",
-            startedAt: existing?.startedAt ?? now,
-            lastProgressAt: now,
-            providerRequestId: options.providerRequestId,
-            toolCallId: options.toolCallId,
-            eventId: turn.eventId,
-            summary,
-        });
-        if (options.updateTurn) {
-            this.telemetry.upsertTurn({
-                turnId: turn.turnId,
-                piboSessionId: turn.piboSessionId,
-                rootSessionId: turn.rootSessionId,
-                roomId: turn.roomId,
-                eventId: turn.eventId,
-                status: "running",
-                currentPhase: phaseName,
-                lastProgressAt: now,
-                queueDepth: turn.queueDepth,
-                summary,
-            });
-        }
-        return phase;
-    }
-    openPhaseByName(turnId, phaseName) {
-        return this.store?.getOpenPhaseForTurn(turnId, phaseName);
-    }
-    nextPhaseId(turnId, phaseName) {
-        const base = phaseId(turnId, phaseName);
-        const count = this.store?.countPhasesForTurn(turnId, phaseName) ?? 0;
-        if (count === 0)
-            return base;
-        return `${base}:${count + 1}`;
-    }
-    finishOpenPhasesByName(turnId, phaseName, status, now = new Date().toISOString(), summary) {
-        if (!turnId)
-            return;
-        for (const phase of this.store?.listOpenPhasesForTurn(turnId) ?? []) {
-            if (phase.name !== phaseName)
-                continue;
-            this.telemetry.finishPhase(phase.phaseId, { status, endedAt: now, lastProgressAt: now, summary });
-        }
-    }
-    closeOpenPhasesByName(turnId, phaseName, status, now, summary) {
-        this.finishOpenPhasesByName(turnId, phaseName, status, now, summary);
-    }
-    finishOpenPhases(turnId, status, now) {
-        for (const phase of this.store?.listOpenPhasesForTurn(turnId) ?? []) {
-            this.telemetry.finishPhase(phase.phaseId, { status, endedAt: now, lastProgressAt: now });
-        }
-    }
-    activeProviderRequestForTurn(turnId) {
-        return this.store?.getActiveProviderRequestForTurn(turnId);
-    }
-    latestProviderRequestForTurn(turnId) {
-        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, nowMs) {
-        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,
-            nowMs,
-        });
-    }
-    accumulateNormalizedProviderProgress(turn, now, force = false, nowMs = Date.now()) {
-        const request = this.providerRequestForTurn(turn.turnId, { includeLatest: force });
-        if (!request)
-            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, nowMs }) ?? request;
-    }
-    flushProviderProgress(turnId, now, options = {}) {
-        const pending = this.pendingProviderProgress.get(turnId);
-        const request = this.providerRequestForTurn(turnId, options);
-        if (!pending)
-            return request;
-        const nowMs = options.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, 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;
-    }
-    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" ? errorCategory ?? "runtime_error" : undefined,
-                errorMessage: status === "error" ? safeSummary(summary) : undefined,
-            });
-        }
-    }
-    finishActiveToolCalls(turnId, status, now, summary) {
-        if (status === "ok")
-            return;
-        for (const toolCall of this.store?.listActiveToolCallsForTurn(turnId) ?? []) {
-            const terminalStatus = terminalToolCallStatus(status);
-            this.telemetry.upsertToolCall({
-                toolCallId: toolCall.toolCallId,
-                piboSessionId: toolCall.piboSessionId,
-                rootSessionId: toolCall.rootSessionId,
-                roomId: toolCall.roomId,
-                turnId: toolCall.turnId,
-                providerRequestId: toolCall.providerRequestId,
-                providerItemId: toolCall.providerItemId,
-                outputIndex: toolCall.outputIndex,
-                toolName: toolCall.toolName,
-                status: terminalStatus,
-                executionStartedAt: toolCall.executionStartedAt,
-                executionEndedAt: toolCall.executionStartedAt ? now : toolCall.executionEndedAt,
-                durationMs: toolCall.executionStartedAt ? durationMs(toolCall.executionStartedAt, now) : toolCall.durationMs,
-                argsBytes: toolCall.argsBytes,
-                parseStatus: toolCall.parseStatus,
-                safeArgKeys: toolCall.safeArgKeys,
-                eventId: toolCall.eventId,
-                errorCategory: terminalStatus === "error" ? "runtime_error" : terminalStatus === "aborted" ? "runtime_aborted" : "runtime_timeout",
-                errorMessage: terminalStatus === "error" ? safeSummary(summary) : undefined,
-            });
-        }
-    }
-    upsertProviderRequestFromExisting(request, input) {
-        this.telemetry.upsertProviderRequest({
-            providerRequestId: request.providerRequestId,
-            piboSessionId: request.piboSessionId,
-            rootSessionId: request.rootSessionId,
-            roomId: request.roomId,
-            turnId: request.turnId,
-            phaseId: request.phaseId,
-            provider: request.provider,
-            api: request.api,
-            model: request.model,
-            transport: request.transport,
-            serviceTier: request.serviceTier,
-            status: input.status ?? request.status,
-            responseHeadersAt: request.responseHeadersAt,
-            firstByteAt: request.firstByteAt,
-            lastRawEventAt: request.lastRawEventAt,
-            lastNormalizedEventAt: input.lastNormalizedEventAt ?? request.lastNormalizedEventAt,
-            completedAt: input.completedAt ?? request.completedAt,
-            httpStatus: request.httpStatus,
-            upstreamResponseId: input.upstreamResponseId ?? request.upstreamResponseId,
-            rawEventCount: request.rawEventCount,
-            normalizedEventCount: input.normalizedEventCount ?? request.normalizedEventCount,
-            parseErrorCount: request.parseErrorCount,
-            unknownEventCount: request.unknownEventCount,
-            bytesReceived: request.bytesReceived,
-            eventTypeCounts: request.eventTypeCounts,
-            eventStreamId: request.eventStreamId,
-            eventId: request.eventId,
-            payloadRef: request.payloadRef,
-            errorCategory: input.errorCategory ?? request.errorCategory,
-            errorMessage: input.errorMessage ?? request.errorMessage,
-            captureMode: request.captureMode,
-            retentionClass: request.retentionClass,
-        });
-    }
-    progressTurnContextForEvent(piboSessionId, eventId, context) {
-        return {
-            turnId: turnIdForEvent(eventId),
-            eventId,
-            piboSessionId,
-            rootSessionId: rootSessionIdFor(context.session, piboSessionId),
-            roomId: roomIdFor(context.session),
-            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;
-        if (!active || TERMINAL_TURN_STATUSES.has(active.status))
-            return undefined;
-        return {
-            turnId: active.turnId,
-            eventId: active.eventId ?? active.inputEventId,
-            piboSessionId,
-            rootSessionId: active.rootSessionId ?? rootSessionIdFor(context.session, piboSessionId),
-            roomId: active.roomId ?? roomIdFor(context.session),
-            source: active.source,
-            queueDepth: context.status?.queuedMessages ?? active.queueDepth,
-        };
-    }
-}
-function emptyPendingProviderProgress() {
-    return {
-        rawEventCount: 0,
-        normalizedEventCount: 0,
-        parseErrorCount: 0,
-        unknownEventCount: 0,
-        bytesReceived: 0,
-        eventTypeCounts: {},
-    };
-}
-function providerEventSummaryForPiEvent(event) {
-    if (!event || typeof event !== "object")
-        return undefined;
-    const candidate = event;
-    if (candidate.type !== "message_update" && candidate.type !== "message_end")
-        return undefined;
-    const assistantType = typeof candidate.assistantMessageEvent?.type === "string" ? candidate.assistantMessageEvent.type : undefined;
-    const eventType = assistantType ? `pi.${assistantType}` : `pi.${String(candidate.type)}`;
-    const parseStatus = assistantType && !KNOWN_PI_ASSISTANT_EVENTS.has(assistantType) ? "unknown_type" : "ok";
-    const toolCall = candidate.assistantMessageEvent?.toolCall;
-    const toolCallId = stringValue(toolCall?.id) ?? stringValue(candidate.toolCallId) ?? toolCallIdFromMessage(candidate.message);
-    const toolName = stringValue(toolCall?.name) ?? stringValue(candidate.toolName) ?? toolNameFromMessage(candidate.message);
-    const deltaBytes = typeof candidate.assistantMessageEvent?.delta === "string" ? utf8Bytes(candidate.assistantMessageEvent.delta) : undefined;
-    const contentBytes = typeof candidate.assistantMessageEvent?.content === "string" ? utf8Bytes(candidate.assistantMessageEvent.content) : undefined;
-    const argsValue = toolCall?.arguments === undefined ? argsFromMessage(candidate.message) : toolCall.arguments;
-    const argsBytes = argsValue === undefined ? undefined : safeJsonByteSize(argsValue);
-    const safeArgKeys = argsValue === undefined ? undefined : toolArgsMetadata(argsValue, assistantType === "toolcall_end").safeArgKeys;
-    const upstreamResponseId = responseIdFromMessage(candidate.message);
-    const safeFields = {
-        piEventType: String(candidate.type),
-    };
-    if (assistantType)
-        safeFields.assistantEventType = assistantType;
-    if (typeof candidate.assistantMessageEvent?.contentIndex === "number")
-        safeFields.contentIndex = candidate.assistantMessageEvent.contentIndex;
-    if (deltaBytes !== undefined)
-        safeFields.deltaBytes = deltaBytes;
-    if (contentBytes !== undefined)
-        safeFields.contentBytes = contentBytes;
-    if (argsBytes !== undefined)
-        safeFields.argsBytes = argsBytes;
-    if (toolName)
-        safeFields.toolName = toolName;
-    if (toolCallId)
-        safeFields.toolCallId = toolCallId;
-    if (upstreamResponseId)
-        safeFields.upstreamResponseId = upstreamResponseId;
-    const byteSize = safeJsonByteSize(safeFields);
-    return {
-        eventType,
-        messageEnded: candidate.type === "message_end",
-        assistantEventType: assistantType,
-        parseStatus,
-        normalizedType: normalizedTypeForPiAssistantEvent(assistantType),
-        byteSize,
-        itemId: itemIdFromToolCallId(toolCallId),
-        toolCallId,
-        toolName,
-        argsBytes,
-        safeArgKeys,
-        safeFields,
-        upstreamResponseId,
-    };
-}
-const KNOWN_PI_ASSISTANT_EVENTS = new Set([
-    "start",
-    "text_start",
-    "text_delta",
-    "text_end",
-    "thinking_start",
-    "thinking_delta",
-    "thinking_end",
-    "toolcall_start",
-    "toolcall_delta",
-    "toolcall_end",
-    "done",
-    "error",
-]);
-function normalizedTypeForPiAssistantEvent(type) {
-    if (!type)
-        return undefined;
-    if (type === "text_delta")
-        return "assistant_delta";
-    if (type === "text_end")
-        return "assistant_message";
-    if (type === "thinking_start")
-        return "thinking_started";
-    if (type === "thinking_delta")
-        return "thinking_delta";
-    if (type === "thinking_end")
-        return "thinking_finished";
-    if (type === "toolcall_start" || type === "toolcall_delta" || type === "toolcall_end")
-        return "tool_call";
-    return undefined;
-}
-function toolArgsMetadata(args, argsComplete) {
-    if (args === undefined || args === null || args === "")
-        return { argsBytes: 0, parseStatus: argsComplete ? "invalid" : "empty", safeArgKeys: [] };
-    const argsBytes = typeof args === "string" ? utf8Bytes(args) : safeJsonByteSize(args);
-    if (typeof args === "string") {
-        const trimmed = args.trim();
-        if (!trimmed)
-            return { argsBytes: 0, parseStatus: argsComplete ? "invalid" : "empty", safeArgKeys: [] };
-        try {
-            const parsed = JSON.parse(trimmed);
-            return { argsBytes, parseStatus: argsComplete ? "complete" : "valid", safeArgKeys: safeTopLevelKeys(parsed) };
-        }
-        catch (error) {
-            return { argsBytes, parseStatus: isLikelyPartialJson(trimmed, error) ? "partial" : "invalid", safeArgKeys: [] };
-        }
-    }
-    return { argsBytes, parseStatus: argsComplete ? "complete" : "valid", safeArgKeys: safeTopLevelKeys(args) };
-}
-function safeTopLevelKeys(value, limit = 50) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return [];
-    return Object.keys(value).filter((key) => key.length <= 128).slice(0, limit);
-}
-function isLikelyPartialJson(value, error) {
-    if (error instanceof SyntaxError && /end of JSON input/i.test(error.message))
-        return true;
-    const opens = (value.match(/[\[{]/g) ?? []).length;
-    const closes = (value.match(/[\]}]/g) ?? []).length;
-    return opens > closes || /[:,]$/.test(value);
-}
-function toolStatusForPiAssistantEvent(type, argsBytes, existingStatus) {
-    if (type === "toolcall_end")
-        return "args_complete";
-    if (type === "toolcall_delta")
-        return argsBytes > 0 ? "args_partial" : existingStatus ?? "args_started";
-    return existingStatus ?? "args_started";
-}
-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")
-        return "aborted";
-    if (status === "timeout")
-        return "timeout";
-    return "error";
-}
-function durationMs(startedAt, endedAt) {
-    if (!startedAt)
-        return undefined;
-    const startMs = Date.parse(startedAt);
-    const endMs = Date.parse(endedAt);
-    return Number.isFinite(startMs) && Number.isFinite(endMs) ? Math.max(0, endMs - startMs) : undefined;
-}
-function numericSafeField(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-function safeErrorMessage(value) {
-    if (typeof value === "string")
-        return safeSummary(value);
-    if (value && typeof value === "object") {
-        const record = value;
-        const message = stringValue(record.message) ?? stringValue(record.error) ?? stringValue(record.status);
-        return message ? safeSummary(message) : undefined;
-    }
-    return undefined;
-}
-function stringValue(value) {
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-function responseIdFromMessage(message) {
-    if (!message || typeof message !== "object")
-        return undefined;
-    const value = message.responseId;
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-function toolCallIdFromMessage(message) {
-    const block = lastToolCallBlock(message);
-    return stringValue(block?.id);
-}
-function toolNameFromMessage(message) {
-    const block = lastToolCallBlock(message);
-    return stringValue(block?.name);
-}
-function argsFromMessage(message) {
-    const block = lastToolCallBlock(message);
-    return block && "arguments" in block ? block.arguments : undefined;
-}
-function lastToolCallBlock(message) {
-    if (!message || typeof message !== "object")
-        return undefined;
-    const content = message.content;
-    if (!Array.isArray(content))
-        return undefined;
-    for (let index = content.length - 1; index >= 0; index -= 1) {
-        const block = content[index];
-        if (!block || typeof block !== "object")
-            continue;
-        if (block.type === "toolCall")
-            return block;
-    }
-    return undefined;
-}
-function itemIdFromToolCallId(toolCallId) {
-    if (!toolCallId)
-        return undefined;
-    const [, itemId] = toolCallId.split("|");
-    return itemId && itemId.length > 0 ? itemId : undefined;
-}
-function safeJsonByteSize(value) {
-    try {
-        return utf8Bytes(JSON.stringify(value));
-    }
-    catch {
-        return 0;
-    }
-}
-function utf8Bytes(value) {
-    return Buffer.byteLength(value, "utf8");
-}
-function telemetryOutputEventSnapshot(event) {
-    if (event.type === "tool_execution_updated")
-        return { ...event, partialResult: undefined };
-    if (event.type === "tool_execution_finished")
-        return { ...event, result: event.isError ? safeErrorMessage(event.result) : undefined };
-    if (event.type === "execution_result")
-        return { ...event, result: undefined };
-    return { ...event };
-}
-function captureTelemetryContext(context) {
-    const parsedAtMs = context.at ? Date.parse(context.at) : Number.NaN;
-    const atMs = context.atMs ?? (Number.isFinite(parsedAtMs) ? parsedAtMs : Date.now());
-    return {
-        ...context,
-        session: context.session ? { ...context.session, metadata: context.session.metadata ? { ...context.session.metadata } : undefined } : undefined,
-        status: context.status ? { ...context.status, activeTools: [...context.status.activeTools], enabledTools: [...context.status.enabledTools] } : undefined,
-        at: context.at ?? new Date(atMs).toISOString(),
-        atMs,
-    };
-}
-function telemetryTimestamp(context) {
-    return context.at ?? new Date().toISOString();
-}
-function telemetryTimestampMs(context) {
-    return context.atMs ?? Date.now();
-}
-export function turnIdForEvent(eventId) {
-    return `turn_${eventId}`;
-}
-function phaseId(turnId, phaseName) {
-    return `${turnId}:${phaseName}`;
-}
-function telemetrySource(source) {
-    if (source === "user")
-        return "user";
-    if (source === "ui")
-        return "ui";
-    if (source === "service")
-        return "system";
-    return "rpc";
-}
-function terminalPhaseStatus(status) {
-    if (status === "ok")
-        return "ok";
-    if (status === "aborted")
-        return "aborted";
-    if (status === "timeout")
-        return "timeout";
-    return "error";
-}
-function providerStatusForTurnStatus(status) {
-    if (status === "ok")
-        return "completed";
-    if (status === "aborted")
-        return "aborted";
-    if (status === "timeout")
-        return "timeout";
-    return "error";
-}
-function rootSessionIdFor(session, fallback) {
-    if (!session)
-        return fallback;
-    if (session.parentId) {
-        const value = session.metadata?.rootSessionId;
-        return typeof value === "string" && value.length > 0 ? value : session.parentId;
-    }
-    return session.id;
-}
-function roomIdFor(session) {
-    const value = session?.metadata?.chatRoomId;
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-function sessionMetadata(session) {
-    const metadata = {};
-    if (session?.channel)
-        metadata.channel = session.channel;
-    if (session?.kind)
-        metadata.kind = session.kind;
-    if (session?.profile)
-        metadata.profile = session.profile;
-    return metadata;
-}
-function safeSummary(summary) {
-    return summary.replace(/\s+/g, " ").trim().slice(0, 512);
-}