@averyyy/pi-coding-agent 0.84.3-piclient.1 → 0.84.4-piclient.2

package/dist/core/agent-session.js

@@ -102,6 +102,16 @@ function getPiServerFailurePhase(message) {
     }
     return undefined;
 }
+function getPiServerFailureRetryable(message) {
+    for (const diagnostic of message.diagnostics ?? []) {
+        if (diagnostic.type !== "pi_server_failure")
+            continue;
+        const retryable = diagnostic.details?.retryable;
+        if (typeof retryable === "boolean")
+            return retryable;
+    }
+    return undefined;
+}
 function toolTextContent(content) {
     return content
         .filter((part) => part.type === "text")
@@ -170,6 +180,8 @@ export class AgentSession {
     _followUpMessages = [];
     /** Messages queued to be included with the next user prompt as context ("asides"). */
     _pendingNextTurnMessages = [];
+    /** Context-only custom messages queued during a run, flushed once the current turn's tool results are in. */
+    _pendingCustomMessages = [];
     // Compaction state
     _compactionAbortController = undefined;
     _autoCompactionAbortController = undefined;
@@ -472,6 +484,11 @@ export class AgentSession {
             followUp: [...this._followUpMessages],
         });
     }
+    async _emitSessionCompactFailed(event) {
+        if (this._extensionRunner.hasHandlers("session_compact_failed")) {
+            await this._extensionRunner.emit({ type: "session_compact_failed", ...event });
+        }
+    }
     _getIdleWaitPromise() {
         if (!this._idleWaitPromise) {
             this._idleWaitPromise = new Promise((resolve) => {
@@ -562,6 +579,14 @@ export class AgentSession {
                 }
             }
         }
+        // A turn ends after its assistant message and every tool result has been appended,
+        // so this is the first point in the run where a context-only custom message can be
+        // inserted without landing between a tool call and its result. Flushing after the
+        // extension and listener dispatch above also picks up messages that turn_end
+        // handlers queued.
+        if (event.type === "turn_end") {
+            this._flushPendingCustomMessages();
+        }
     };
     _willRetryAfterAgentEnd(event) {
         const settings = this.settingsManager.getRetrySettings();
@@ -990,6 +1015,7 @@ export class AgentSession {
         finally {
             this._systemPromptOverride = undefined;
             this._flushPendingBashMessages();
+            this._flushPendingCustomMessages();
             await this._emitAgentSettled();
         }
     }
@@ -1148,8 +1174,9 @@ export class AgentSession {
                 preflightResult?.(true);
                 return;
             }
-            // Flush any pending bash messages before the new prompt
+            // Flush any pending bash and custom messages before the new prompt
             this._flushPendingBashMessages();
+            this._flushPendingCustomMessages();
             // Validate model
             if (!this.model) {
                 throw new Error(formatNoModelSelectedMessage());
@@ -1366,8 +1393,9 @@ export class AgentSession {
     /**
      * Send a custom message to the session. Creates a CustomMessageEntry.
      *
-     * Handles three cases:
+     * Handles four cases:
      * - Streaming: queues message, processed when loop pulls from queue
+     * - Streaming + triggerTurn false: appended to state/session once the current turn ends
      * - Not streaming + triggerTurn: appends to state/session, starts new turn
      * - Not streaming + no trigger: appends to state/session, no turn
      *
@@ -1399,11 +1427,34 @@ export class AgentSession {
         else if (options?.triggerTurn) {
             await this._runAgentPrompt(appMessage);
         }
+        else if (this.isStreaming) {
+            // Appending now would put the message between an assistant tool call and its
+            // result, which providers that validate message order reject on replay. Defer
+            // to the end of the turn. Nothing is emitted yet: message events must not
+            // describe messages the session tree does not contain.
+            this._pendingCustomMessages.push(appMessage);
+        }
         else {
-            this.agent.state.messages.push(appMessage);
-            this.sessionManager.appendCustomMessageEntry(message.customType, message.content, message.display, message.details);
-            this._emit({ type: "message_start", message: appMessage });
-            this._emit({ type: "message_end", message: appMessage });
+            this._appendCustomMessage(appMessage);
+        }
+    }
+    _appendCustomMessage(appMessage) {
+        this.agent.state.messages.push(appMessage);
+        this.sessionManager.appendCustomMessageEntry(appMessage.customType, appMessage.content, appMessage.display, appMessage.details);
+        this._emit({ type: "message_start", message: appMessage });
+        this._emit({ type: "message_end", message: appMessage });
+    }
+    /**
+     * Append custom messages queued while the agent was running.
+     * Called once the current turn's tool results are in agent state and session history.
+     */
+    _flushPendingCustomMessages() {
+        if (this._pendingCustomMessages.length === 0)
+            return;
+        const pending = this._pendingCustomMessages;
+        this._pendingCustomMessages = [];
+        for (const appMessage of pending) {
+            this._appendCustomMessage(appMessage);
         }
     }
     /**
@@ -1518,6 +1569,7 @@ export class AgentSession {
         this.sessionManager.appendModelChange(model.provider, model.id);
         if (options.persist) {
             this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
+            this._addPersistedDefaultToNonEmptyScope(model);
         }
         // Apply thinking level for the new model.
         // Per-model thinking level overrides take priority over the global default.
@@ -1525,6 +1577,20 @@ export class AgentSession {
         this.setThinkingLevel(thinkingLevel);
         await this._emitModelSelect(model, previousModel, "set");
     }
+    _addPersistedDefaultToNonEmptyScope(model) {
+        if (this._scopedModels.length === 0)
+            return;
+        if (this._scopedModels.some((scoped) => modelsAreEqual(scoped.model, model)))
+            return;
+        this._scopedModels = [...this._scopedModels, { model }];
+        const enabledModels = this.settingsManager.getEnabledModels();
+        if (!enabledModels?.length)
+            return;
+        const modelReference = `${model.provider}/${model.id}`;
+        if (enabledModels.some((pattern) => pattern.toLowerCase() === modelReference.toLowerCase()))
+            return;
+        this.settingsManager.setEnabledModels([...enabledModels, modelReference]);
+    }
     /**
      * Cycle to next/previous model.
      * Uses scoped models (from --models flag) if available, otherwise all available models.
@@ -1555,6 +1621,7 @@ export class AgentSession {
         this.sessionManager.appendModelChange(next.model.provider, next.model.id);
         if (options.persist) {
             this.settingsManager.setDefaultModelAndProvider(next.model.provider, next.model.id);
+            this._addPersistedDefaultToNonEmptyScope(next.model);
         }
         // Apply thinking level for the new model.
         // - Explicit scoped model thinking level overrides defaults
@@ -1581,6 +1648,7 @@ export class AgentSession {
         this.sessionManager.appendModelChange(nextModel.provider, nextModel.id);
         if (options.persist) {
             this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id);
+            this._addPersistedDefaultToNonEmptyScope(nextModel);
         }
         // Apply thinking level for the new model.
         // Model persistence does not implicitly rewrite the global thinking default.
@@ -1920,20 +1988,24 @@ export class AgentSession {
         // independent of the configured context size or any context-clamped provider request limit.
         // A successful response over the configured window should compact but must not retry: the
         // assistant answer already completed and agent.continue() cannot continue from an assistant.
+        const contextOverflow = sameModel && isContextOverflow(assistantMessage, contextWindow);
         const recoverableLength = sameModel && isRecoverableLength(assistantMessage, this.model?.maxTokens ?? 0);
-        if (sameModel && (isContextOverflow(assistantMessage, contextWindow) || recoverableLength)) {
+        if (contextOverflow || recoverableLength) {
             const willRetry = assistantMessage.stopReason !== "stop";
             if (!willRetry) {
                 return await this._runAutoCompaction("overflow", false);
             }
             if (this._overflowRecoveryAttempted) {
+                const errorMessage = contextOverflow
+                    ? "Context overflow recovery failed after one compact-and-retry attempt. Try reducing context or switching to a larger-context model."
+                    : "Truncated response recovery failed after one compact-and-retry attempt.";
                 this._emit({
                     type: "compaction_end",
                     reason: "overflow",
                     result: undefined,
                     aborted: false,
                     willRetry: false,
-                    errorMessage: "Context overflow recovery failed after one compact-and-retry attempt. Try reducing context or switching to a larger-context model.",
+                    errorMessage,
                 });
                 return false;
             }
@@ -1963,16 +2035,16 @@ export class AgentSession {
         if (assistantMessage.stopReason === "error" || directContextTokens === 0) {
             const messages = this.agent.state.messages;
             const estimate = estimateContextTokens(messages);
-            if (estimate.lastUsageIndex === null)
-                return false; // No usage data at all
-            // Verify the usage source is post-compaction. Kept pre-compaction messages
-            // have stale usage reflecting the old (larger) context and would falsely
-            // trigger compaction right after one just finished.
-            const usageMsg = messages[estimate.lastUsageIndex];
-            if (compactionTimestamp > 0 &&
-                usageMsg.role === "assistant" &&
-                usageMsg.timestamp <= compactionTimestamp) {
-                return false;
+            // When a valid usage entry exists, verify it is post-compaction. Kept
+            // pre-compaction messages have stale usage reflecting the old (larger)
+            // context and would falsely trigger compaction right after one finished.
+            if (estimate.lastUsageIndex !== null) {
+                const usageMsg = messages[estimate.lastUsageIndex];
+                if (compactionTimestamp > 0 &&
+                    usageMsg.role === "assistant" &&
+                    usageMsg.timestamp <= compactionTimestamp) {
+                    return false;
+                }
             }
             contextTokens = estimate.tokens;
         }
@@ -1990,6 +2062,7 @@ export class AgentSession {
     async _runAutoCompaction(reason, willRetry, preparationOverride, preparationOptions) {
         const settings = this.settingsManager.getCompactionSettings();
         let started = false;
+        let fromExtension = false;
         try {
             if (!this.model) {
                 return false;
@@ -2029,7 +2102,6 @@ export class AgentSession {
             this._autoCompactionAbortController = new AbortController();
             started = true;
             let extensionCompaction;
-            let fromExtension = false;
             if (this._extensionRunner.hasHandlers("session_before_compact")) {
                 const extensionResult = (await this._extensionRunner.emit({
                     type: "session_before_compact",
@@ -2048,6 +2120,12 @@ export class AgentSession {
                         aborted: true,
                         willRetry: false,
                     });
+                    await this._emitSessionCompactFailed({
+                        reason,
+                        aborted: true,
+                        willRetry: false,
+                        fromExtension: false,
+                    });
                     return false;
                 }
                 if (extensionResult?.compaction) {
@@ -2085,6 +2163,12 @@ export class AgentSession {
                     aborted: true,
                     willRetry: false,
                 });
+                await this._emitSessionCompactFailed({
+                    reason,
+                    aborted: true,
+                    willRetry: false,
+                    fromExtension,
+                });
                 return false;
             }
             this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension, usage);
@@ -2141,6 +2225,15 @@ export class AgentSession {
                         ? `Context overflow recovery failed: ${errorMessage}`
                         : `Auto-compaction failed: ${errorMessage}`,
                 });
+                await this._emitSessionCompactFailed({
+                    reason,
+                    errorMessage: reason === "overflow"
+                        ? `Context overflow recovery failed: ${errorMessage}`
+                        : `Auto-compaction failed: ${errorMessage}`,
+                    aborted: false,
+                    willRetry: false,
+                    fromExtension,
+                });
             }
             return false;
         }
@@ -2554,6 +2647,9 @@ export class AgentSession {
      * Check if an error is retryable. Provider error text is retryable by default,
      * except usage/quota/balance limits and session or context failures.
      * Context overflow errors are NOT retryable (handled by compaction instead).
+     * Pi-server diagnostics may mark recovery/history failures as non-retryable;
+     * transient session_init/tree_sync outages stay retryable so the next attempt
+     * re-runs the whole stream path.
      */
     _isRetryableError(message) {
         // Context overflow is handled by compaction, not retry.
@@ -2561,9 +2657,14 @@ export class AgentSession {
             return false;
         if (this._isPostAssistantPiServerSyncFailure(message))
             return false;
-        const piServerPhase = getPiServerFailurePhase(message);
-        if (piServerPhase && piServerPhase !== "provider_stream")
+        const piServerRetryable = getPiServerFailureRetryable(message);
+        if (piServerRetryable === false)
             return false;
+        if (piServerRetryable !== true) {
+            const piServerPhase = getPiServerFailurePhase(message);
+            if (piServerPhase && piServerPhase !== "provider_stream")
+                return false;
+        }
         return isRetryableAssistantError(message);
     }
     /**