@code-yeongyu/senpi 2026.9.10 → 2026.9.12-2

package/dist/core/agent-session.js

@@ -18,8 +18,9 @@ import { rm } from "node:fs/promises";
 import { basename, dirname } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { ProviderRetryWatchdogAbortError, prepareAgentToolCall } from "@earendil-works/pi-agent-core";
-import { contentText, measureCursorHistorySerializedBytes, SERVER_FALLBACK_ABORTED_DIAGNOSTIC, } from "@earendil-works/pi-ai";
+import { contentText, providerNotConfiguredMessage, SERVER_FALLBACK_ABORTED_DIAGNOSTIC, } from "@earendil-works/pi-ai";
 import { cleanupSessionResources, cursorOverflowCompactionSettings, isClassifierRefusal, isContextOverflow, isCursorPayloadResourceExhausted, isCursorQuotaResourceExhausted, isCursorZeroTokenResourceExhausted, isProviderStreamStallError, isProviderTimeoutError, isRecoverableLength, isRetryableAssistantError, modelsAreEqual, resetApiProviders, shouldRetryOverflowWithoutCompact, streamSimple, } from "@earendil-works/pi-ai/compat";
+import { getCursorContextLimit } from "@earendil-works/pi-ai/utils/cursor-context-limit";
 import { extract429RetryAfterMs, parseRetryAfterMsMarker } from "@earendil-works/pi-ai/utils/retry-hint";
 import { retryBackoffDelayMs } from "@earendil-works/pi-ai/utils/retry-profile/backoff";
 import { getAgentDir } from "../config.js";
