dominds 1.16.4 → 1.16.5

package/dist/dialog-display-state.d.ts

@@ -51,6 +51,7 @@ export declare function broadcastDisplayStateMarker(dialogId: DialogID, marker:
     reason?: DialogInterruptionReason;
 }): void;
 export declare function computeIdleDisplayState(dlg: Dialog): Promise<DialogDisplayState>;
+export declare function refreshRunControlProjectionFromPersistenceFacts(dialogId: DialogID, trigger: 'resume_dialog' | 'resume_all' | 'run_control_snapshot' | 'pending_subdialogs_changed' | 'q4h_changed'): Promise<DialogLatestFile | null>;
 export declare function reconcileDisplayStatesAfterRestart(): Promise<void>;
 export declare function requestInterruptDialog(dialogId: DialogID, reason: StopRequestedReason): Promise<{
     applied: boolean;

package/dist/dialog-display-state.js

@@ -39,6 +39,7 @@ exports.clearDialogInterruptedExecutionMarker = clearDialogInterruptedExecutionM
 exports.setDialogDisplayState = setDialogDisplayState;
 exports.broadcastDisplayStateMarker = broadcastDisplayStateMarker;
 exports.computeIdleDisplayState = computeIdleDisplayState;
+exports.refreshRunControlProjectionFromPersistenceFacts = refreshRunControlProjectionFromPersistenceFacts;
 exports.reconcileDisplayStatesAfterRestart = reconcileDisplayStatesAfterRestart;
 exports.requestInterruptDialog = requestInterruptDialog;
 exports.requestEmergencyStopAll = requestEmergencyStopAll;
@@ -84,6 +85,9 @@ function isDialogLatestResumable(latest) {
         latest.displayState.continueEnabled &&
         latest.executionMarker?.kind === 'interrupted');
 }
