@pasko70/pibo 1.7.12 → 1.8.1

package/dist/apps/chat/workflow-manual-trigger-runtime.js

@@ -184,6 +184,7 @@ function emitMessageAndWaitForAssistant(channelContext, piboSessionId, text, tim
     return new Promise((resolve, reject) => {
         const eventId = `wfm_${randomUUID()}`;
         let settled = false;
+        let lastAssistantMessage;
         let timeout;
         let unsubscribe = () => { };
         const finish = (value) => {
@@ -197,16 +198,24 @@ function emitMessageAndWaitForAssistant(channelContext, piboSessionId, text, tim
             else
                 resolve(value);
         };
-        timeout = setTimeout(() => finish(new Error(`Timed out waiting for assistant reply from workflow agent session '${piboSessionId}'.`)), timeoutMs);
+        timeout = setTimeout(() => {
+            finish(new Error(`Timed out waiting for assistant reply from workflow agent session '${piboSessionId}'.`));
+            void channelContext.emit({ type: "execution", piboSessionId, action: "abort", id: `wfm_abort_${randomUUID()}` }).catch(() => { });
+        }, timeoutMs);
         unsubscribe = channelContext.subscribe((event) => {
             if (event.piboSessionId !== piboSessionId)
                 return;
+            if (!("eventId" in event) || event.eventId !== eventId)
+                return;
             if (event.type === "assistant_message") {
-                if (event.eventId === eventId)
-                    finish(event.text);
+                lastAssistantMessage = event.text;
+                return;
+            }
+            if (event.type === "message_finished") {
+                finish(lastAssistantMessage ?? new Error(`Workflow agent session '${piboSessionId}' finished without an assistant reply.`));
                 return;
             }
-            if (event.type === "session_error" && event.eventId === eventId)
+            if (event.type === "session_error")
                 finish(new Error(event.error));
         });
         channelContext.emit({ type: "message", piboSessionId, id: eventId, text, source: "actor" }).catch(finish);

package/dist/core/compaction-prompt.js

@@ -1,9 +1,11 @@
+import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { completeSimple } from "@earendil-works/pi-ai/compat";
 import { buildSessionContext, convertToLlm, serializeConversation, } from "@earendil-works/pi-coding-agent";
+import { isRetryablePiboAssistantError, isRetryablePiboProviderError, resolvePiboProviderRecoverySettings, waitForPiboProviderRecovery, } from "./provider-recovery.js";
 const PROJECT_ROOT = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
 export const PIBO_LIBRARY_COMPACTION_PROMPT_PATH = resolve(PROJECT_ROOT, "context/pibo-compaction-prompt.md");
 function getCompactionPromptStatePath(cwd) {
@@ -134,38 +136,62 @@ function buildTurnPrefixPrompt(spec, messages) {
     const conversationText = serializeConversation(convertToLlm(messages));
     return `<conversation>\n${conversationText}\n</conversation>\n\n${spec.turnPrefixSummaryPrompt}`;
 }
-async function completeSummary(input) {
-    const completionOptions = input.model.reasoning && input.thinkingLevel && input.thinkingLevel !== "off"
-        ? {
-            maxTokens: input.maxTokens,
-            signal: input.signal,
-            apiKey: input.apiKey,
-            headers: input.headers,
-            reasoning: input.thinkingLevel,
+export async function completePiboCompactionSummary(input) {
+    const recoverySessionId = input.sessionId ? `compaction-${randomUUID()}` : undefined;
+    const completionOptions = {
+        maxTokens: input.maxTokens,
+        signal: input.signal,
+        apiKey: input.apiKey,
+        headers: input.headers,
+        transport: input.transport,
+        sessionId: recoverySessionId,
+        timeoutMs: input.timeoutMs,
+        websocketConnectTimeoutMs: input.websocketConnectTimeoutMs,
+        maxRetries: input.maxRetries,
+        maxRetryDelayMs: input.maxRetryDelayMs,
+        ...(input.model.reasoning && input.thinkingLevel && input.thinkingLevel !== "off"
+            ? { reasoning: input.thinkingLevel }
+            : {}),
+    };
+    const complete = input.complete ?? completeSimple;
+    let recoveryAttempt = 0;
+    while (true) {
+        let response;
+        try {
+            response = await complete(input.model, {
+                systemPrompt: input.systemPrompt,
+                messages: [
+                    {
+                        role: "user",
+                        content: [{ type: "text", text: input.promptText }],
+                        timestamp: Date.now(),
+                    },
+                ],
+            }, completionOptions);
         }
-        : {
-            maxTokens: input.maxTokens,
-            signal: input.signal,
-            apiKey: input.apiKey,
-            headers: input.headers,
-        };
-    const response = await completeSimple(input.model, {
-        systemPrompt: input.systemPrompt,
-        messages: [
-            {
-                role: "user",
-                content: [{ type: "text", text: input.promptText }],
-                timestamp: Date.now(),
-            },
-        ],
-    }, completionOptions);
-    if (response.stopReason === "error") {
-        throw new Error(`Summarization failed: ${response.errorMessage || "Unknown error"}`);
+        catch (error) {
+            if (input.signal?.aborted || !input.recovery.enabled || !isRetryablePiboProviderError(error))
+                throw error;
+            recoveryAttempt += 1;
+            await waitForPiboProviderRecovery(recoveryAttempt, input.recovery, input.signal);
+            continue;
+        }
+        if (response.stopReason === "aborted") {
+            throw new Error("Summarization was aborted");
+        }
+        if (response.stopReason === "error") {
+            const error = new Error(`Summarization failed: ${response.errorMessage || "Unknown error"}`);
+            if (!input.recovery.enabled || !isRetryablePiboAssistantError(response))
+                throw error;
+            recoveryAttempt += 1;
+            await waitForPiboProviderRecovery(recoveryAttempt, input.recovery, input.signal);
+            continue;
+        }
+        return response.content
+            .filter((content) => content.type === "text")
+            .map((content) => content.text)
+            .join("\n");
     }
-    return response.content
-        .filter((content) => content.type === "text")
-        .map((content) => content.text)
-        .join("\n");
 }
 function computeFileLists(fileOps) {
     const modified = new Set([...fileOps.written, ...fileOps.edited]);
@@ -183,44 +209,44 @@ function formatFileOperations(readFiles, modifiedFiles) {
 }
 async function generatePiboCompaction(input) {
     const { preparation, spec } = input;
+    const completionDefaults = {
+        model: input.model,
+        systemPrompt: spec.systemPrompt,
+        apiKey: input.apiKey,
+        headers: input.headers,
+        signal: input.signal,
+        thinkingLevel: input.thinkingLevel,
+        transport: input.transport,
+        sessionId: input.sessionId,
+        timeoutMs: input.timeoutMs,
+        websocketConnectTimeoutMs: input.websocketConnectTimeoutMs,
+        maxRetries: input.maxRetries,
+        maxRetryDelayMs: input.maxRetryDelayMs,
+        recovery: input.recovery,
+    };
     let summary;
     if (preparation.isSplitTurn && preparation.turnPrefixMessages.length > 0) {
         const [historySummary, turnPrefixSummary] = await Promise.all([
             preparation.messagesToSummarize.length > 0
-                ? completeSummary({
-                    model: input.model,
-                    systemPrompt: spec.systemPrompt,
+                ? completePiboCompactionSummary({
+                    ...completionDefaults,
                     promptText: buildSummaryPrompt(spec, preparation.messagesToSummarize, input.customInstructions, preparation.previousSummary),
                     maxTokens: Math.floor(0.8 * preparation.settings.reserveTokens),
-                    apiKey: input.apiKey,
-                    headers: input.headers,
-                    signal: input.signal,
-                    thinkingLevel: input.thinkingLevel,
                 })
                 : Promise.resolve("No prior history."),
-            completeSummary({
-                model: input.model,
-                systemPrompt: spec.systemPrompt,
+            completePiboCompactionSummary({
+                ...completionDefaults,
                 promptText: buildTurnPrefixPrompt(spec, preparation.turnPrefixMessages),
                 maxTokens: Math.floor(0.5 * preparation.settings.reserveTokens),
-                apiKey: input.apiKey,
-                headers: input.headers,
-                signal: input.signal,
-                thinkingLevel: input.thinkingLevel,
             }),
         ]);
         summary = `${historySummary}\n\n---\n\n**Turn Context (split turn):**\n\n${turnPrefixSummary}`;
     }
     else {
-        summary = await completeSummary({
-            model: input.model,
-            systemPrompt: spec.systemPrompt,
+        summary = await completePiboCompactionSummary({
+            ...completionDefaults,
             promptText: buildSummaryPrompt(spec, preparation.messagesToSummarize, input.customInstructions, preparation.previousSummary),
             maxTokens: Math.floor(0.8 * preparation.settings.reserveTokens),
-            apiKey: input.apiKey,
-            headers: input.headers,
-            signal: input.signal,
-            thinkingLevel: input.thinkingLevel,
         });
     }
     const { readFiles, modifiedFiles } = computeFileLists(preparation.fileOps);
@@ -232,7 +258,7 @@ async function generatePiboCompaction(input) {
         details: { readFiles, modifiedFiles },
     };
 }
-export function createPiboCompactionPromptExtension() {
+export function createPiboCompactionPromptExtension(options = {}) {
     return (pi) => {
         pi.on("session_before_compact", async (event, ctx) => {
             if (!ctx.model)
@@ -241,6 +267,8 @@ export function createPiboCompactionPromptExtension() {
             if (!auth.ok || !auth.apiKey)
                 return undefined;
             const sessionContext = buildSessionContext(ctx.sessionManager.getEntries(), ctx.sessionManager.getLeafId());
+            const settingsManager = options.getSettingsManager?.();
+            const providerRetry = settingsManager?.getProviderRetrySettings();
             return {
                 compaction: await generatePiboCompaction({
                     preparation: event.preparation,
@@ -251,6 +279,13 @@ export function createPiboCompactionPromptExtension() {
                     customInstructions: event.customInstructions,
                     signal: event.signal,
                     thinkingLevel: sessionContext.thinkingLevel,
+                    transport: settingsManager?.getTransport(),
+                    sessionId: ctx.sessionManager.getSessionId(),
+                    timeoutMs: settingsManager?.getHttpIdleTimeoutMs(),
+                    websocketConnectTimeoutMs: settingsManager?.getWebSocketConnectTimeoutMs(),
+                    maxRetries: providerRetry?.maxRetries,
+                    maxRetryDelayMs: providerRetry?.maxRetryDelayMs,
+                    recovery: resolvePiboProviderRecoverySettings(settingsManager),
                 }),
             };
         });

package/dist/core/context-guard.js

@@ -1,7 +1,92 @@
 import { DEFAULT_COMPACTION_SETTINGS, buildSessionContext, estimateTokens, } from "@earendil-works/pi-coding-agent";
 export const PIBO_CONTEXT_GUARD_NOTICE = "Context safety interrupted this response before adding it to long-term context. Pibo is compacting the session before continuing.";
+export const PIBO_CONTEXT_GUARD_RESUME_MESSAGE_TYPE = "pibo-context-guard-resume";
+export const PIBO_CONTEXT_GUARD_RESUME_PROMPT = "Continue the interrupted task autonomously from the compacted context. Do not wait for additional user input and do not repeat the context-safety notice.";
 const DEFAULT_MIN_COMPACTION_RESERVE_TOKENS = 1024;
 const FALLBACK_CONTEXT_WINDOW = 0;
+const MAX_CONTEXT_GUARD_RECOVERY_ATTEMPTS = 3;
+const contextGuardRecoveries = new WeakMap();
+export function createPiboAssistantContextGuardRecovery() {
+    let pending;
+    let claimed = false;
+    let cancelError;
+    let cancelHandler;
+    return {
+        begin() {
+            if (pending && !pending.settled)
+                return;
+            cancelError = undefined;
+            let resolve;
+            const promise = new Promise((done) => {
+                resolve = done;
+            });
+            pending = { promise, resolve, settled: false };
+        },
+        complete() {
+            if (!pending || pending.settled)
+                return;
+            pending.settled = true;
+            pending.resolve({ ok: true });
+        },
+        fail(error) {
+            if (!pending || pending.settled)
+                return;
+            pending.settled = true;
+            pending.resolve({ ok: false, error });
+        },
+        cancel(error) {
+            cancelError = error;
+            if (pending && !pending.settled) {
+                pending.settled = true;
+                pending.resolve({ ok: false, error });
+            }
+            cancelHandler?.();
+        },
+        claim() {
+            claimed = true;
+        },
+        isClaimed() {
+            return claimed;
+        },
+        isPending() {
+            return pending !== undefined && !pending.settled;
+        },
+        onCancel(handler) {
+            cancelHandler = handler;
+        },
+        async wait() {
+            const current = pending;
+            if (!current)
+                return false;
+            const outcome = await current.promise;
+            const cancelled = cancelError;
+            if (pending === current) {
+                pending = undefined;
+                cancelError = undefined;
+            }
+            if (cancelled)
+                throw cancelled;
+            if (!outcome.ok)
+                throw outcome.error;
+            return true;
+        },
+    };
+}
+export function registerPiboAssistantContextGuardRecovery(session, recovery) {
+    contextGuardRecoveries.set(session, recovery);
+}
+export function claimPiboAssistantContextGuardRecovery(session) {
+    contextGuardRecoveries.get(session)?.claim();
+}
+export function cancelPiboAssistantContextGuardRecovery(session, error) {
+    contextGuardRecoveries.get(session)?.cancel(error);
+}
+export function isPiboAssistantContextGuardRecoveryPending(session) {
+    return contextGuardRecoveries.get(session)?.isPending() ?? false;
+}
+export async function waitForPiboAssistantContextGuardRecovery(session) {
+    return await contextGuardRecoveries.get(session)?.wait() ?? false;
+}
 function textTokensByLength(length) {
     return Math.ceil(length / 4);
 }
@@ -79,15 +164,43 @@ function compactionInstructions(projection) {
         : "";
     return `Pibo interrupted the previous assistant response before persisting the full output because it would exceed the safe context budget.${usage} Summarize the durable conversation up to the guard notice, preserve the user's current task and important recent facts, and leave enough context budget for the next response.`;
 }
-export function createPiboAssistantContextGuardExtension(options = {}) {
+export function createPiboAssistantContextGuardExtension(options = {}, recovery = createPiboAssistantContextGuardRecovery()) {
     return (pi) => {
-        const state = { deltaChars: 0, tripped: false, compactQueued: false };
+        const state = {
+            deltaChars: 0,
+            tripped: false,
+            compactQueued: false,
+            resumeRequested: false,
+            resumeInProgress: false,
+            resumeSettling: false,
+            recoveryAttempts: 0,
+        };
         function resetAssistantState() {
             state.deltaChars = 0;
             state.tripped = false;
             state.compactQueued = false;
             state.lastProjection = undefined;
         }
+        function clearResumeStartTimer() {
+            if (state.resumeStartTimer === undefined)
+                return;
+            clearTimeout(state.resumeStartTimer);
+            state.resumeStartTimer = undefined;
+        }
+        function resetRecoveryState() {
+            clearResumeStartTimer();
+            state.tripped = false;
+            state.compactQueued = false;
+            state.resumeRequested = false;
+            state.resumeInProgress = false;
+            state.resumeSettling = false;
+            state.recoveryAttempts = 0;
+        }
+        function failRecovery(error) {
+            resetRecoveryState();
+            recovery.fail(error);
+        }
+        recovery.onCancel(resetRecoveryState);
         function tripIfNeeded(ctx, assistantTokens) {
             const projection = projectAssistantContextGuard(ctx, assistantTokens, options);
             state.lastProjection = projection;
@@ -96,6 +209,20 @@ export function createPiboAssistantContextGuardExtension(options = {}) {
             state.tripped = true;
             return true;
         }
+        pi.on("agent_start", () => {
+            if (!state.resumeRequested)
+                return;
+            clearResumeStartTimer();
+            state.resumeRequested = false;
+            state.resumeInProgress = true;
+        });
+        pi.on("agent_settled", () => {
+            if (!state.resumeSettling)
+                return;
+            state.resumeSettling = false;
+            state.recoveryAttempts = 0;
+            recovery.complete();
+        });
         pi.on("message_start", (event) => {
             if (event.message.role === "assistant")
                 resetAssistantState();
@@ -117,10 +244,50 @@ export function createPiboAssistantContextGuardExtension(options = {}) {
             return { message: replacementAssistantMessage(event.message) };
         });
         pi.on("agent_end", (_event, ctx) => {
-            if (!state.tripped || state.compactQueued)
+            if (state.tripped && !state.compactQueued) {
+                if (state.recoveryAttempts >= MAX_CONTEXT_GUARD_RECOVERY_ATTEMPTS) {
+                    failRecovery(new Error(`Context guard recovery exceeded ${MAX_CONTEXT_GUARD_RECOVERY_ATTEMPTS} compaction attempts`));
+                    return;
+                }
+                state.compactQueued = true;
+                state.recoveryAttempts++;
+                recovery.begin();
+                let callbackHandled = false;
+                ctx.compact({
+                    customInstructions: compactionInstructions(state.lastProjection),
+                    onComplete: () => {
+                        if (callbackHandled || !recovery.isPending())
+                            return;
+                        callbackHandled = true;
+                        state.tripped = false;
+                        state.compactQueued = false;
+                        state.resumeRequested = true;
+                        if (recovery.isClaimed()) {
+                            recovery.complete();
+                            return;
+                        }
+                        state.resumeStartTimer = setTimeout(() => {
+                            failRecovery(new Error("Context guard continuation did not start"));
+                        }, 5000);
+                        pi.sendMessage({
+                            customType: PIBO_CONTEXT_GUARD_RESUME_MESSAGE_TYPE,
+                            content: [{ type: "text", text: PIBO_CONTEXT_GUARD_RESUME_PROMPT }],
+                            display: false,
+                        }, { triggerTurn: true });
+                    },
+                    onError: (error) => {
+                        if (callbackHandled || !recovery.isPending())
+                            return;
+                        callbackHandled = true;
+                        failRecovery(error);
+                    },
+                });
+                return;
+            }
+            if (!state.resumeInProgress)
                 return;
-            state.compactQueued = true;
-            ctx.compact({ customInstructions: compactionInstructions(state.lastProjection) });
+            state.resumeInProgress = false;
+            state.resumeSettling = true;
         });
     };
 }

package/dist/core/provider-recovery.js

@@ -0,0 +1,64 @@
+import { isRetryableAssistantError } from "@earendil-works/pi-ai";
+import { classifySessionErrorMessage } from "./session-errors.js";
+export const PIBO_PROVIDER_RECOVERY_MESSAGE_TYPE = "pibo-provider-recovery-resume";
+export const PIBO_PROVIDER_RECOVERY_PROMPT = "Continue the interrupted task autonomously from the existing session state. The previous provider request failed transiently. Do not wait for more user input, ask the user to repeat the request, or mention this recovery message unless the failure affects the result.";
+const DEFAULT_RECOVERY_BASE_DELAY_MS = 2_000;
+const DEFAULT_RECOVERY_MAX_DELAY_MS = 60_000;
+export class PiboProviderRecoveryCancelledError extends Error {
+    constructor(message = "Provider recovery cancelled") {
+        super(message);
+        this.name = "PiboProviderRecoveryCancelledError";
+    }
+}
+export function resolvePiboProviderRecoverySettings(settingsManager) {
+    if (!settingsManager) {
+        return {
+            enabled: false,
+            baseDelayMs: DEFAULT_RECOVERY_BASE_DELAY_MS,
+            maxDelayMs: DEFAULT_RECOVERY_MAX_DELAY_MS,
+        };
+    }
+    const retry = settingsManager.getRetrySettings();
+    const provider = settingsManager.getProviderRetrySettings();
+    return {
+        enabled: retry.enabled,
+        baseDelayMs: Math.max(0, retry.baseDelayMs),
+        maxDelayMs: provider.maxRetryDelayMs > 0 ? provider.maxRetryDelayMs : DEFAULT_RECOVERY_MAX_DELAY_MS,
+    };
+}
+export function piboProviderRecoveryDelayMs(attempt, settings) {
+    const exponent = Math.max(0, Math.floor(attempt) - 1);
+    const uncapped = settings.baseDelayMs * 2 ** Math.min(exponent, 30);
+    return Math.min(settings.maxDelayMs, Number.isFinite(uncapped) ? uncapped : settings.maxDelayMs);
+}
+export function isRetryablePiboAssistantError(message) {
+    if (!message || typeof message !== "object")
+        return false;
+    const assistantMessage = message;
+    if (isRetryableAssistantError(assistantMessage))
+        return true;
+    return typeof assistantMessage.errorMessage === "string"
+        && classifySessionErrorMessage(assistantMessage.errorMessage, { hasProviderContext: true }).retryable === true;
+}
+export function isRetryablePiboProviderError(error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return isRetryablePiboAssistantError({ stopReason: "error", errorMessage });
+}
+export async function waitForPiboProviderRecovery(attempt, settings, signal) {
+    if (signal?.aborted)
+        throw new PiboProviderRecoveryCancelledError();
+    const delayMs = piboProviderRecoveryDelayMs(attempt, settings);
+    if (delayMs <= 0)
+        return;
+    await new Promise((resolve, reject) => {
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(new PiboProviderRecoveryCancelledError());
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, delayMs);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}

package/dist/core/provider-telemetry.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { BestEffortTelemetryService, } from "../data/telemetry.js";
+import { normalizeSessionErrorDetails } from "./session-errors.js";
 export class PiboProviderTelemetryRecorder {
     options;
     telemetry;
@@ -16,6 +17,9 @@ export class PiboProviderTelemetryRecorder {
             if (!turn)
                 return undefined;
             const now = options.at ?? new Date().toISOString();
+            if (this.activeProviderRequest()) {
+                this.finishActiveProviderRequest("aborted", now, "provider request superseded", undefined, "provider_superseded");
+            }
             const model = modelInfo(options.model, this.options.model, payload);
             const providerRequestId = `pr_${randomUUID()}`;
             const phaseId = this.nextPhaseId(turn.turnId, "provider_request");
@@ -83,7 +87,7 @@ export class PiboProviderTelemetryRecorder {
                 lastProgressAt: now,
                 summary: "provider response received",
             });
-            const streamPhaseId = `${request.turnId}:provider_stream:${request.providerRequestId}`;
+            const streamPhaseId = providerStreamPhaseId(request);
             this.telemetry.upsertPhase({
                 phaseId: streamPhaseId,
                 turnId: request.turnId,
@@ -122,6 +126,56 @@ export class PiboProviderTelemetryRecorder {
             return undefined;
         }
     }
+    // The assistant message boundary ends the provider stream even when the wider
+    // Pibo turn continues with a long-running tool or another provider request.
+    recordMessageEnd(message, options = {}) {
+        if (!this.options.store || !isAssistantMessage(message))
+            return undefined;
+        const status = providerStatusForMessage(message);
+        const summary = providerSummaryForStatus(status);
+        const errorMessage = safeMessageError(message);
+        const errorDetails = status === "error"
+            ? normalizeSessionErrorDetails(errorMessage ?? "Provider request failed.", {
+                api: optionalString(message.api),
+                provider: optionalString(message.provider),
+                model: optionalString(message.model),
+            })
+            : undefined;
+        return this.finishActiveProviderRequest(status, options.at ?? new Date().toISOString(), summary, errorMessage, errorDetails?.category ?? errorDetails?.errorClass);
+    }
+    recordShutdown(reason, at = new Date().toISOString()) {
+        return this.finishActiveProviderRequest("aborted", at, reason, undefined, "runtime_abort");
+    }
+    finishActiveProviderRequest(status, now, summary, errorMessage, errorCategory) {
+        if (!this.options.store)
+            return undefined;
+        try {
+            const request = this.activeProviderRequest();
+            if (!request)
+                return undefined;
+            const phaseStatus = status === "completed" ? "ok" : status;
+            const requestPhaseId = request.phaseId ?? `${request.turnId}:provider_request`;
+            if (this.options.store.getPhase(requestPhaseId)?.status === "open") {
+                this.telemetry.finishPhase(requestPhaseId, { status: phaseStatus, endedAt: now, lastProgressAt: now, summary });
+            }
+            const streamPhaseId = providerStreamPhaseId(request);
+            if (this.options.store.getPhase(streamPhaseId)?.status === "open") {
+                this.telemetry.finishPhase(streamPhaseId, { status: phaseStatus, endedAt: now, lastProgressAt: now, summary });
+            }
+            const updated = this.updateProviderRequest(request, {
+                status,
+                completedAt: now,
+                errorCategory: status === "error" ? errorCategory ?? "provider_error" : status === "aborted" ? errorCategory ?? "runtime_abort" : undefined,
+                errorMessage,
+            });
+            this.activeProviderRequestId = undefined;
+            return updated;
+        }
+        catch (error) {
+            this.options.onError?.(error);
+            return undefined;
+        }
+    }
     activeTurn() {
         const detail = this.options.store?.getSessionTelemetry(this.options.session.id, { limit: 10 });
         const active = detail?.activeTurn;
@@ -138,11 +192,10 @@ export class PiboProviderTelemetryRecorder {
         const turn = this.activeTurn();
         if (!turn)
             return undefined;
-        const timeline = this.options.store?.getTurnTimeline(turn.turnId, { limit: 100 });
-        return [...(timeline?.providerRequests ?? [])].reverse().find((request) => !isTerminalProviderStatus(request.status));
+        return this.options.store?.getActiveProviderRequestForTurn(turn.turnId);
     }
     nextPhaseId(turnId, phaseName) {
-        const count = this.options.store?.getTurnTimeline(turnId, { limit: 100 })?.phases.filter((phase) => phase.name === phaseName).length ?? 0;
+        const count = this.options.store?.countPhasesForTurn(turnId, phaseName) ?? 0;
         return count === 0 ? `${turnId}:${phaseName}` : `${turnId}:${phaseName}:${count + 1}`;
     }
     updateProviderRequest(existing, input) {
@@ -162,12 +215,18 @@ export class PiboProviderTelemetryRecorder {
             responseHeadersAt: input.responseHeadersAt,
             firstByteAt: input.firstByteAt,
             httpStatus: input.httpStatus,
+            completedAt: input.completedAt,
             rawEventCount: existing.rawEventCount,
             normalizedEventCount: existing.normalizedEventCount,
             parseErrorCount: existing.parseErrorCount,
             unknownEventCount: existing.unknownEventCount,
             bytesReceived: existing.bytesReceived,
             eventTypeCounts: existing.eventTypeCounts,
+            eventStreamId: existing.eventStreamId,
+            eventId: existing.eventId,
+            payloadRef: existing.payloadRef,
+            errorCategory: input.errorCategory,
+            errorMessage: input.errorMessage,
             captureMode: existing.captureMode,
             retentionClass: existing.retentionClass,
         });
@@ -182,11 +241,45 @@ export function createPiboProviderTelemetryExtension(options) {
         pi.on("after_provider_response", (event) => {
             recorder.recordResponse({ status: event.status, headers: event.headers });
         });
+        pi.on("message_end", (event) => {
+            recorder.recordMessageEnd(event.message);
+        });
+        pi.on("session_shutdown", (event) => {
+            recorder.recordShutdown(`provider session shutdown: ${event.reason}`);
+        });
     };
 }
 export function isTerminalProviderStatus(status) {
     return status === "completed" || status === "error" || status === "aborted" || status === "timeout";
 }
+function isAssistantMessage(message) {
+    return Boolean(message && typeof message === "object" && message.role === "assistant");
+}
+function providerStatusForMessage(message) {
+    if (message.stopReason === "error")
+        return "error";
+    if (message.stopReason === "aborted")
+        return "aborted";
+    return "completed";
+}
+function providerSummaryForStatus(status) {
+    if (status === "error")
+        return "provider stream failed";
+    if (status === "aborted")
+        return "provider stream aborted";
+    return "provider stream completed";
+}
+function providerStreamPhaseId(request) {
+    return `${request.turnId}:provider_stream:${request.providerRequestId}`;
+}
+function safeMessageError(message) {
+    return typeof message.errorMessage === "string" && message.errorMessage.trim().length > 0
+        ? message.errorMessage.replace(/\s+/g, " ").trim().slice(0, 512)
+        : undefined;
+}
+function optionalString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
 function modelInfo(primary, fallback, payload) {
     const payloadModel = modelIdFromPayload(payload);
     return {