@@ -37,12 +38,14 @@ import { calculateContextTokens, collectEntriesForBranchSummary, compact, estima
 import { CompactionLifecycleCoordinator } from "./compaction/lifecycle.js";
 import { isTurnStuckOnContextOverflow } from "./compaction/stuck-overflow.js";
 import { isWarmSummaryAnchorValid } from "./compaction/warm-anchor.js";
+import { admitCursorHistory, cursorAdmissionBudgetBytes } from "./cursor-history-admission.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 import { buildDynamicSystemPrompt } from "./dynamic-prompt/index.js";
 import { AssistantEditError, assertExpectedLeaf, assistantTextEquals, buildEditedAssistantMessage, SessionStreamingError, } from "./edited-assistant-message.js";
 import { areExperimentalFeaturesEnabled } from "./experimental.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
+import { CLAUDE_SDK_OAUTH_PROVIDER_ID } from "./extensions/builtin/claude-sdk-oauth/account-management.js";
 import { ModelUsabilityBudgetError, projectModelUsabilityBudget, } from "./extensions/builtin/compaction/model-usability-budget.js";
 import { resolveEffectiveReserveTokens, resolveReserveTokens, shouldTriggerCompaction, } from "./extensions/builtin/compaction/policy.js";
 import { createResumeCompactionRequirement, } from "./extensions/builtin/compaction/resume-admission.js";
@@ -55,8 +58,8 @@ import { ExecuteToolError, ExtensionRunner, wrapRegisteredTools, } from "./exten
 import { emitSessionShutdownEvent } from "./extensions/runner.js";
 import { normalizeToolExposure, RUNTIME_EXTENSION_PATH } from "./extensions/types.js";
 import { shouldWarnHighReasoning } from "./high-reasoning-warning.js";
-import { MANUAL_CONTINUE_CUSTOM_TYPE, MANUAL_CONTINUE_DIRECTIVE } from "./manual-continue.js";
-import { convertToLlm, filterContextExcludedMessages, } from "./messages.js";
+import { isManualContinueSubmission, MANUAL_CONTINUE_CUSTOM_TYPE, MANUAL_CONTINUE_DIRECTIVE, } from "./manual-continue.js";
+import { filterContextExcludedMessages } from "./messages.js";
 import { ModelRegistry } from "./model-registry.js";
 import { getModelNarrowingPatterns, resolveModelScope } from "./model-resolver.js";
 import { PROMPT_CACHE_SAFE_WAIT_ENV, resolvePromptCacheSafeWaitSeconds } from "./prompt-cache-budget.js";
@@ -334,121 +337,11 @@ function isSameOverflowSource(message, model, upstreamModelId) {
 const THINKING_LEVELS_WITH_MAX = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
 /** Caps explicit skill expansion so one prompt cannot consume unbounded context. */
 export const MAX_SKILL_EXPANSIONS_PER_PROMPT = 5;
-/** Cursor ingest rejects large verbatim tool payloads. The bound is UTF-8 bytes. */
-export const CURSOR_TOOL_RESULT_MAX_CHARS = 2000;
-export const CURSOR_TOOL_RESULT_MAX_BYTES = 50_000;
-const CURSOR_TRUNCATION_MARKER = "\n...[truncated]";
-export function truncateToolResultBodies(messages, maxChars = CURSOR_TOOL_RESULT_MAX_CHARS, maxBytes = CURSOR_TOOL_RESULT_MAX_BYTES, convert = (candidate) => convertToLlm(candidate)) {
-    if (!Array.isArray(messages) || messages.length === 0)
-        return { messages, changed: false };
-    const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
-    const markerChars = [...segmenter.segment(CURSOR_TRUNCATION_MARKER)].length;
-    const result = messages.slice();
-    let changed = false;
-    // Apply the per-result character cap first, independent of the aggregate wire cap.
-    for (let messageIndex = result.length - 1; messageIndex >= 0; messageIndex--) {
-        const message = result[messageIndex];
-        if (message.role !== "toolResult" || !Array.isArray(message.content))
-            continue;
-        let content = message.content;
-        for (let partIndex = content.length - 1; partIndex >= 0; partIndex--) {
-            const part = content[partIndex];
-            if (part.type === "image" && typeof part.data === "string")
-                continue;
-            if (part.type !== "text" || typeof part.text !== "string")
-                continue;
-            const graphemes = [...segmenter.segment(part.text)].map((item) => item.segment);
-            if (graphemes.length <= maxChars)
-                continue;
-            const kept = graphemes.slice(0, Math.max(0, maxChars - markerChars)).join("");
-            const nextText = kept + CURSOR_TRUNCATION_MARKER;
-            content = content === message.content ? content.slice() : content;
-            content[partIndex] = { ...part, text: nextText };
-            result[messageIndex] = { ...message, content };
-            changed = true;
-        }
-    }
-    const measure = (candidate) => {
-        const converted = convert(candidate);
-        const activeUserMessageIndex = converted.at(-1)?.role === "user" ? converted.length - 1 : -1;
-        return measureCursorHistorySerializedBytes(converted, activeUserMessageIndex);
-    };
-    const fits = (candidate = result) => measure(candidate) <= maxBytes;
-    if (fits())
-        return { messages: changed ? result : messages, changed };
-    // Empty the oldest result bodies. Search the monotonic prefix of candidates
-    // rather than serializing once for every result (admission must stay bounded).
-    const emptyToolResult = (message) => {
-        if (message.role !== "toolResult" || !Array.isArray(message.content))
-            return message;
-        const emptiedContent = message.content.map((part) => part.type === "text" ? { ...part, text: "" } : part.type === "image" ? { ...part, data: "" } : part);
-        const content = emptiedContent.filter((part, index) => {
-            if (index === 0)
-                return true;
-            const previous = emptiedContent[index - 1];
-            const empty = part.type === "text" ? part.text === "" : part.type === "image" && part.data === "";
-            const previousEmpty = previous.type === "text" ? previous.text === "" : previous.type === "image" && previous.data === "";
-            return !empty || !previousEmpty;
-        });
-        return { ...message, content };
-    };
-    const toolResultIndexes = result.flatMap((message, index) => message.role === "toolResult" && Array.isArray(message.content) ? [index] : []);
-    const withEmptyPrefix = (count) => {
-        const candidate = result.slice();
-        for (let i = 0; i < count; i++)
-            candidate[toolResultIndexes[i]] = emptyToolResult(candidate[toolResultIndexes[i]]);
-        return candidate;
-    };
-    let low = 0;
-    let high = toolResultIndexes.length;
-    while (low < high) {
-        const middle = Math.floor((low + high) / 2);
-        if (fits(withEmptyPrefix(middle + 1)))
-            high = middle;
-        else
-            low = middle + 1;
-    }
-    const emptyCount = Math.min(low + 1, toolResultIndexes.length);
-    if (emptyCount > 0) {
-        result.splice(0, result.length, ...withEmptyPrefix(emptyCount));
-        changed = true;
-    }
-    if (fits())
-        return { messages: changed ? result : messages, changed };
-    // If metadata alone exceeds the cap, discard the oldest complete turns. This
-    // search is also monotonic and avoids quadratic whole-history reserialization.
-    const turnRanges = [];
-    const isConvertedUser = (message) => convert([message])[0]?.role === "user";
-    for (let index = 0; index < result.length; index++) {
-        if (!isConvertedUser(result[index]))
-            continue;
-        const nextUser = result.findIndex((message, nextIndex) => nextIndex > index && isConvertedUser(message));
-        turnRanges.push([index, nextUser < 0 ? result.length : nextUser]);
-    }
-    const withoutTurns = (count) => {
-        if (count === 0)
-            return result;
-        const start = turnRanges[0]?.[0] ?? 0;
-        const end = turnRanges[count - 1]?.[1] ?? start;
-        return [...result.slice(0, start), ...result.slice(end)];
-    };
-    low = 0;
-    high = turnRanges.length;
-    while (low < high) {
-        const middle = Math.floor((low + high) / 2);
-        if (fits(withoutTurns(middle + 1)))
-            high = middle;
-        else
-            low = middle + 1;
-    }
-    const turnCount = Math.min(low + 1, turnRanges.length);
-    if (turnCount > 0) {
-        const next = withoutTurns(turnCount);
-        result.splice(0, result.length, ...next);
-        changed = true;
-    }
-    return { messages: changed ? result : messages, changed };
-}
+/**
+ * Cursor admission lives in its own module; the names stay exported here so
+ * existing importers keep resolving them.
+ */
+export { CURSOR_TOOL_RESULT_MAX_CHARS, truncateToolResultBodies } from "./cursor-history-admission.js";
 // ============================================================================
 // AgentSession Class
 // ============================================================================
@@ -904,6 +797,20 @@ export class AgentSession {
             usage: hookResult?.usage,
         };
     }
+    /**
+     * Cursor states a model's real context ceiling on every conversation
+     * checkpoint. Once observed, it replaces the catalog guess on the live model
+     * so context usage, compaction thresholds and admission all size against the
+     * window the server will actually enforce.
+     */
+    _applyObservedCursorContextWindow(model) {
+        const observed = getCursorContextLimit(model.id);
+        if (observed === undefined || observed <= 0 || observed === model.contextWindow)
+            return;
+        const previous = model.contextWindow;
+        model.contextWindow = observed;
+        this._sessionLogger.info("cursor_context_window_observed", { modelId: model.id, previous, observed });
+    }
     _installAgentNextTurnRefresh() {
         const previousPrepareNextTurnWithContext = this.agent.prepareNextTurnWithContext ??
             (this.agent.prepareNextTurn
@@ -912,10 +819,33 @@ export class AgentSession {
         const previousTransformContext = this.agent.transformContext;
         this.agent.transformContext = async (messages, signal) => {
             const transformed = previousTransformContext ? await previousTransformContext(messages, signal) : messages;
-            if (this.model?.provider === "cursor" || this.model?.provider === "cursor-cli-oauth") {
-                return ((await truncateToolResultBodies(transformed, CURSOR_TOOL_RESULT_MAX_CHARS, CURSOR_TOOL_RESULT_MAX_BYTES, (candidate) => this.agent.convertToLlm(candidate))).messages ?? transformed);
+            const model = this.model;
+            if (model?.provider !== "cursor" && model?.provider !== "cursor-cli-oauth")
+                return transformed;
+            this._applyObservedCursorContextWindow(model);
+            const budgetBytes = cursorAdmissionBudgetBytes(model.contextWindow);
+            const admission = admitCursorHistory({
+                messages: transformed,
+                budgetBytes,
+                convert: (candidate) => this.agent.convertToLlm(candidate),
+            });
+            if (admission.blankedToolResults > 0) {
+                this._sessionLogger.info("cursor_admission_truncated", {
+                    blankedToolResults: admission.blankedToolResults,
+                    bytesBefore: admission.bytesBefore,
+                    bytesAfter: admission.bytesAfter,
+                    budgetBytes,
+                });
+            }
+            if (admission.overBudget) {
+                // The request is still admitted: Cursor answers an oversized history
+                // with a 0-token resource_exhausted, which the session layer compacts.
+                this._sessionLogger.warn("cursor_admission_over_budget", {
+                    bytes: admission.bytesAfter,
+                    budgetBytes,
+                });
             }
-            return transformed;
+            return admission.messages ?? transformed;
         };
         this.agent.prepareNextTurnWithContext = async (turn, signal) => {
             // Enforce compaction only when this prepare precedes an actual provider
@@ -1700,9 +1630,14 @@ export class AgentSession {
             const hardErrorFallbackEligible = this._isHardErrorFallbackEligible(msg);
             const cursorZeroTokenRe = isCursorZeroTokenResourceExhausted(msg);
             const cursorQuotaRe = isCursorQuotaResourceExhausted(msg, this.model?.contextWindow ?? 0);
+            const claudeSdkSameModelRemint = this._isClaudeSdkSameModelRemintError(msg);
             const retryCanAdmitProvider = !userAbortSuppressedQueuedContinuation &&
                 this.settingsManager.getRetrySettings().enabled &&
-                (retryableError || hardErrorFallbackEligible || cursorZeroTokenRe || cursorQuotaRe);
+                (retryableError ||
+                    hardErrorFallbackEligible ||
+                    cursorZeroTokenRe ||
+                    cursorQuotaRe ||
+                    claudeSdkSameModelRemint);
             let compactedBeforeRetry = false;
             if (retryCanAdmitProvider &&
                 requiredAutoCompaction &&
@@ -1725,6 +1660,9 @@ export class AgentSession {
                     this._retireFailedRetryAssistant(msg);
                     retryOutcome = await this._handleRetryableError(msg, { hardErrorFallback: true });
                 }
+                else if (claudeSdkSameModelRemint) {
+                    retryOutcome = await this._handleRetryableError(msg, { sameModelRemint: true });
+                }
                 else if (retryableError) {
                     retryOutcome = await this._handleRetryableError(msg);
                 }
@@ -2791,7 +2729,11 @@ export class AgentSession {
             // empty session, or a "." carrying image attachments (the user is sending
             // the images, not asking to continue), falls through to ordinary prompt
             // handling below.
-            if (text.trim() === "." && this.agent.state.messages.length > 0 && !options?.images?.length) {
+            if (isManualContinueSubmission({
+                text,
+                hasMessages: this.agent.state.messages.length > 0,
+                hasImages: (options?.images?.length ?? 0) > 0,
+            })) {
                 await this.sendCustomMessage({
                     customType: MANUAL_CONTINUE_CUSTOM_TYPE,
                     content: MANUAL_CONTINUE_DIRECTIVE,
@@ -3782,10 +3724,67 @@ export class AgentSession {
     async setSessionModel(model) {
         return this._setModel(model, false);
     }
+    /**
+     * #1526: every switch guard rejects before `_switchActiveModel` appends its
+     * `model_change`, so a refused switch used to leave no entry, no event, and
+     * no log line - indistinguishable from a switch the user never attempted.
+     * Record the refusal, then rethrow the original error unchanged.
+     */
+    _recordRejectedModelChange(model, error) {
+        const budget = error instanceof ModelUsabilityBudgetError ? error.projection : undefined;
+        const detail = error instanceof Error ? error.message : String(error);
+        const reason = budget ? "context-budget" : "auth";
+        const numbers = budget
+            ? {
+                contextWindow: budget.contextWindow,
+                liveContextTokens: budget.liveContextTokens,
+                requiredTokens: budget.requiredTokens,
+                shortfallTokens: budget.shortfallTokens,
+                safetyMarginProfile: budget.safetyMarginProfile,
+            }
+            : {};
+        this.sessionManager.appendModelChangeRejected({
+            provider: model.provider,
+            modelId: model.id,
+            reason,
+            detail,
+            ...numbers,
+        });
+        this._emit({ type: "model_change_rejected", model, reason, detail, ...numbers });
+    }
+    /**
+     * The admission only selects wording, and the switch wording's remedy
+     * ("Compact the session, ...") is executable only when there is context to
+     * compact. `_setModel` is also reachable from `session_start` (the
+     * `recommended-models` builtin switches the model there), so derive the
+     * admission from the branch instead of hardcoding a switch: with conversation
+     * context this is a switch, on an empty session it is still a cold start.
+     */
+    _modelSwitchAdmission() {
+        return this.sessionManager.hasContextMessages() ? "switch" : "start";
+    }
+    /**
+     * The single guard seam for a model switch (#1526): every site that can
+     * refuse a switch - the `_setModel` pre-flight, the post-`model_select`
+     * revalidation in `_switchActiveModel`, and both cycle guards - records the
+     * refusal and rethrows the original error unchanged, so no refusal is
+     * observable on one path and invisible on its sibling.
+     */
+    _assertModelUsableForSwitch(model, liveContextTokens) {
+        try {
+            this.assertModelUsable(model, liveContextTokens, { admission: this._modelSwitchAdmission() });
+        }
+        catch (error) {
+            this._recordRejectedModelChange(model, error);
+            throw error;
+        }
+    }
     async _setModel(model, updateGlobalDefaults) {
-        this.assertModelUsable(model, this._getDownswitchLiveContextTokens(model));
+        this._assertModelUsableForSwitch(model, this._getDownswitchLiveContextTokens(model));
         if (!(await this._modelRuntime.checkAuth(model.provider))) {
-            throw new Error(`No API key for ${model.provider}/${model.id}`);
+            const error = new Error(`No API key for ${model.provider}/${model.id}`);
+            this._recordRejectedModelChange(model, error);
+            throw error;
         }
         // A manual model change abandons any active fallback window; if a fallback
         // retry sleep is still pending, cancel it so no surprise continuation fires.
@@ -3859,7 +3858,7 @@ export class AgentSession {
             const systemPromptChange = opts.emitModelSelect
                 ? await this._emitModelSelect(model, previousModel, opts.modelSelectSource)
                 : undefined;
-            this.assertModelUsable(model, liveContextTokens);
+            this._assertModelUsableForSwitch(model, liveContextTokens);
             if (opts.appendSessionEntry) {
                 this.sessionManager.appendModelChange(model.provider, model.id, opts.entryReason, previousModel?.provider, previousModel?.id);
             }
@@ -3959,7 +3958,7 @@ export class AgentSession {
             const alternatives = favoriteModels.filter((entry) => !modelsAreEqual(entry.model, currentModel));
             const onlyAlternative = alternatives.length === 1 ? alternatives[0] : undefined;
             if (onlyAlternative) {
-                this.assertModelUsable(onlyAlternative.model, this._getDownswitchLiveContextTokens(onlyAlternative.model));
+                this._assertModelUsableForSwitch(onlyAlternative.model, this._getDownswitchLiveContextTokens(onlyAlternative.model));
             }
             return {
                 model: currentModel,
@@ -3970,7 +3969,7 @@ export class AgentSession {
         }
         const next = favoriteModels[selectedIndex];
         const liveContextTokens = this._getDownswitchLiveContextTokens(next.model);
-        this.assertModelUsable(next.model, liveContextTokens);
+        this._assertModelUsableForSwitch(next.model, liveContextTokens);
         const invalidatesCompaction = this._modelSelectionChangesContext(currentModel, next.model) ||
             currentModel?.provider !== next.model.provider ||
             currentModel?.id !== next.model.id;
@@ -3981,25 +3980,30 @@ export class AgentSession {
         this._retryFallback.clearForManualModelChange(next.model);
         const thinking = this._getThinkingForModelSwitch(next.model, next.thinkingLevel, next.thinkingSelection);
         this.agent.state.model = next.model;
-        this.sessionManager.appendModelChange(next.model.provider, next.model.id);
-        this.settingsManager.setDefaultModelAndProvider(next.model.provider, next.model.id);
         const previousTier = this._currentServiceTier;
         const previousFastMode = this.isFastModeActive();
         this._currentServiceTier = this._resolveServiceTier(next.model, next.serviceTier);
         // Apply thinking level and provenance from the favorite projection or remembered preference.
         this._setThinkingLevel(thinking.level, false, thinking.selection);
-        // Post-switch, same contract as _switchActiveModel: the level in force AFTER the cycle.
-        this._emit({
-            type: "model_changed",
-            model: next.model,
-            thinkingLevel: this.thinkingLevel,
-            source: "cycle",
-        });
-        this._emitServiceTierChangeIfNeeded(previousTier, previousFastMode);
         const previousSystemPrompt = this.agent.state.systemPrompt;
         try {
             const systemPromptChange = await this._emitModelSelect(next.model, currentModel, "cycle");
-            this.assertModelUsable(next.model, liveContextTokens);
+            // #1526: the `model_select` hook may have grown the system prompt, so the
+            // switch is not decided yet. Nothing durable - no `model_change`, no global
+            // default - may be written before this guard accepts, or a refused cycle
+            // would resume on a model that never ran (the ordering `_switchActiveModel`
+            // already uses).
+            this._assertModelUsableForSwitch(next.model, liveContextTokens);
+            this.sessionManager.appendModelChange(next.model.provider, next.model.id);
+            this.settingsManager.setDefaultModelAndProvider(next.model.provider, next.model.id);
+            // Post-switch, same contract as _switchActiveModel: the level in force AFTER the cycle.
+            this._emit({
+                type: "model_changed",
+                model: next.model,
+                thinkingLevel: this.thinkingLevel,
+                source: "cycle",
+            });
+            this._emitServiceTierChangeIfNeeded(previousTier, previousFastMode);
             const cycleResult = {
                 model: next.model,
                 thinkingLevel: this.thinkingLevel,
@@ -4017,6 +4021,7 @@ export class AgentSession {
             else
                 delete this.agent.state.model;
             this.agent.state.systemPrompt = previousSystemPrompt;
+            this._currentServiceTier = previousTier;
             throw error;
         }
     }
@@ -4821,7 +4826,11 @@ export class AgentSession {
         // Size the same retained context that will be admitted to Cursor. Persisted JSONL
         // remains verbatim, but the in-memory request representation is bounded first.
         if (model.provider === "cursor" || model.provider === "cursor-cli-oauth") {
-            simulatedMessages = truncateToolResultBodies(simulatedMessages).messages ?? simulatedMessages;
+            simulatedMessages =
+                admitCursorHistory({
+                    messages: simulatedMessages,
+                    budgetBytes: cursorAdmissionBudgetBytes(model.contextWindow),
+                }).messages ?? simulatedMessages;
         }
         const contextTokens = estimateMessagesTokens(filterContextExcludedMessages(simulatedMessages));
         const settings = this._getCompactionSettings();
@@ -6336,8 +6345,42 @@ export class AgentSession {
         this.agent.state.messages = messages.slice(lastUser);
         return true;
     }
+    _isClaudeSdkSessionLockError(message) {
+        return (message.errorMessage ?? "").includes("Lock file is already being held");
+    }
+    _isClaudeSdkInvalidRequestError(message) {
+        return message.errorMessage === "invalid_request";
+    }
+    /**
+     * Claude-SDK-only quirks that a provider hop cannot fix: the session.json
+     * lock is held by this session's own subprocess, and a bare `invalid_request`
+     * from the SDK boundary carries no provider-neutral meaning. Both are scoped
+     * to the Claude SDK lane, because the SAME wording from another provider is
+     * an ordinary failure whose classification (transient retry, or hard-error
+     * fallback) must not change. Provider-agnostic classes - the stream-stall
+     * watchdog above all - stay out of this predicate: they already consume the
+     * shared same-model budget through `isRetryableAssistantError` and must still
+     * escalate to the fallback chain when that budget runs out.
+     */
+    _isClaudeSdkSameModelRemintError(message) {
+        if (this.model?.provider !== CLAUDE_SDK_OAUTH_PROVIDER_ID)
+            return false;
+        return this._isClaudeSdkSessionLockError(message) || this._isClaudeSdkInvalidRequestError(message);
+    }
+    /**
+     * The Claude SDK lane owns its own account pool: an auth miss there is
+     * repaired or failed over inside the pool, so hopping to another provider
+     * would abandon the user's Claude subscription on a recoverable miss. Every
+     * other provider keeps the configured fallback-chain hop.
+     */
+    _isClaudeSdkAuthMissError(message) {
+        return (this.model?.provider === CLAUDE_SDK_OAUTH_PROVIDER_ID &&
+            message.errorMessage === providerNotConfiguredMessage(CLAUDE_SDK_OAUTH_PROVIDER_ID));
+    }
     _isHardErrorFallbackEligible(message) {
         return (!message.errorMessage?.startsWith(TURN_RETRY_SUPPRESSION_PREFIX) &&
+            !this._isClaudeSdkAuthMissError(message) &&
+            !this._isClaudeSdkSameModelRemintError(message) &&
             message.stopReason === "error" &&
             !isContextOverflow(message, this.model?.contextWindow ?? 0) &&
             !this._isCursorPayloadOverflow(message) &&