+function isSameDisplayState(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
 function classifyRunControlBucket(state) {
     if (!state)
         return 'none';
@@ -122,8 +126,13 @@ async function getRunControlCountsSnapshot() {
             if (latest?.generating === true) {
                 proceeding++;
             }
-            else if (isDialogLatestResumable(latest)) {
-                resumable++;
+            else if (latest?.executionMarker?.kind === 'interrupted' &&
+                isStoppedReasonResumable(latest.executionMarker.reason)) {
+                const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
+                const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, 'running');
+                if (q4h.length === 0 && pendingSubdialogs.length === 0) {
+                    resumable++;
+                }
             }
         }
         catch (error) {
@@ -444,6 +453,66 @@ async function computeIdleDisplayStateFromPersistence(dialogId) {
     }
     return { kind: 'idle_waiting_user' };
 }
+async function refreshRunControlProjectionFromPersistenceFacts(dialogId, trigger) {
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, 'running');
+    if (!latest) {
+        return null;
+    }
+    if (latest.generating === true) {
+        return latest;
+    }
+    if (hasActiveRun(dialogId)) {
+        return latest;
+    }
+    const desired = await (async () => {
+        if (dialogId.selfId !== dialogId.rootId &&
+            latest.executionMarker &&
+            latest.executionMarker.kind === 'dead') {
+            return { kind: 'dead', reason: latest.executionMarker.reason };
+        }
+        const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
+        const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, 'running');
+        const hasQ4H = q4h.length > 0;
+        const hasSubdialogs = pendingSubdialogs.length > 0;
+        if (hasQ4H && hasSubdialogs) {
+            return { kind: 'blocked', reason: { kind: 'needs_human_input_and_subdialogs' } };
+        }
+        if (hasQ4H) {
+            return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
+        }
+        if (hasSubdialogs) {
+            return { kind: 'blocked', reason: { kind: 'waiting_for_subdialogs' } };
+        }
+        if (latest.executionMarker?.kind === 'interrupted') {
+            return {
+                kind: 'stopped',
+                reason: latest.executionMarker.reason,
+                continueEnabled: isStoppedReasonResumable(latest.executionMarker.reason),
+            };
+        }
+        return { kind: 'idle_waiting_user' };
+    })();
+    const executionMarkerNeedsHealing = desired.kind === 'stopped'
+        ? latest.executionMarker?.kind !== 'interrupted' ||
+            JSON.stringify(latest.executionMarker.reason) !== JSON.stringify(desired.reason)
+        : desired.kind === 'dead'
+            ? latest.executionMarker?.kind !== 'dead' ||
+                JSON.stringify(latest.executionMarker.reason) !== JSON.stringify(desired.reason)
+            : latest.executionMarker?.kind === 'interrupted';
+    const displayStateNeedsHealing = !isSameDisplayState(latest.displayState, desired);
+    if (!displayStateNeedsHealing && !executionMarkerNeedsHealing) {
+        return latest;
+    }
+    log.warn('Healing stale run-control projection from persistence facts', undefined, {
+        dialogId: dialogId.valueOf(),
+        trigger,
+        previousDisplayState: latest.displayState ?? null,
+        previousExecutionMarker: latest.executionMarker ?? null,
+        healedDisplayState: desired,
+    });
+    await setDialogDisplayState(dialogId, desired);
+    return await persistence_1.DialogPersistence.loadDialogLatest(dialogId, 'running');
+}
 async function computeIdleDisplayStateForReconciliation(dialogId) {
     try {
         return await computeIdleDisplayStateFromPersistence(dialogId);

package/dist/docs/mcp-support.md

@@ -335,9 +335,13 @@ Policy:
     reduce tool set, etc.).
 - **Network/retriable errors**: Dominds may auto-retry only for clearly retriable classes such as
   transient network failures/timeouts and provider transient errors (e.g. rate limits or 5xx), using
-  bounded backoff and a max retry count.
+  strategy-specific backoff. Explicit short transport failures may use a brief aggressive burst, explicit
+  rate-limit signals may use smart-rate backoff, and everything else should default to conservative
+  keepalive retry instead of stopping just because a fixed retry-count ceiling was reached. Only
+  high-confidence non-progress cases should stop automatic retry.
 
-This keeps the system responsive and avoids infinite “retry loops” caused by invalid tool schemas.
+This keeps the system responsive while still avoiding pointless automatic loops caused by invalid tool
+schemas or other high-confidence non-retriable failures.
 
 ## Environment Variables (`env`)
 

package/dist/llm/api-quirks.js

@@ -7,6 +7,7 @@ const DOMINDS_LLM_EMPTY_RESPONSE_ERROR_CODE = 'DOMINDS_LLM_EMPTY_RESPONSE';
 const XCODE_BEST_EMPTY_RESPONSE_SINGLE_RETRY_DELAY_MS = 3000;
 const XCODE_BEST_EMPTY_RESPONSE_GIVE_UP_THRESHOLD = 5;
 const XCODE_BEST_GATEWAY_HTML_502_RETRY_MESSAGE = 'xcode.best gateway returned an HTML 502 Bad Gateway page; retrying conservatively.';
+const XCODE_BEST_AUTH_UNAVAILABLE_RETRY_MESSAGE = 'xcode.best upstream returned 500 auth_unavailable: no auth available; treating it as an infrastructure failure and retrying conservatively.';
 const XCODE_BEST_UNEXPECTED_EOF_RETRY_MESSAGE = 'xcode.best upstream stream ended unexpectedly (unexpected EOF); retrying conservatively.';
 const LOCAL_FILE_IO_ERROR_CODES = new Set(['ENOENT', 'ENOTDIR', 'EISDIR', 'EACCES', 'EPERM']);
 const LOCAL_FILE_IO_SYSCALLS = new Set([
@@ -42,6 +43,21 @@ function isXcodeBestUnexpectedEofFailure(failure, error) {
         failure.message.toLowerCase().includes('unexpected eof')) &&
         !hasLikelyLocalFileErrorContext(error));
 }
+function isXcodeBestAuthUnavailableFailure(failure, error) {
+    const status = failure.status ?? readErrorStatus(error);
+    if (status !== 500) {
+        return false;
+    }
+    const code = (failure.code ?? readErrorCode(error))?.trim().toLowerCase();
+    if (code === 'auth_unavailable') {
+        return true;
+    }
+    const message = (readErrorMessage(error) ?? failure.message).toLowerCase();
+    if (message.includes('auth_unavailable')) {
+        return true;
+    }
+    return code === 'internal_server_error' && message.includes('no auth available');
+}
 function getErrorChain(error) {
     const queue = [error];
     const visited = new Set();
@@ -248,12 +264,12 @@ function buildXcodeBestEmptyResponseGiveUpText(providerConfig, provider) {
     const providerName = providerConfig.name.trim().length > 0 ? providerConfig.name : provider;
     const summaryTextI18n = {
         zh: `${providerName} 在同一对话上下文中连续返回 empty response。` +
-            `Dominds 已在 ${String(XCODE_BEST_EMPTY_RESPONSE_GIVE_UP_THRESHOLD)} 次 empty response 后停止继续重试，因为这通常表示 provider 侧该对话上下文已经卡住；` +
-            '如果直接点继续，大概率仍然无真实进展；更建议结合真实情况灵活尝试多种新的指令，例如改写问题、补充上下文、换一个切入方式。',
+            `Dominds 已在 ${String(XCODE_BEST_EMPTY_RESPONSE_GIVE_UP_THRESHOLD)} 次 empty response 后停止沿用同一上下文继续自动重试，因为这通常表示 provider 侧该对话上下文已经卡住；` +
+            '如果不引入新的信息或新的指令，直接点继续大概率仍然无真实进展；更建议补充上下文、改写问题、换一个切入方式，或在确实需要人类判断时调用 askHuman。',
         en: `${providerName} returned empty responses repeatedly for the same dialog context. ` +
-            `Dominds stopped retrying after ${String(XCODE_BEST_EMPTY_RESPONSE_GIVE_UP_THRESHOLD)} empty responses because this usually means the provider-side conversation ` +
-            'context is stuck; simply pressing Continue is still unlikely to make real progress, ' +
-            'so it is better to try different fresh instructions based on the real situation, such as reframing the ask, adding context, or changing the angle.',
+            `Dominds stopped repeating the same-context automatic retry path after ${String(XCODE_BEST_EMPTY_RESPONSE_GIVE_UP_THRESHOLD)} empty responses because this usually means the provider-side conversation ` +
+            'context is stuck; simply pressing Continue without new information or fresh instructions is still unlikely to make real progress, ' +
+            'so it is better to add context, reframe the ask, change the angle, or call askHuman when human judgment is genuinely needed.',
     };
     return {
         providerName,
@@ -269,6 +285,11 @@ function createXcodeBestFailureQuirkHandlerSession(providerConfig) {
         onFailure(args) {
             const { providerName, summaryTextI18n, recoveryAction } = buildXcodeBestEmptyResponseGiveUpText(providerConfig, args.provider);
             if (args.failure.code === DOMINDS_LLM_EMPTY_RESPONSE_ERROR_CODE) {
+                // xcode.best can enter a same-context deadlock where the upstream keeps returning empty
+                // responses forever until the dialog context changes materially. A short burst of
+                // temporary retries is still worthwhile for transient glitches, but once the streak reaches
+                // the threshold we must stop repeating the exact same automatic path and require fresh
+                // information / fresh instructions instead of hiding the deadlock behind slow retries.
                 consecutiveEmptyResponseCount += 1;
                 if (consecutiveEmptyResponseCount < XCODE_BEST_EMPTY_RESPONSE_GIVE_UP_THRESHOLD) {
                     return {
@@ -279,7 +300,7 @@ function createXcodeBestFailureQuirkHandlerSession(providerConfig) {
                 return {
                     kind: 'give_up',
                     message: `${providerName} returned empty responses repeatedly for the same dialog context; ` +
-                        'automatic retries were stopped; simply continuing is still unlikely to make real progress, so it is better to flexibly try different fresh instructions based on the real situation.',
+                        'Dominds stopped repeating the same-context automatic retry path; continuing without new information is still unlikely to make real progress, so it is better to introduce fresh instructions or new context based on the real situation.',
                     summaryTextI18n,
                     recoveryAction: consumedDiligencePushRecoverySinceLastSuccess
                         ? { kind: 'none' }
@@ -301,6 +322,13 @@ function createXcodeBestFailureQuirkHandlerSession(providerConfig) {
                     message: XCODE_BEST_GATEWAY_HTML_502_RETRY_MESSAGE,
                 };
             }
+            if (isXcodeBestAuthUnavailableFailure(args.failure, args.error)) {
+                return {
+                    kind: 'retry_strategy',
+                    retryStrategy: 'conservative',
+                    message: XCODE_BEST_AUTH_UNAVAILABLE_RETRY_MESSAGE,
+                };
+            }
             return { kind: 'default' };
         },
         onRequestSucceeded() {

package/dist/llm/client.d.ts

@@ -56,7 +56,7 @@ export type ProviderConfig = {
     baseUrl: string;
     apiKeyEnvVar: string;
     tool_result_max_chars?: number;
-    llm_retry_max_retries?: number;
+    llm_retry_aggressive_max_retries?: number;
     llm_retry_initial_delay_ms?: number;
     llm_retry_conservative_delay_ms?: number;
     llm_retry_backoff_multiplier?: number;

package/dist/llm/defaults.yaml

@@ -1,5 +1,7 @@
 # Optional provider-level retry controls for kernel dialog driving:
-# - llm_retry_max_retries: extra retries after the initial attempt (default 99; ~41.2h total retry window with current backoff defaults).
+# - llm_retry_aggressive_max_retries: front-loaded fast retries before Dominds automatically downgrades
+#   to conservative slow retry (default 3). Automatic retries no longer stop just because a retry
+#   count budget was exhausted.
 # - llm_retry_initial_delay_ms: delay before the 1st retry (default 1000).
 # - llm_retry_conservative_delay_ms: base delay for provider-classified conservative retries (default 30000; fixed for first 10 retries, then ramps by x1.5 with the normal max-delay cap).
 # - llm_retry_backoff_multiplier: exponential factor between retries (default 1.5).
@@ -7,8 +9,9 @@
 # - apiQuirks: optional provider/gateway quirk profile(s) for non-standard transport behavior
 #   and provider-specific failure handling that can override the driver's default retry disposition.
 #   Example: `apiQuirks: xcode.best` currently covers both keepalive/heartbeat stream quirks and
-#   repeated empty-response handling for the same dialog context, plus conservative retry
-#   classification for gateway-returned HTML 502 Bad Gateway pages.
+#   repeated empty-response deadlock detection for the same unchanged dialog context, plus conservative retry
+#   classification for gateway-returned HTML 502 Bad Gateway pages and
+#   `500 auth_unavailable: no auth available` infrastructure failures.
 # - tool_result_max_chars: optional transport-level cap for a single tool-result text payload
 #   before Dominds projects it into the provider request. Use this when a provider/gateway enforces
 #   a stricter per-item string limit than Dominds' built-in defaults.

package/dist/llm/gen/failure-classifier.d.ts

@@ -3,8 +3,6 @@ export declare function readErrorStatus(error: unknown): number | undefined;
 export declare function readErrorCode(error: unknown): string | undefined;
 export declare function readErrorMessage(error: unknown): string | undefined;
 export declare function readProviderSuggestedRetryAfterMs(error: unknown): number | undefined;
-export declare function isConservativeRetryMessage(lowerMessage: string): boolean;
-export declare function isOpenAiLikeOverloadFailure(error: unknown): boolean;
 export declare function isOpenAiLikeRateLimitFailure(error: unknown): boolean;
 export declare function classifyOpenAiLikeFailure(error: unknown): LlmFailureDisposition | undefined;
 export declare function classifyAnthropicFailure(error: unknown): LlmFailureDisposition | undefined;

package/dist/llm/gen/failure-classifier.js

@@ -4,8 +4,6 @@ exports.readErrorStatus = readErrorStatus;
 exports.readErrorCode = readErrorCode;
 exports.readErrorMessage = readErrorMessage;
 exports.readProviderSuggestedRetryAfterMs = readProviderSuggestedRetryAfterMs;
-exports.isConservativeRetryMessage = isConservativeRetryMessage;
-exports.isOpenAiLikeOverloadFailure = isOpenAiLikeOverloadFailure;
 exports.isOpenAiLikeRateLimitFailure = isOpenAiLikeRateLimitFailure;
 exports.classifyOpenAiLikeFailure = classifyOpenAiLikeFailure;
 exports.classifyAnthropicFailure = classifyAnthropicFailure;
@@ -195,28 +193,46 @@ function isOpenAiRetriableProcessingFailureMessage(lowerMessage) {
     }
     return lowerMessage.includes('help.openai.com') && lowerMessage.includes('request id');
 }
-function isConservativeRetryMessage(lowerMessage) {
-    if (lowerMessage.includes('servers are currently overloaded')) {
-        return true;
-    }
-    if (lowerMessage.includes('server is currently overloaded')) {
+const OPENAI_LIKE_AGGRESSIVE_TRANSPORT_CODES = new Set([
+    'ETIMEDOUT',
+    'ECONNRESET',
+    'ECONNREFUSED',
+    'EAI_AGAIN',
+    'ENOTFOUND',
+    'ENETUNREACH',
+    'EHOSTUNREACH',
+    'UND_ERR_CONNECT_TIMEOUT',
+    'UND_ERR_HEADERS_TIMEOUT',
+    'UND_ERR_BODY_TIMEOUT',
+    'UND_ERR_SOCKET',
+]);
+function isOpenAiLikeAggressiveTransportFailure(error, lowerMessage) {
+    const code = readErrorCode(error);
+    if (typeof code === 'string' && OPENAI_LIKE_AGGRESSIVE_TRANSPORT_CODES.has(code)) {
         return true;
     }
-    if (lowerMessage.includes('currently overloaded')) {
+    if (lowerMessage.includes('fetch failed') || lowerMessage.includes('socket hang up')) {
         return true;
     }
-    if (lowerMessage.includes('temporarily overloaded')) {
+    if (lowerMessage.includes('terminated')) {
         return true;
     }
-    if (lowerMessage.includes('service unavailable')) {
+    if (lowerMessage.includes('timeout') || lowerMessage.includes('timed out')) {
         return true;
     }
-    return lowerMessage.includes('overloaded') && lowerMessage.includes('try again later');
+    return false;
 }
-function isOpenAiLikeOverloadFailure(error) {
-    const lowerMessage = buildFailureMessage(error).toLowerCase();
+function isHighConfidenceRejectedStatus(status) {
+    return (status === 400 ||
+        status === 401 ||
+        status === 403 ||
+        status === 404 ||
+        status === 413 ||
+        status === 422);
+}
+function isOpenAiLikeRejectedFailure(error) {
     const status = readErrorStatus(error);
-    return status === 503 || status === 529 || isConservativeRetryMessage(lowerMessage);
+    return isHighConfidenceRejectedStatus(status);
 }
 function isOpenAiLikeRateLimitFailure(error) {
     const lowerMessage = buildFailureMessage(error).toLowerCase();
@@ -251,6 +267,14 @@ function classifyOpenAiLikeFailure(error) {
     const lowerMessage = message.toLowerCase();
     const status = readErrorStatus(error);
     const code = readErrorCode(error);
+    if (isOpenAiLikeRejectedFailure(error)) {
+        return {
+            kind: 'rejected',
+            message,
+            status,
+            code,
+        };
+    }
     if (code === 'OPENAI_MALFORMED_BATCH_OUTPUT_ITEM') {
         return {
             kind: 'fatal',
@@ -268,23 +292,23 @@ function classifyOpenAiLikeFailure(error) {
             retryStrategy: 'aggressive',
         };
     }
-    if (isOpenAiLikeOverloadFailure(error)) {
+    if (isOpenAiLikeRateLimitFailure(error)) {
         return {
             kind: 'retriable',
             message,
             status,
             code,
-            retryStrategy: 'conservative',
+            retryStrategy: 'smart_rate',
+            retryAfterMs: readProviderSuggestedRetryAfterMs(error),
         };
     }
-    if (isOpenAiLikeRateLimitFailure(error)) {
+    if (isOpenAiLikeAggressiveTransportFailure(error, lowerMessage)) {
         return {
             kind: 'retriable',
             message,
             status,
             code,
-            retryStrategy: 'smart_rate',
-            retryAfterMs: readProviderSuggestedRetryAfterMs(error),
+            retryStrategy: 'aggressive',
         };
     }
     if (isOpenAiRetriableProcessingFailureMessage(lowerMessage)) {
@@ -293,20 +317,63 @@ function classifyOpenAiLikeFailure(error) {
             message,
             status,
             code,
-            retryStrategy: 'aggressive',
+            retryStrategy: 'conservative',
+        };
+    }
+    if (status !== undefined || code !== undefined) {
+        return {
+            kind: 'retriable',
+            message,
+            status,
+            code,
+            retryStrategy: 'conservative',
         };
     }
     return undefined;
 }
+function isAnthropicRejectedFailure(error) {
+    const status = readErrorStatus(error);
+    const errorType = readErrorType(error);
+    if (isHighConfidenceRejectedStatus(status)) {
+        return true;
+    }
+    return (errorType === 'invalid_request_error' ||
+        errorType === 'authentication_error' ||
+        errorType === 'permission_error' ||
+        errorType === 'not_found_error');
+}
+function isAnthropicRateLimitFailure(error) {
+    const status = readErrorStatus(error);
+    const errorType = readErrorType(error);
+    const lowerMessage = buildFailureMessage(error).toLowerCase();
+    if (status === 429 || errorType === 'rate_limit_error') {
+        return true;
+    }
+    return lowerMessage.includes('rate limit');
+}
 function classifyAnthropicFailure(error) {
     const message = buildFailureMessage(error);
-    const lowerMessage = message.toLowerCase();
     const status = readErrorStatus(error);
     const code = readErrorCode(error);
-    const errorType = readErrorType(error);
-    if (errorType === 'overloaded_error' ||
-        status === 529 ||
-        isConservativeRetryMessage(lowerMessage)) {
+    if (isAnthropicRejectedFailure(error)) {
+        return {
+            kind: 'rejected',
+            message,
+            status,
+            code,
+        };
+    }
+    if (isAnthropicRateLimitFailure(error)) {
+        return {
+            kind: 'retriable',
+            message,
+            status,
+            code,
+            retryStrategy: 'smart_rate',
+            retryAfterMs: readProviderSuggestedRetryAfterMs(error),
+        };
+    }
+    if (status !== undefined || readErrorType(error) !== undefined) {
         return {
             kind: 'retriable',
             message,

package/dist/llm/kernel-driver/drive.js

@@ -33,7 +33,7 @@ const reply_guidance_1 = require("./reply-guidance");
 const runtime_1 = require("./runtime");
 const tellask_special_1 = require("./tellask-special");
 const KERNEL_DRIVER_DEFAULT_RETRY_POLICY = {
-    maxRetries: 99, // long total retry window to survive major down-time by llm providers
+    aggressiveMaxRetries: 3, // short fast burst; persistent failures automatically downgrade to conservative
     initialDelayMs: 1000,
     conservativeDelayMs: 30000,
     backoffMultiplier: 1.5,
@@ -169,13 +169,13 @@ function isUserOriginPrompt(prompt) {
 function resolveModelInfo(providerCfg, model) {
     return providerCfg.models[model];
 }
-function resolveRetryMaxRetries(raw) {
+function resolveRetryAggressiveMaxRetries(raw) {
     if (typeof raw !== 'number' || !Number.isFinite(raw)) {
-        return KERNEL_DRIVER_DEFAULT_RETRY_POLICY.maxRetries;
+        return KERNEL_DRIVER_DEFAULT_RETRY_POLICY.aggressiveMaxRetries;
     }
     const normalized = Math.floor(raw);
     if (normalized < 0) {
-        return KERNEL_DRIVER_DEFAULT_RETRY_POLICY.maxRetries;
+        return KERNEL_DRIVER_DEFAULT_RETRY_POLICY.aggressiveMaxRetries;
     }
     return normalized;
 }
@@ -219,13 +219,13 @@ function resolveRetryMaxDelayMs(raw) {
     return normalized;
 }
 function resolveKernelDriverRetryPolicy(providerCfg) {
-    const maxRetries = resolveRetryMaxRetries(providerCfg.llm_retry_max_retries);
+    const aggressiveMaxRetries = resolveRetryAggressiveMaxRetries(providerCfg.llm_retry_aggressive_max_retries);
     const initialDelayMs = resolveRetryInitialDelayMs(providerCfg.llm_retry_initial_delay_ms);
     const conservativeDelayMs = resolveRetryConservativeDelayMs(providerCfg.llm_retry_conservative_delay_ms);
     const backoffMultiplier = resolveRetryBackoffMultiplier(providerCfg.llm_retry_backoff_multiplier);
     const maxDelayMs = resolveRetryMaxDelayMs(providerCfg.llm_retry_max_delay_ms);
     return {
-        maxRetries,
+        aggressiveMaxRetries,
         initialDelayMs,
         conservativeDelayMs: Math.max(initialDelayMs, conservativeDelayMs),
         backoffMultiplier,
@@ -1584,7 +1584,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 modelId: model,
                                 providerConfig: providerCfg,
                                 abortSignal,
-                                maxRetries: retryPolicy.maxRetries,
+                                aggressiveRetryMaxRetries: retryPolicy.aggressiveMaxRetries,
                                 retryInitialDelayMs: retryPolicy.initialDelayMs,
                                 retryConservativeDelayMs: retryPolicy.conservativeDelayMs,
                                 retryBackoffMultiplier: retryPolicy.backoffMultiplier,
@@ -1792,7 +1792,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             modelId: model,
                             providerConfig: providerCfg,
                             abortSignal,
-                            maxRetries: retryPolicy.maxRetries,
+                            aggressiveRetryMaxRetries: retryPolicy.aggressiveMaxRetries,
                             retryInitialDelayMs: retryPolicy.initialDelayMs,
                             retryConservativeDelayMs: retryPolicy.conservativeDelayMs,
                             retryBackoffMultiplier: retryPolicy.backoffMultiplier,

package/dist/llm/kernel-driver/runtime.d.ts

@@ -56,7 +56,7 @@ export declare function runLlmRequestWithRetry<T>(params: {
     modelId: string;
     providerConfig: ProviderConfig;
     abortSignal?: AbortSignal;
-    maxRetries: number;
+    aggressiveRetryMaxRetries: number;
     retryInitialDelayMs: number;
     retryConservativeDelayMs: number;
     retryBackoffMultiplier: number;