@pasko70/pibo 1.8.0 → 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/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/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;

package/dist/core/runtime.js

@@ -166,9 +166,9 @@ function getBuiltinToolAllowlist(profile, customTools) {
         return undefined;
     return [...selectedBuiltinTools, ...customTools.map((tool) => tool.name)];
 }
-function getProfileExtensionFactories(profile, extensionFactories, contextGuardRecovery) {
+function getProfileExtensionFactories(profile, extensionFactories, contextGuardRecovery, getSettingsManager) {
     const piboPromptTemplateExtension = createPiboSystemPromptTemplateExtension();
-    const piboCompactionPromptExtension = createPiboCompactionPromptExtension();
+    const piboCompactionPromptExtension = createPiboCompactionPromptExtension({ getSettingsManager });
     const piboContextGuardExtension = createPiboAssistantContextGuardExtension({}, contextGuardRecovery);
     const providerToolExtensions = profile.tools
         .filter((tool) => tool.enabled !== false)
@@ -241,6 +241,7 @@ export async function createPiboRuntime(options = {}) {
         const mcpAgentContextFile = await getMcpAgentContextFile(profile.mcpServers);
         const skillPaths = getEnabledSkillPaths(runtimeCwd, profile);
         const piPackageOptions = getPiPackageRuntimeOptions(runtimeCwd, profile);
+        let runtimeSettingsManager;
         const services = await createAgentSessionServices({
             cwd: runtimeCwd,
             agentDir: runtimeAgentDir,
@@ -248,7 +249,7 @@ export async function createPiboRuntime(options = {}) {
             resourceLoaderOptions: {
                 ...piPackageOptions.resourceLoaderOptions,
                 additionalSkillPaths: skillPaths,
-                extensionFactories: getProfileExtensionFactories(profile, options.extensionFactories, contextGuardRecovery),
+                extensionFactories: getProfileExtensionFactories(profile, options.extensionFactories, contextGuardRecovery, () => runtimeSettingsManager),
                 noExtensions: true,
                 noSkills: true,
                 noPromptTemplates: true,
@@ -265,6 +266,7 @@ export async function createPiboRuntime(options = {}) {
                 }),
             },
         });
+        runtimeSettingsManager = services.settingsManager;
         applyPiboRuntimeRetryDefaults(services.settingsManager, options.retryDefaults);
         registerOpenAiGpt56Models(services.modelRegistry);
         registerMiniMaxProvider(services.modelRegistry);

package/dist/core/session-errors.js

@@ -10,6 +10,11 @@ const PROVIDER_NETWORK_ERROR_MARKERS = [
     "reset before headers",
     "socket hang up",
     "socket connection was closed",
+    "eai_again",
+    "enotfound",
+    "econnreset",
+    "econnrefused",
+    "etimedout",
 ];
 export function classifySessionErrorMessage(message, options = {}) {
     const normalized = message.toLowerCase();
@@ -20,7 +25,15 @@ export function classifySessionErrorMessage(message, options = {}) {
         return { category: "provider_transport", errorClass: "provider_transport", code: "websocket_error", origin: "provider", retryable: true, userMessage: "The provider WebSocket connection failed." };
     }
     if (normalized.includes("request was aborted") || normalized.includes("aborted")) {
-        return { category: "runtime_abort", errorClass: "runtime_abort", code: "request_aborted", origin: "runtime", retryable: true, userMessage: "The active model request was aborted." };
+        return { category: "runtime_abort", errorClass: "runtime_abort", code: "request_aborted", origin: "runtime", retryable: false, userMessage: "The active model request was aborted." };
+    }
+    if (normalized.includes("insufficient_quota")
+        || normalized.includes("quota exceeded")
+        || normalized.includes("out of budget")
+        || normalized.includes("billing")
+        || normalized.includes("usage limit")
+        || normalized.includes("available balance")) {
+        return { category: "quota_exhausted", errorClass: "provider_rate_limit", code: "quota_exhausted", origin: "provider", retryable: false, userMessage: "The provider quota or billing limit was reached." };
     }
     if (normalized.includes("rate limit") || normalized.includes("429")) {
         return { category: "rate_limit", errorClass: "provider_rate_limit", code: "rate_limited", origin: "provider", retryable: true, userMessage: "The provider rate limit was reached." };

package/dist/core/session-router.js

@@ -319,6 +319,8 @@ export class PiboSessionRouter {
         const eventWithId = { ...event, id: event.id ?? randomUUID() };
         return await new Promise((resolve, reject) => {
             let settled = false;
+            let lastAssistantMessage;
+            let timeout;
             const unsubscribe = this.subscribe((output) => {
                 if (output.piboSessionId !== eventWithId.piboSessionId ||
                     !("eventId" in output) ||
@@ -326,20 +328,21 @@ export class PiboSessionRouter {
                     return;
                 }
                 if (output.type === "assistant_message") {
-                    finish(output);
+                    lastAssistantMessage = output;
+                }
+                else if (output.type === "message_finished") {
+                    finish(lastAssistantMessage ?? new Error(`Pibo session "${eventWithId.piboSessionId}" finished without an assistant reply`));
                 }
                 else if (output.type === "session_error") {
                     finish(new Error(output.error));
                 }
             });
-            const timeout = setTimeout(() => {
-                finish(new Error(`Timed out waiting for assistant reply from Pibo session "${eventWithId.piboSessionId}"`));
-            }, timeoutMs);
             const finish = (result) => {
                 if (settled)
                     return;
                 settled = true;
-                clearTimeout(timeout);
+                if (timeout)
+                    clearTimeout(timeout);
                 unsubscribe();
                 if (result instanceof Error) {
                     reject(result);
@@ -348,6 +351,20 @@ export class PiboSessionRouter {
                     resolve(result);
                 }
             };
+            timeout = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                unsubscribe();
+                const timeoutError = new Error(`Timed out waiting for assistant reply from Pibo session "${eventWithId.piboSessionId}"`);
+                reject(timeoutError);
+                void this.emit({
+                    type: "execution",
+                    piboSessionId: eventWithId.piboSessionId,
+                    action: "abort",
+                    id: randomUUID(),
+                }).catch(() => { });
+            }, timeoutMs);
             this.emit(eventWithId).catch(finish);
         });
     }

package/dist/gateway/request.js

@@ -75,6 +75,7 @@ export async function sendGatewayMessageAndWaitForReply(event, options = {}) {
         let settled = false;
         let response;
         let reply;
+        let messageFinished = false;
         const timeout = setTimeout(() => {
             finish(new Error(`Timed out waiting for assistant reply from session "${event.piboSessionId}"`));
         }, timeoutMs);
@@ -91,14 +92,21 @@ export async function sendGatewayMessageAndWaitForReply(event, options = {}) {
                 resolve(result);
             }
         };
+        const finishCompletedReply = () => {
+            if (!response?.ok || !messageFinished)
+                return;
+            finish(reply
+                ? { response, reply }
+                : new Error(`Session "${eventWithId.piboSessionId}" finished without an assistant reply`));
+        };
         const handleFrame = (frame) => {
             if (frame.type === "res" && frame.id === id) {
                 response = frame;
                 if (!frame.ok) {
                     finish(new Error(frame.error?.message ?? "Gateway rejected the message"));
                 }
-                else if (reply) {
-                    finish({ response, reply });
+                else {
+                    finishCompletedReply();
                 }
                 return;
             }
@@ -111,13 +119,14 @@ export async function sendGatewayMessageAndWaitForReply(event, options = {}) {
                 finish(new Error(output.error));
                 return;
             }
-            if (output.type === "assistant_message" &&
-                output.piboSessionId === eventWithId.piboSessionId &&
-                output.eventId === eventWithId.id) {
+            if (output.piboSessionId !== eventWithId.piboSessionId || !("eventId" in output) || output.eventId !== eventWithId.id)
+                return;
+            if (output.type === "assistant_message") {
                 reply = output;
-                if (response?.ok) {
-                    finish({ response, reply });
-                }
+            }
+            else if (output.type === "message_finished") {
+                messageFinished = true;
+                finishCompletedReply();
             }
         };
         socket.once("connect", () => {

package/dist/ralph/service.js

@@ -252,7 +252,7 @@ export class PiboRalphService {
             },
         });
         this.store.attachRunSession(job.id, run.id, session.id);
-        const finalAnswer = await this.emitMessageAndWait(session.id, buildRalphPrompt(job), { isCancelled: () => this.cancelledRuns.has(run.id) });
+        const finalAnswer = await this.emitMessageAndWait(session.id, buildRalphPrompt(job));
         return { piboSessionId: session.id, finalAnswer };
     }
     resolveTarget(job) { if (job.target.kind === 'room') {
@@ -263,7 +263,7 @@ export class PiboRalphService {
             throw new Error('Target room is archived');
         return { roomId: room.id, workspace: room.workspace ?? getDefaultPiboWorkspace() };
     } const room = this.roomService.ensureDefaultRoom({ name: 'Shared Chat' }); return { roomId: room.id, workspace: room.workspace ?? getDefaultPiboWorkspace() }; }
-    async emitMessageAndWait(piboSessionId, text, options = {}) {
+    async emitMessageAndWait(piboSessionId, text) {
         const eventId = `ralph_msg_${randomUUID()}`;
         return await new Promise((resolve, reject) => {
             let settled = false;
@@ -308,9 +308,7 @@ export class PiboRalphService {
                     finish(lastSessionError ? new Error(lastSessionError) : undefined);
                 if (event.type === 'session_error') {
                     lastSessionError = event.error;
-                    const providerAttempt = event.errorDetails?.origin === 'provider' && Boolean(event.errorDetails.api || event.errorDetails.provider || event.errorDetails.model);
-                    if (!providerAttempt || options.isCancelled?.())
-                        finish(new Error(event.error));
+                    finish(new Error(event.error));
                 }
             });
             this.options.context.emit({ type: 'message', piboSessionId, id: eventId, source: 'service', text }).catch((error) => finish(error instanceof Error ? error : new Error(String(error))));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "type": "module",
   "imports": {
     "vscode": "./src/apps/chat-vscode/extension/src/vscode-shim.js"