open-multi-agent-kit 0.96.2 → 0.97.0

package/dist/core/agent-session.js

@@ -79,7 +79,7 @@ import { computePromptTokenBudget } from "./prompt-budget.js";
 import { classifyPromptCacheTransition } from "./prompt-cache.js";
 import { createPromptSettlementState, reducePromptSettlement, settlePromptIfReady, } from "./prompt-settlement.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
-import { isQuotaExhaustionMessage, isStickySafetyModel, pickFailoverCandidate, resolveProviderResilience, shouldEjectStickySafetyModel, shouldHonorSafetyFailover, stickySafetyBlockMessage, } from "./provider-resilience.js";
+import { isQuotaExhaustionMessage, isStickySafetyModel, isUpstreamUnavailableMessage, pickFailoverCandidate, resolveFailoverCandidates, resolveProviderResilience, sameModelRouteCandidates, shouldEjectStickySafetyModel, shouldHonorSafetyFailover, stickySafetyBlockMessage, } from "./provider-resilience.js";
 import { computeRetryDelayMs, failoverModelKey, isFailoverTriggerError, isRetryableAssistantError, nextRetryAttempt, retryBudgetForAssistantError, } from "./provider-retry.js";
 import { getBiasStepsForCell, parseRouterBiasSnapshot } from "./reasoning-router-bias.js";
 import { classifyTaskV4, deriveRouterFeedbackFeaturesV4, resolveThinkingLevelV4WithUncertainty, TASK_CLASS_THINKING_LEVELS_V4, } from "./reasoning-router-v4.js";
@@ -624,6 +624,12 @@ export class AgentSession {
         if (/auth|unauthori[sz]ed|forbidden|invalid.?api.?key|no api key|401|403|\/login/i.test(text)) {
             return { area: "provider", code: "auth" };
         }
+        // Gateway/upstream 5xx and dropped streams are transport failures, not
+        // transcript-shape problems. Classify as network so the guidance points to
+        // retry/model-switch instead of the protocol sanitize path.
+        if (isUpstreamUnavailableMessage(text)) {
+            return { area: "provider", code: "network" };
+        }
         // Kimi/K3 + OpenAI-compat: orphan tool results after dropped error assistants.
         // Sanitize-and-retry (transform-messages drops orphans), not a hard tool fatal.
         if (/tool_call_id\s+is\s+not\s+found|tool_call_id\s+not\s+found|unknown\s+tool_call_id/i.test(text)) {
@@ -648,6 +654,9 @@ export class AgentSession {
         if (/auth|api key|unauthori[sz]ed|forbidden|401|403|\/login/i.test(message)) {
             return { area: "provider", code: "auth" };
         }
+        if (isUpstreamUnavailableMessage(message)) {
+            return { area: "provider", code: "network" };
+        }
         if (/context.+overflow|context window|too many tokens/i.test(message)) {
             return { area: "provider", code: "context_overflow" };
         }
@@ -1130,6 +1139,11 @@ export class AgentSession {
         }
         else if (event.type === "agent_end") {
             await this._extensionRunner.emit({ type: "agent_end", messages: event.messages });
+            // `agent_end` fires once per attempt. Extensions that release per-run
+            // state need the boundary no retry follows, so mark it explicitly.
+            if (!this._willRetryAfterAgentEnd(event)) {
+                await this._extensionRunner.emit({ type: "agent_settled", messages: event.messages });
+            }
         }
         else if (event.type === "turn_start") {
             this._turnMetricsState = {
@@ -2986,6 +3000,25 @@ export class AgentSession {
         });
         return model;
     }
+    /**
+     * Authenticated failover candidates for compaction summarization, in
+     * resilience-chain order, excluding the primary compaction model itself.
+     * Used when the primary model's quota is exhausted (same-model retry is
+     * useless until reset; another provider can still save the compaction).
+     */
+    _compactionFailoverModels(primary) {
+        const candidates = resolveFailoverCandidates(this.settingsManager.getProviderResilienceSettings());
+        const available = this._modelRegistry.getAvailable();
+        const models = [];
+        for (const candidate of candidates) {
+            if (candidate.provider === primary.provider && candidate.id === primary.id)
+                continue;
+            const resolved = available.find((m) => m.provider === candidate.provider && m.id === candidate.id);
+            if (resolved)
+                models.push(resolved);
+        }
+        return models;
+    }
     /**
      * Manually compact the session context.
      * Aborts current agent operation first.
@@ -3046,7 +3079,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, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason: "manual" }));
+                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" }), this._compactionFailoverModels(compactionModel));
                 summary = result.summary;
                 firstKeptEntryId = result.firstKeptEntryId;
                 tokensBefore = result.tokensBefore;
@@ -3089,6 +3122,8 @@ export class AgentSession {
                 compactionCode = "aborted";
             else if (stale)
                 compactionCode = "stale";
+            else if (isQuotaExhaustionMessage(message))
+                compactionCode = "quota_exhausted";
             const timestamp = new Date().toISOString();
             this._publishTermination(classifySessionTermination({
                 sessionId: this.sessionId,
@@ -3142,7 +3177,7 @@ export class AgentSession {
     /**
      * Effective context window for the upcoming turn.
      * Image-bearing turns with a text-only session model are auto-routed to the
-     * vision model (gpt-5.6-luna, 400K) — that window is the real limit. Text-only
+     * vision model (gpt-5.6-luna, 1M) — that window is the real limit. Text-only
      * turns keep the session model's (typically much larger) window.
      */
     _effectiveTurnContextWindow(pendingMessages, sessionWindow) {
@@ -3377,7 +3412,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, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason }));
+                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 }), this._compactionFailoverModels(compactionModel));
                 summary = compactResult.summary;
                 firstKeptEntryId = compactResult.firstKeptEntryId;
                 tokensBefore = compactResult.tokensBefore;
