@pasko70/pibo 1.8.0 → 1.8.2

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/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

@@ -10,6 +10,10 @@ export class PiboProviderTelemetryRecorder {
         this.telemetry = new BestEffortTelemetryService(options.store, options.onError);
     }
     recordRequestStart(payload, options = {}) {
+        const capturedOptions = { ...options, at: options.at ?? new Date().toISOString() };
+        return this.schedule(() => this.recordRequestStartNow(providerPayloadSnapshot(payload), capturedOptions));
+    }
+    recordRequestStartNow(payload, options) {
         if (!this.options.store)
             return undefined;
         try {
@@ -74,6 +78,10 @@ export class PiboProviderTelemetryRecorder {
         }
     }
     recordResponse(input) {
+        const captured = { status: input.status, at: input.at ?? new Date().toISOString() };
+        return this.schedule(() => this.recordResponseNow(captured));
+    }
+    recordResponseNow(input) {
         if (!this.options.store)
             return undefined;
         try {
@@ -129,7 +137,14 @@ export class PiboProviderTelemetryRecorder {
     // 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))
+        if (!isAssistantMessage(message))
+            return undefined;
+        const captured = providerAssistantMessageSnapshot(message);
+        const capturedOptions = { ...options, at: options.at ?? new Date().toISOString() };
+        return this.schedule(() => this.recordMessageEndNow(captured, capturedOptions));
+    }
+    recordMessageEndNow(message, options) {
+        if (!this.options.store)
             return undefined;
         const status = providerStatusForMessage(message);
         const summary = providerSummaryForStatus(status);
@@ -144,7 +159,14 @@ export class PiboProviderTelemetryRecorder {
         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");
+        return this.schedule(() => this.finishActiveProviderRequest("aborted", at, reason, undefined, "runtime_abort"));
+    }
+    schedule(write) {
+        if (this.options.writer) {
+            this.options.writer.enqueue(write, this.options.onError);
+            return undefined;
+        }
+        return write();
     }
     finishActiveProviderRequest(status, now, summary, errorMessage, errorCategory) {
         if (!this.options.store)
@@ -301,6 +323,22 @@ function modelFromContext(ctx) {
     const api = typeof candidate.api === "string" && candidate.api.length > 0 ? candidate.api : undefined;
     return provider && id ? { provider, id, api } : undefined;
 }
+function providerAssistantMessageSnapshot(message) {
+    return {
+        role: message.role,
+        stopReason: message.stopReason,
+        errorMessage: message.errorMessage,
+        api: message.api,
+        provider: message.provider,
+        model: message.model,
+    };
+}
+function providerPayloadSnapshot(payload) {
+    return {
+        model: modelIdFromPayload(payload),
+        service_tier: serviceTierFromPayload(payload),
+    };
+}
 function modelIdFromPayload(payload) {
     if (!payload || typeof payload !== "object" || Array.isArray(payload))
         return undefined;

package/dist/core/routed-session.js

@@ -3,6 +3,7 @@ import { getOpenAiCodexProviderUsageForActiveModel } from "../auth/openai-codex-
 import { normalizeSessionErrorDetails, runtimeSessionErrorDetails } from "./session-errors.js";
 import { expandInlineSkills } from "./skill-expansion.js";
 import { PIBO_CONTEXT_GUARD_RESUME_MESSAGE_TYPE, PIBO_CONTEXT_GUARD_RESUME_PROMPT, cancelPiboAssistantContextGuardRecovery, claimPiboAssistantContextGuardRecovery, waitForPiboAssistantContextGuardRecovery, } from "./context-guard.js";
+import { PIBO_PROVIDER_RECOVERY_MESSAGE_TYPE, PIBO_PROVIDER_RECOVERY_PROMPT, PiboProviderRecoveryCancelledError, isRetryablePiboAssistantError, isRetryablePiboProviderError, resolvePiboProviderRecoverySettings, waitForPiboProviderRecovery, } from "./provider-recovery.js";
 const FAST_SERVICE_TIER = "priority";
 function modelSupportsFastServiceTier(model) {
     if (!model)
@@ -404,7 +405,10 @@ export class RoutedSession {
     activeThinkingIndex;
     nextThinkingIndex = 0;
     pendingAssistantError;
+    pendingAssistantErrorRetryable = false;
     activeMessageFailed = false;
+    providerRecoveryCancelled = false;
+    providerRecoveryAbortController;
     unsubscribe;
     recoverySession;
     isContinuePatched = false;
@@ -496,6 +500,7 @@ export class RoutedSession {
         this.unsubscribe?.();
         const session = this.runtime.session;
         if (this.recoverySession && this.recoverySession !== session) {
+            this.cancelProviderRecovery();
             cancelPiboAssistantContextGuardRecovery(this.recoverySession, new Error("Context guard recovery cancelled because the Pi session changed"));
         }
         this.recoverySession = session;
@@ -506,19 +511,20 @@ export class RoutedSession {
             const normalized = normalizePiEvent(this.piboSessionId, event, { contextWindow: numberValue(model?.contextWindow) });
             const candidate = event && typeof event === "object" ? event : undefined;
             const assistantMessageEnded = candidate?.type === "message_end" && isAssistantMessage(candidate.message);
-            // Pi may recover an assistant error through retry or compaction. Publish it only
-            // after agent_settled confirms that no automatic continuation remains.
+            // Pi gets the first chance to recover through its short retry/compaction loop.
+            // Keep the final error pending so the routed turn can continue durable recovery.
             if (assistantMessageEnded && normalized?.type === "session_error") {
                 this.pendingAssistantError = this.withActiveMessage(normalized);
+                this.pendingAssistantErrorRetryable = isRetryablePiboAssistantError(candidate.message);
             }
             else {
-                if (assistantMessageEnded)
+                if (assistantMessageEnded) {
                     this.pendingAssistantError = undefined;
+                    this.pendingAssistantErrorRetryable = false;
+                }
                 if (normalized)
                     this.emit(this.withActiveMessage(normalized));
             }
-            if (candidate?.type === "agent_settled")
-                this.flushPendingAssistantError();
             if (this.forwardPiEvents) {
                 this.emit({ type: "pi_event", piboSessionId: this.piboSessionId, event });
             }
@@ -531,6 +537,80 @@ export class RoutedSession {
         this.activeMessageFailed = true;
         this.emit(this.pendingAssistantError);
         this.pendingAssistantError = undefined;
+        this.pendingAssistantErrorRetryable = false;
+    }
+    cancelProviderRecovery() {
+        this.providerRecoveryCancelled = true;
+        this.providerRecoveryAbortController?.abort();
+        this.providerRecoveryAbortController = undefined;
+    }
+    async resumeContextGuardRecovery(session) {
+        while (await waitForPiboAssistantContextGuardRecovery(session)) {
+            try {
+                await session.sendCustomMessage({
+                    customType: PIBO_CONTEXT_GUARD_RESUME_MESSAGE_TYPE,
+                    content: [{ type: "text", text: PIBO_CONTEXT_GUARD_RESUME_PROMPT }],
+                    display: false,
+                }, { triggerTurn: true });
+            }
+            catch (error) {
+                const resumeError = error instanceof Error ? error : new Error(String(error));
+                cancelPiboAssistantContextGuardRecovery(session, resumeError);
+                throw resumeError;
+            }
+        }
+    }
+    async recoverTransientProviderErrors(session) {
+        let attempt = 0;
+        while (this.pendingAssistantError && this.pendingAssistantErrorRetryable) {
+            if (this.providerRecoveryCancelled)
+                throw new PiboProviderRecoveryCancelledError();
+            const settings = resolvePiboProviderRecoverySettings(session.settingsManager);
+            if (!settings.enabled)
+                return;
+            attempt += 1;
+            this.pendingAssistantError = undefined;
+            this.pendingAssistantErrorRetryable = false;
+            const controller = new AbortController();
+            this.providerRecoveryAbortController = controller;
+            try {
+                await waitForPiboProviderRecovery(attempt, settings, controller.signal);
+            }
+            finally {
+                if (this.providerRecoveryAbortController === controller) {
+                    this.providerRecoveryAbortController = undefined;
+                }
+            }
+            if (this.providerRecoveryCancelled || this.disposed || this.runtime.session !== session || !this.activeMessage) {
+                throw new PiboProviderRecoveryCancelledError();
+            }
+            try {
+                await session.sendCustomMessage({
+                    customType: PIBO_PROVIDER_RECOVERY_MESSAGE_TYPE,
+                    content: [{ type: "text", text: PIBO_PROVIDER_RECOVERY_PROMPT }],
+                    display: false,
+                    details: { attempt },
+                }, { triggerTurn: true });
+                await this.resumeContextGuardRecovery(session);
+                if (this.providerRecoveryCancelled)
+                    throw new PiboProviderRecoveryCancelledError();
+            }
+            catch (error) {
+                if (error instanceof PiboProviderRecoveryCancelledError)
+                    throw error;
+                if (!isRetryablePiboProviderError(error))
+                    throw error;
+                const message = errorMessage(error);
+                this.pendingAssistantError = {
+                    type: "session_error",
+                    piboSessionId: this.piboSessionId,
+                    eventId: this.activeMessage.id,
+                    error: message,
+                    errorDetails: runtimeSessionErrorDetails(message),
+                };
+                this.pendingAssistantErrorRetryable = true;
+            }
+        }
     }
     handleCompactionEvent(event) {
         if (!event || typeof event !== "object")
@@ -770,6 +850,7 @@ export class RoutedSession {
         if (this.disposed)
             return;
         this.notifyMessagesInterrupted(this.activeAndQueuedMessages(), "session disposed");
+        this.cancelProviderRecovery();
         this.queue.length = 0;
         this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: true });
         this.unsubscribe?.();
@@ -783,6 +864,7 @@ export class RoutedSession {
     }
     async kill() {
         this.notifyMessagesInterrupted(this.activeAndQueuedMessages(), "session killed");
+        this.cancelProviderRecovery();
         this.queue.length = 0;
         this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: this.disposed });
         this.cancelContextGuardRecovery("Context guard recovery cancelled because the routed session was killed");
@@ -801,6 +883,7 @@ export class RoutedSession {
         }
         if (this.activeMessage?.id === eventId) {
             this.notifyMessagesInterrupted([this.activeMessage], "message cancelled");
+            this.cancelProviderRecovery();
             this.cancelContextGuardRecovery("Context guard recovery cancelled with the active message");
             await this.runtime.session.abort();
             return true;
@@ -839,7 +922,9 @@ export class RoutedSession {
         });
         try {
             this.activeMessage = event;
+            this.providerRecoveryCancelled = false;
             this.pendingAssistantError = undefined;
+            this.pendingAssistantErrorRetryable = false;
             this.activeMessageFailed = false;
             this.activeAssistantIndex = undefined;
             this.nextAssistantIndex = 0;
@@ -848,20 +933,9 @@ export class RoutedSession {
             const session = this.runtime.session;
             const expandedText = expandInlineSkills(event.text, session.resourceLoader.getSkills().skills);
             await session.prompt(expandedText, { source: promptSource(event.source) });
-            while (await waitForPiboAssistantContextGuardRecovery(session)) {
-                try {
-                    await session.sendCustomMessage({
-                        customType: PIBO_CONTEXT_GUARD_RESUME_MESSAGE_TYPE,
-                        content: [{ type: "text", text: PIBO_CONTEXT_GUARD_RESUME_PROMPT }],
-                        display: false,
-                    }, { triggerTurn: true });
-                }
-                catch (error) {
-                    const resumeError = error instanceof Error ? error : new Error(String(error));
-                    cancelPiboAssistantContextGuardRecovery(session, resumeError);
-                    throw resumeError;
-                }
-            }
+            await this.resumeContextGuardRecovery(session);
+            await this.recoverTransientProviderErrors(session);
+            this.flushPendingAssistantError();
             if (!this.activeMessageFailed) {
                 this.emit({
                     type: "message_finished",
@@ -872,6 +946,8 @@ export class RoutedSession {
             }
         }
         catch (error) {
+            if (error instanceof PiboProviderRecoveryCancelledError)
+                return;
             const message = errorMessage(error);
             this.emit({
                 type: "session_error",
@@ -883,7 +959,9 @@ export class RoutedSession {
         }
         finally {
             this.activeMessage = undefined;
+            this.providerRecoveryCancelled = false;
             this.pendingAssistantError = undefined;
+            this.pendingAssistantErrorRetryable = false;
             this.activeMessageFailed = false;
             this.activeAssistantIndex = undefined;
             this.nextAssistantIndex = 0;