open-multi-agent-kit 0.92.0 → 0.93.0

package/dist/core/agent-session.js

@@ -286,6 +286,9 @@ export class AgentSession {
     // Retry state
     _retryAbortController = undefined;
     _retryAttempt = 0;
+    // v10.3-Ω: models that already refused/failed this turn — failover must advance,
+    // not re-pick the same candidate (claude-opus-5 → grok → grok → grok loop fix).
+    _refusedModels = new Set();
     // Bash execution state
     _bashAbortController = undefined;
     _pendingBashMessages = [];
@@ -927,6 +930,7 @@ export class AgentSession {
                         attempt: this._retryAttempt,
                     });
                     this._retryAttempt = 0;
+                    this._refusedModels.clear();
                 }
             }
         }
@@ -1463,6 +1467,7 @@ export class AgentSession {
                 finalError: msg.errorMessage,
             });
             this._retryAttempt = 0;
+            this._refusedModels.clear();
         }
         if (await this._checkCompaction(msg)) {
             return true;
@@ -2743,7 +2748,7 @@ export class AgentSession {
             }
             else {
                 // Generate compaction result
-                const result = await compact(preparation, compactionModel, apiKey, headers, customInstructions, this._compactionAbortController.signal, this.thinkingLevel, this.agent.streamFn);
+                const result = await compact(preparation, compactionModel, apiKey, headers, customInstructions, this._compactionAbortController.signal, this.thinkingLevel, this.agent.streamFn, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason: "manual" }));
                 summary = result.summary;
                 firstKeptEntryId = result.firstKeptEntryId;
                 tokensBefore = result.tokensBefore;
@@ -3019,7 +3024,7 @@ export class AgentSession {
             }
             else {
                 // Generate compaction result
-                const compactResult = await compact(preparation, compactionModel, apiKey, headers, undefined, this._autoCompactionAbortController.signal, this.thinkingLevel, this.agent.streamFn);
+                const compactResult = await compact(preparation, compactionModel, apiKey, headers, undefined, this._autoCompactionAbortController.signal, this.thinkingLevel, this.agent.streamFn, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason }));
                 summary = compactResult.summary;
                 firstKeptEntryId = compactResult.firstKeptEntryId;
                 tokensBefore = compactResult.tokensBefore;
@@ -3050,7 +3055,21 @@ export class AgentSession {
                     fromExtension,
                 });
             }
-            const emitWillRetry = compactionEmitWillRetry(willRetry, this.agent.hasQueuedMessages());
+            // Whether the agent loop will resume after this compaction. Shared by
+            // the compaction_end event (so the TUI flushes its queued messages
+            // correctly) and the return value below.
+            const resumeMessages = this.agent.state.messages;
+            let lastAssistantMsg;
+            for (let i = resumeMessages.length - 1; i >= 0; i--) {
+                const candidate = resumeMessages[i];
+                if (candidate.role === "assistant") {
+                    lastAssistantMsg = candidate;
+                    break;
+                }
+            }
+            const endedCleanly = lastAssistantMsg?.stopReason === "stop";
+            const willResume = this.agent.hasQueuedMessages() || !endedCleanly;
+            const emitWillRetry = compactionEmitWillRetry(willRetry, willResume);
             this._emit({ type: "compaction_end", reason, result, aborted: false, willRetry: emitWillRetry });
             if (willRetry) {
                 const messages = this.agent.state.messages;
@@ -3060,9 +3079,16 @@ export class AgentSession {
                 }
                 return true;
             }
-            // Auto-compaction can complete while follow-up/steering/custom messages are waiting.
-            // Continue once so queued messages are delivered.
-            return this.agent.hasQueuedMessages();
+            // Resume the agent loop after a successful auto-compaction unless the
+            // agent had already finished cleanly. Previously this returned
+            // `hasQueuedMessages()`, which made the agent stall right after the
+            // purple "Auto-compacting..." indicator whenever no steer/follow-up
+            // messages were queued — even when the last turn was cut off mid-task
+            // (stopReason toolUse/length/error/aborted). Continue in that case so
+            // the task runs to completion on the compacted context. Hysteresis
+            // (disarmed until context drops below rearmRatio) prevents an immediate
+            // re-trigger; a clean "stop" with nothing queued still ends the loop.
+            return willResume;
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : "compaction failed";
@@ -3476,6 +3502,34 @@ export class AgentSession {
         // Shared contract with provider-resilience.ts (Fable safety stop, K3 orphan tool_call_id, terminated).
         return isTransientProviderErrorMessage(err);
     }