@@ -3992,6 +4027,41 @@ export class AgentSession {
         // setModel itself blocks sticky targets, not sources — safe.
         await this.setModel(next);
     }
+    /**
+     * Rotate to another authenticated provider route serving the SAME model
+     * family (e.g. openrouter/stealth/ox-alpha ↔ opencode-go/ox-alpha-free ↔
+     * opencode/x-preview-f-free). Used when the current route fails with an
+     * upstream availability error — same-model retry would hammer a dead
+     * endpoint while the identical model is one route away. Visited and
+     * unauthenticated routes are marked in {@link _refusedModels} so repeat
+     * failures advance the rotation within the turn.
+     */
+    async _maybeRotateModelRoutes() {
+        const current = this.model;
+        if (!current)
+            return undefined;
+        const candidates = sameModelRouteCandidates(current, this._modelRegistry.getAvailable());
+        for (const candidate of candidates) {
+            const key = failoverModelKey(candidate.provider, candidate.id);
+            if (this._refusedModels.has(key))
+                continue;
+            const next = this._modelRegistry.find(candidate.provider, candidate.id);
+            if (!next || !this._modelRegistry.hasConfiguredAuth(next)) {
+                this._refusedModels.add(key);
+                continue;
+            }
+            try {
+                await this.setModel(next);
+                // The old route just failed upstream — keep it out of this turn's retries.
+                this._refusedModels.add(failoverModelKey(current.provider, current.id));
+                return `${next.provider}/${next.id}`;
+            }
+            catch {
+                this._refusedModels.add(key);
+            }
+        }
+        return undefined;
+    }
     /**
      * 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 —
@@ -4053,12 +4123,19 @@ export class AgentSession {
         if (attempt === undefined)
             return false;
         this._retryAttempt = attempt;
+        // Upstream-unavailable (gateway 5xx / dropped stream): rotate to another
+        // authenticated route of the SAME model family so the retry lands on a
+        // live endpoint instead of hammering the dead one.
+        const rotatedTo = isUpstreamUnavailableMessage(message.errorMessage)
+            ? await this._maybeRotateModelRoutes()
+            : undefined;
         // Content/safety stop (Fable/Opus/Sonnet): switch model BEFORE delay so retry is not same-model refusal.
         const failoverTo = await this._maybeFailoverFromSafetyStop(message);
+        const switchedVia = failoverTo ? `failover ${failoverTo}` : rotatedTo ? `route ${rotatedTo}` : undefined;
         // Safety stops are usually immediate false positives — short delay after failover, full backoff otherwise.
-        const delayMs = computeRetryDelayMs(settings.baseDelayMs, attempt, failoverTo !== undefined);
-        const errorMessage = failoverTo
-            ? `${message.errorMessage || "content/safety stop"} → failover ${failoverTo}`
+        const delayMs = computeRetryDelayMs(settings.baseDelayMs, attempt, switchedVia !== undefined);
+        const errorMessage = switchedVia
+            ? `${message.errorMessage || "content/safety stop"} → ${switchedVia}`
             : message.errorMessage || "Unknown error";
         this._emit({
             type: "auto_retry_start",