@mariozechner/pi-coding-agent 0.56.1 → 0.56.3

package/dist/core/agent-session.js

@@ -1013,11 +1013,12 @@ export class AgentSession {
             throw new Error(`No API key for ${model.provider}/${model.id}`);
         }
         const previousModel = this.model;
+        const thinkingLevel = this._getThinkingLevelForModelSwitch();
         this.agent.setModel(model);
         this.sessionManager.appendModelChange(model.provider, model.id);
         this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
         // Re-clamp thinking level for new model's capabilities
-        this.setThinkingLevel(this.thinkingLevel);
+        this.setThinkingLevel(thinkingLevel);
         await this._emitModelSelect(model, previousModel, "set");
     }
     /**
@@ -1062,15 +1063,16 @@ export class AgentSession {
         const len = scopedModels.length;
         const nextIndex = direction === "forward" ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len;
         const next = scopedModels[nextIndex];
+        const thinkingLevel = this._getThinkingLevelForModelSwitch(next.thinkingLevel);
         // Apply model
         this.agent.setModel(next.model);
         this.sessionManager.appendModelChange(next.model.provider, next.model.id);
         this.settingsManager.setDefaultModelAndProvider(next.model.provider, next.model.id);
         // Apply thinking level.
         // - Explicit scoped model thinking level overrides current session level
-        // - Undefined scoped model thinking level inherits current session level
+        // - Undefined scoped model thinking level inherits the current session preference
         // setThinkingLevel clamps to model capabilities.
-        this.setThinkingLevel(next.thinkingLevel ?? this.thinkingLevel);
+        this.setThinkingLevel(thinkingLevel);
         await this._emitModelSelect(next.model, currentModel, "cycle");
         return { model: next.model, thinkingLevel: this.thinkingLevel, isScoped: true };
     }
@@ -1089,11 +1091,12 @@ export class AgentSession {
         if (!apiKey) {
             throw new Error(`No API key for ${nextModel.provider}/${nextModel.id}`);
         }
+        const thinkingLevel = this._getThinkingLevelForModelSwitch();
         this.agent.setModel(nextModel);
         this.sessionManager.appendModelChange(nextModel.provider, nextModel.id);
         this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id);
         // Re-clamp thinking level for new model's capabilities
-        this.setThinkingLevel(this.thinkingLevel);
+        this.setThinkingLevel(thinkingLevel);
         await this._emitModelSelect(nextModel, currentModel, "cycle");
         return { model: nextModel, thinkingLevel: this.thinkingLevel, isScoped: false };
     }
@@ -1113,7 +1116,9 @@ export class AgentSession {
         this.agent.setThinkingLevel(effectiveLevel);
         if (isChanging) {
             this.sessionManager.appendThinkingLevelChange(effectiveLevel);
-            this.settingsManager.setDefaultThinkingLevel(effectiveLevel);
+            if (this.supportsThinking() || effectiveLevel !== "off") {
+                this.settingsManager.setDefaultThinkingLevel(effectiveLevel);
+            }
         }
     }
     /**
@@ -1151,6 +1156,15 @@ export class AgentSession {
     supportsThinking() {
         return !!this.model?.reasoning;
     }
+    _getThinkingLevelForModelSwitch(explicitLevel) {
+        if (explicitLevel !== undefined) {
+            return explicitLevel;
+        }
+        if (!this.supportsThinking()) {
+            return this.settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
+        }
+        return this.thinkingLevel;
+    }
     _clampThinkingLevel(level, availableLevels) {
         const ordered = THINKING_LEVELS_WITH_XHIGH;
         const available = new Set(availableLevels);
@@ -1322,15 +1336,16 @@ export class AgentSession {
         // to a larger-context model (e.g. codex) - the overflow error from the old model
         // shouldn't trigger compaction for the new model.
         const sameModel = this.model && assistantMessage.provider === this.model.provider && assistantMessage.model === this.model.id;
-        // Skip overflow check if the error is from before a compaction in the current path.
-        // This handles the case where an error was kept after compaction (in the "kept" region).
-        // The error shouldn't trigger another compaction since we already compacted.
-        // Example: opus fails → switch to codex → compact → switch back to opus → opus error
-        // is still in context but shouldn't trigger compaction again.
+        // Skip compaction checks if this assistant message is older than the latest
+        // compaction boundary. This prevents a stale pre-compaction usage/error
+        // from retriggering compaction on the first prompt after compaction.
         const compactionEntry = getLatestCompactionEntry(this.sessionManager.getBranch());
-        const errorIsFromBeforeCompaction = compactionEntry !== null && assistantMessage.timestamp < new Date(compactionEntry.timestamp).getTime();
+        const assistantIsFromBeforeCompaction = compactionEntry !== null && assistantMessage.timestamp <= new Date(compactionEntry.timestamp).getTime();
+        if (assistantIsFromBeforeCompaction) {
+            return;
+        }
         // Case 1: Overflow - LLM returned context overflow error
-        if (sameModel && !errorIsFromBeforeCompaction && isContextOverflow(assistantMessage, contextWindow)) {
+        if (sameModel && isContextOverflow(assistantMessage, contextWindow)) {
             if (this._overflowRecoveryAttempted) {
                 this._emit({
                     type: "auto_compaction_end",
@@ -1351,11 +1366,29 @@ export class AgentSession {
             await this._runAutoCompaction("overflow", true);
             return;
         }
-        // Case 2: Threshold - turn succeeded but context is getting large
-        // Skip if this was an error (non-overflow errors don't have usage data)
-        if (assistantMessage.stopReason === "error")
-            return;
-        const contextTokens = calculateContextTokens(assistantMessage.usage);
+        // Case 2: Threshold - context is getting large
+        // For error messages (no usage data), estimate from last successful response.
+        // This ensures sessions that hit persistent API errors (e.g. 529) can still compact.
+        let contextTokens;
+        if (assistantMessage.stopReason === "error") {
+            const messages = this.agent.state.messages;
+            const estimate = estimateContextTokens(messages);
+            if (estimate.lastUsageIndex === null)
+                return; // 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 (compactionEntry &&
+                usageMsg.role === "assistant" &&
+                usageMsg.timestamp <= new Date(compactionEntry.timestamp).getTime()) {
+                return;
+            }
+            contextTokens = estimate.tokens;
+        }
+        else {
+            contextTokens = calculateContextTokens(assistantMessage.usage);
+        }
         if (shouldCompact(contextTokens, contextWindow, settings)) {
             await this._runAutoCompaction("threshold", false);
         }