+    /**
+     * Retry policy + callbacks shared by compaction and branch-summary summarization calls.
+     * Uses the same `settings.retry` budget/backoff as agent-turn retries so a single transient
+     * stream drop no longer fails the whole operation. `source` carries the context
+     * the TUI needs to render the retry and recreate the underlying indicator.
+     */
+    _summarizationRetryCallbacks(source) {
+        return {
+            onRetryScheduled: (attempt, maxAttempts, delayMs, errorMessage) => {
+                this._emit({
+                    type: "summarization_retry_scheduled",
+                    attempt,
+                    maxAttempts,
+                    delayMs,
+                    errorMessage,
+                });
+            },
+            onRetryAttemptStart: () => {
+                this._emit({
+                    type: "summarization_retry_attempt_start",
+                    ...source,
+                });
+            },
+            onRetryFinished: () => {
+                this._emit({ type: "summarization_retry_finished" });
+            },
+        };
+    }
     /**
      * Prepare a retryable error for continuation with exponential backoff.
      * @returns true if the caller should continue the agent, false otherwise
@@ -3504,8 +3558,9 @@ export class AgentSession {
         await this.setModel(next);
     }
     /**
-     * Sticky safety models (e.g. claude-fable-5) often false-positive on coding turns.
-     * Retrying the same model repeats the refusal — switch via provider-resilience chain first.
+     * Content/safety stops (stop_reason=refusal) are often false positives on coding turns
+     * for Fable AND Claude Opus/Sonnet. Retrying the same model usually reprints the refusal —
+     * switch via provider-resilience chain first. Failover targets still skip sticky models.
      */
     async _maybeFailoverFromSafetyStop(message) {
         const resilience = resolveProviderResilience(this.settingsManager.getProviderResilienceSettings());
@@ -3514,11 +3569,15 @@ export class AgentSession {
         if (!isContentSafetyStopMessage(message.errorMessage))
             return undefined;
         const current = this.model;
-        const currentId = message.model || current?.id || "";
-        const currentProvider = message.provider || current?.provider || "";
-        if (!isStickySafetyModel(currentId, currentProvider))
-            return undefined;
+        // v10.0-Ω: do NOT gate on isStickySafetyModel(source).
+        // claude-opus-5 emits the same stop_reason=refusal FP; same-model retry is useless.
+        // v10.3-Ω: mark the model that just refused so we never re-pick it this turn.
+        if (current)
+            this._refusedModels.add(`${current.provider}/${current.id}`);
         const pick = pickFailoverCandidate(resilience.failoverCandidates, current ? { provider: current.provider, id: current.id } : undefined, (c) => {
+            // Skip any model that already refused/failed this turn → advance the chain.
+            if (this._refusedModels.has(`${c.provider}/${c.id}`))
+                return false;
             const next = this._modelRegistry.find(c.provider, c.id);
             return !!next && this._modelRegistry.hasConfiguredAuth(next);
         });
@@ -3532,6 +3591,8 @@ export class AgentSession {
             return `${next.provider}/${next.id}`;
         }
         catch {
+            // setModel failed (auth/guard) — blacklist so next retry advances further.
+            this._refusedModels.add(`${pick.provider}/${pick.id}`);
             return undefined;
         }
     }
@@ -3546,7 +3607,7 @@ export class AgentSession {
             this._retryAttempt--;
             return false;
         }
-        // Content/safety stop on Fable: switch model BEFORE delay so the retry is not another Fable refusal.
+        // Content/safety stop (Fable/Opus/Sonnet): switch model BEFORE delay so retry is not same-model refusal.
         const failoverTo = await this._maybeFailoverFromSafetyStop(message);
         // Safety stops are usually immediate false positives — short delay after failover, full backoff otherwise.
         const delayMs = failoverTo
@@ -3576,6 +3637,7 @@ export class AgentSession {
             // Aborted during sleep - emit end event so UI can clean up
             const attempt = this._retryAttempt;
             this._retryAttempt = 0;
+            this._refusedModels.clear();
             this._emit({
                 type: "auto_retry_end",
                 success: false,
@@ -3662,7 +3724,10 @@ export class AgentSession {
                         shellPath,
                         sandboxPolicy: this._getBashSandboxPreflight(options?.sandboxPolicy),
                     }), {
-                    onChunk,
+                    onChunk: (delta) => {
+                        onChunk?.(delta);
+                        this._emit({ type: "bash_execution_update", id: options?.id, delta });
+                    },
                     signal: this._bashAbortController.signal,
                 });
                 this.recordBashResult(command, result, options);
@@ -3838,6 +3903,8 @@ export class AgentSession {
                     replaceInstructions,
                     reserveTokens: branchSummarySettings.reserveTokens,
                     streamFn: this.agent.streamFn,
+                    retry: this.settingsManager.getRetrySettings(),
+                    callbacks: this._summarizationRetryCallbacks({ source: "branchSummary" }),
                 });
                 if (result.aborted) {
                     return { cancelled: true, aborted: true };