@pasko70/pibo 1.0.5 → 1.2.0

package/dist/core/runtime-telemetry.js

@@ -0,0 +1,853 @@
+import { BestEffortTelemetryService, } from "../data/telemetry.js";
+import { isTerminalProviderStatus } from "./provider-telemetry.js";
+const TERMINAL_TURN_STATUSES = new Set(["ok", "error", "aborted", "timeout"]);
+export class PiboRuntimeTelemetryRecorder {
+    store;
+    onError;
+    telemetry;
+    constructor(store, onError) {
+        this.store = store;
+        this.onError = onError;
+        this.telemetry = new BestEffortTelemetryService(store, onError);
+    }
+    recordOutput(event, context = {}) {
+        if (!this.store)
+            return;
+        try {
+            this.recordOutputUnsafe(event, context);
+        }
+        catch (error) {
+            this.onError?.(error);
+        }
+    }
+    recordPiEvent(piboSessionId, event, context = {}) {
+        if (!this.store)
+            return;
+        try {
+            this.recordPiEventUnsafe(piboSessionId, event, context);
+        }
+        catch (error) {
+            this.onError?.(error);
+        }
+    }
+    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":
+            case "assistant_message":
+                this.recordProviderStreamProgress(event, context, "assistant_text", "assistant text progress");
+                return;
+            case "thinking_started":
+            case "thinking_delta":
+                this.recordProviderStreamProgress(event, context, "reasoning", "reasoning progress");
+                return;
+            case "thinking_finished": {
+                this.recordProviderStreamProgress(event, context, "reasoning", "reasoning finished");
+                const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, undefined, context) ?? this.activeTurnContext(event.piboSessionId, context);
+                this.finishOpenPhasesByName(turn?.turnId, "reasoning", "ok");
+                return;
+            }
+            case "tool_call":
+                this.recordToolArgsPhase(event, context);
+                return;
+            case "tool_execution_started":
+            case "tool_execution_updated":
+                this.recordToolExecutionPhase(event, context);
+                return;
+            case "tool_execution_finished":
+                this.recordToolExecutionFinished(event, context);
+                return;
+            case "session_error":
+                this.recordTurnTerminal(event, context, "error", "error", event.error);
+                return;
+            case "execution_result":
+                this.recordExecutionResult(event, context);
+                return;
+            default:
+                return;
+        }
+    }
+    recordPiEventUnsafe(piboSessionId, event, context) {
+        const summary = providerEventSummaryForPiEvent(event);
+        if (!summary)
+            return;
+        const turn = context.activeEventId
+            ? this.turnContextForEvent(piboSessionId, context.activeEventId, undefined, 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 });
+        }
+        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);
+        }
+        this.startOrProgressPhase(turn, "provider_stream", now, "provider event metadata", { providerRequestId: providerRequest.providerRequestId });
+    }
+    recordMessageQueued(event, context) {
+        const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, event.source, context);
+        if (!turn)
+            return;
+        const now = new Date().toISOString();
+        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 = new Date().toISOString();
+        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_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);
+        if (!turn)
+            return;
+        const now = new Date().toISOString();
+        const providerRequest = this.activeProviderRequestForTurn(turn.turnId);
+        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 });
+        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 = new Date().toISOString();
+        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);
+        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) {
+        const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, undefined, context) ?? this.activeTurnContext(event.piboSessionId, context);
+        if (!turn)
+            return;
+        const now = new Date().toISOString();
+        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 = new Date().toISOString();
+        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,
+        });
+    }
+    recordTurnProgress(event, context, phaseName, summary) {
+        const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, undefined, context) ?? 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)
+            return;
+        const now = new Date().toISOString();
+        this.finishOpenPhases(turn.turnId, terminalPhaseStatus(status), now);
+        this.finishActiveProviderRequests(turn.turnId, providerStatusForTurnStatus(status), now, summary);
+        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),
+        });
+    }
+    startOrProgressPhase(turn, phaseName, now, summary, options = {}) {
+        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) {
+        const timeline = this.store?.getTurnTimeline(turnId, { limit: 100 });
+        return timeline?.phases.find((phase) => phase.name === phaseName && phase.status === "open");
+    }
+    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)
+            return base;
+        return `${base}:${phases.length + 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")
+                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) {
+        const timeline = this.store?.getTurnTimeline(turnId, { limit: 100 });
+        for (const phase of timeline?.phases ?? []) {
+            if (phase.status !== "open")
+                continue;
+            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));
+    }
+    latestProviderRequestForTurn(turnId) {
+        const timeline = this.store?.getTurnTimeline(turnId, { limit: 100 });
+        return timeline?.providerRequests.at(-1);
+    }
+    progressProviderRequest(request, now) {
+        if (!request)
+            return;
+        this.upsertProviderRequestFromExisting(request, {
+            status: "streaming",
+            lastNormalizedEventAt: now,
+            normalizedEventCount: request.normalizedEventCount + 1,
+        });
+    }
+    finishActiveProviderRequests(turnId, status, now, summary) {
+        const timeline = this.store?.getTurnTimeline(turnId, { limit: 100 });
+        for (const request of timeline?.providerRequests ?? []) {
+            if (isTerminalProviderStatus(request.status))
+                continue;
+            this.upsertProviderRequestFromExisting(request, {
+                status,
+                completedAt: now,
+                errorCategory: status === "error" ? "runtime_error" : undefined,
+                errorMessage: status === "error" ? safeSummary(summary) : undefined,
+            });
+        }
+    }
+    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;
+            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,
+        });
+    }
+    turnContextForEvent(piboSessionId, eventId, source, context) {
+        if (!eventId)
+            return undefined;
+        const rootSessionId = rootSessionIdFor(context.session, piboSessionId);
+        return {
+            turnId: turnIdForEvent(eventId),
+            eventId,
+            piboSessionId,
+            rootSessionId,
+            roomId: roomIdFor(context.session),
+            source: telemetrySource(source),
+            queueDepth: context.status?.queuedMessages,
+        };
+    }
+    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 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,
+        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 isTerminalToolCallStatus(status) {
+    return status === "ok" || status === "error" || status === "aborted" || status === "timeout";
+}
+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");
+}
+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);
+}