dominds 1.15.5 → 1.16.1

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

@@ -16,7 +16,7 @@
  *   so multi-tab views converge without polling.
  */
 import type { DialogDisplayState, DialogInterruptionReason } from '@longrun-ai/kernel/types/display-state';
-import type { DialogExecutionMarker } from '@longrun-ai/kernel/types/storage';
+import type { DialogExecutionMarker, DialogLatestFile } from '@longrun-ai/kernel/types/storage';
 import type { WebSocketMessage } from '@longrun-ai/kernel/types/wire';
 import { DialogID, type Dialog } from './dialog';
 type StopRequestedReason = 'user_stop' | 'emergency_stop';
@@ -25,6 +25,10 @@ export type RunControlCountsSnapshot = {
     resumable: number;
 };
 export declare function setDisplayStateBroadcaster(fn: (msg: WebSocketMessage) => void): void;
+export declare function isStoppedReasonResumable(reason: DialogInterruptionReason): boolean;
+export declare function isDisplayStateResumable(state: DialogDisplayState | undefined): boolean;
+export declare function isExecutionMarkerResumable(executionMarker: DialogExecutionMarker | undefined): boolean;
+export declare function isDialogLatestResumable(latest: DialogLatestFile | null | undefined): boolean;
 export declare function getRunControlCountsSnapshot(): Promise<RunControlCountsSnapshot>;
 export declare function broadcastRunControlCountsSnapshot(): Promise<void>;
 export declare function hasActiveRun(dialogId: DialogID): boolean;

package/dist/dialog-display-state.js

@@ -18,6 +18,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setDisplayStateBroadcaster = setDisplayStateBroadcaster;
+exports.isStoppedReasonResumable = isStoppedReasonResumable;
+exports.isDisplayStateResumable = isDisplayStateResumable;
+exports.isExecutionMarkerResumable = isExecutionMarkerResumable;
+exports.isDialogLatestResumable = isDialogLatestResumable;
 exports.getRunControlCountsSnapshot = getRunControlCountsSnapshot;
 exports.broadcastRunControlCountsSnapshot = broadcastRunControlCountsSnapshot;
 exports.hasActiveRun = hasActiveRun;
@@ -58,13 +62,27 @@ function syncRunControlCountsAfterActiveRunChange(trigger, dialogId) {
         }
     })();
 }
+function isStoppedReasonResumable(reason) {
+    return reason.kind !== 'llm_retry_stopped';
+}
+function isDisplayStateResumable(state) {
+    return state?.kind === 'stopped' && state.continueEnabled;
+}
+function isExecutionMarkerResumable(executionMarker) {
+    return (executionMarker?.kind === 'interrupted' && isStoppedReasonResumable(executionMarker.reason));
+}
+function isDialogLatestResumable(latest) {
+    return (latest?.displayState?.kind === 'stopped' &&
+        latest.displayState.continueEnabled &&
+        latest.executionMarker?.kind === 'interrupted');
+}
 function classifyRunControlBucket(state) {
     if (!state)
         return 'none';
     if (state.kind === 'proceeding' || state.kind === 'proceeding_stop_requested') {
         return 'proceeding';
     }
-    if (state.kind === 'interrupted') {
+    if (isDisplayStateResumable(state)) {
         return 'resumable';
     }
     return 'none';
@@ -91,7 +109,7 @@ async function getRunControlCountsSnapshot() {
         if (latest?.generating === true) {
             proceeding++;
         }
-        else if (latest?.executionMarker?.kind === 'interrupted') {
+        else if (isDialogLatestResumable(latest)) {
             resumable++;
         }
     }
@@ -219,7 +237,7 @@ async function setDialogDisplayState(dialogId, displayState) {
             dialogId: dialogId.valueOf(),
         });
     }
-    const nextExecutionMarker = displayState.kind === 'interrupted'
+    const nextExecutionMarker = displayState.kind === 'stopped'
         ? { kind: 'interrupted', reason: displayState.reason }
         : displayState.kind === 'dead'
             ? { kind: 'dead', reason: displayState.reason }
@@ -270,7 +288,7 @@ function broadcastDisplayStateMarker(dialogId, marker) {
 }
 async function computeIdleDisplayState(dlg) {
     if (dlg.status === 'completed' || dlg.status === 'archived') {
-        return { kind: 'terminal', status: dlg.status };
+        return { kind: 'idle_waiting_user' };
     }
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(dlg.id, 'running');
     if (dlg.id.selfId !== dlg.id.rootId &&
@@ -279,7 +297,11 @@ async function computeIdleDisplayState(dlg) {
         return { kind: 'dead', reason: latest.executionMarker.reason };
     }
     if (latest?.executionMarker?.kind === 'interrupted') {
-        return { kind: 'interrupted', reason: latest.executionMarker.reason };
+        return {
+            kind: 'stopped',
+            reason: latest.executionMarker.reason,
+            continueEnabled: isStoppedReasonResumable(latest.executionMarker.reason),
+        };
     }
     const hasQ4H = await dlg.hasPendingQ4H();
     const hasSubdialogs = await dlg.hasPendingSubdialogs();
@@ -298,7 +320,7 @@ async function computeIdleDisplayStateFromPersistence(dialogId) {
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, 'running');
     const status = latest?.status;
     if (status === 'completed' || status === 'archived') {
-        return { kind: 'terminal', status };
+        return { kind: 'idle_waiting_user' };
     }
     if (dialogId.selfId !== dialogId.rootId &&
         latest &&
@@ -307,7 +329,11 @@ async function computeIdleDisplayStateFromPersistence(dialogId) {
         return { kind: 'dead', reason: latest.executionMarker.reason };
     }
     if (latest?.executionMarker?.kind === 'interrupted') {
-        return { kind: 'interrupted', reason: latest.executionMarker.reason };
+        return {
+            kind: 'stopped',
+            reason: latest.executionMarker.reason,
+            continueEnabled: isStoppedReasonResumable(latest.executionMarker.reason),
+        };
     }
     const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
     const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, 'running');
@@ -358,8 +384,9 @@ async function reconcileDisplayStatesAfterRestart() {
             const next = nextIdle.kind === 'blocked'
                 ? nextIdle
                 : {
-                    kind: 'interrupted',
+                    kind: 'stopped',
                     reason: { kind: 'server_restart' },
+                    continueEnabled: true,
                 };
             try {
                 await persistence_1.DialogPersistence.mutateDialogLatest(dialogId, () => ({
@@ -367,9 +394,7 @@ async function reconcileDisplayStatesAfterRestart() {
                     patch: {
                         generating: false,
                         displayState: next,
-                        executionMarker: next.kind === 'interrupted'
-                            ? { kind: 'interrupted', reason: next.reason }
-                            : undefined,
+                        executionMarker: next.kind === 'stopped' ? { kind: 'interrupted', reason: next.reason } : undefined,
                     },
                 }));
             }

package/dist/dialog-fork.js

@@ -245,7 +245,7 @@ function computeRootForkDisplayState(args) {
     if (hasSubdialogs) {
         return { kind: 'blocked', reason: { kind: 'waiting_for_subdialogs' } };
     }
-    return { kind: 'interrupted', reason: { kind: 'system_stop', detail: 'fork_dialog_continue' } };
+    return { kind: 'stopped', reason: { kind: 'fork_continue_ready' }, continueEnabled: true };
 }
 async function copyArtifactsIfPresent(sourceId, targetId, sourceStatus) {
     const sourceDir = node_path_1.default.join(persistence_1.DialogPersistence.getDialogEventsPath(sourceId, sourceStatus), 'artifacts');

package/dist/llm/api-quirks.d.ts

@@ -0,0 +1,35 @@
+import type { LanguageCode } from '@longrun-ai/kernel/types/language';
+import type { ProviderConfig } from './client';
+import type { LlmRetryStrategy } from './gen';
+export type LlmFailureKind = 'retriable' | 'rejected' | 'fatal';
+export type LlmFailureSummary = {
+    kind: LlmFailureKind;
+    message: string;
+    status?: number;
+    code?: string;
+};
+export type LlmQuirkFailureHandling = {
+    kind: 'default';
+} | {
+    kind: 'give_up';
+    message?: string;
+    summaryTextI18n?: Partial<Record<LanguageCode, string>>;
+} | {
+    kind: 'retry_strategy';
+    retryStrategy: LlmRetryStrategy;
+    message?: string;
+} | {
+    kind: 'single_retry';
+    delayMs: number;
+    message?: string;
+};
+export type LlmFailureQuirkHandlerSession = {
+    onFailure: (args: {
+        provider: string;
+        providerConfig: ProviderConfig;
+        failure: LlmFailureSummary;
+        error: unknown;
+    }) => LlmQuirkFailureHandling;
+};
+export declare function normalizeProviderApiQuirks(providerConfig: ProviderConfig): Set<string>;
+export declare function createLlmFailureQuirkHandlerSession(providerConfig: ProviderConfig): LlmFailureQuirkHandlerSession | undefined;

package/dist/llm/api-quirks.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeProviderApiQuirks = normalizeProviderApiQuirks;
+exports.createLlmFailureQuirkHandlerSession = createLlmFailureQuirkHandlerSession;
+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;
+function createXcodeBestFailureQuirkHandlerSession(providerConfig) {
+    let consecutiveEmptyResponseCount = 0;
+    return {
+        onFailure(args) {
+            if (args.failure.code !== DOMINDS_LLM_EMPTY_RESPONSE_ERROR_CODE) {
+                consecutiveEmptyResponseCount = 0;
+                return { kind: 'default' };
+            }
+            consecutiveEmptyResponseCount += 1;
+            if (consecutiveEmptyResponseCount < XCODE_BEST_EMPTY_RESPONSE_GIVE_UP_THRESHOLD) {
+                return {
+                    kind: 'single_retry',
+                    delayMs: XCODE_BEST_EMPTY_RESPONSE_SINGLE_RETRY_DELAY_MS,
+                };
+            }
+            const providerName = providerConfig.name.trim().length > 0 ? providerConfig.name : args.provider;
+            const summaryTextI18n = {
+                zh: `${providerName} 在同一对话上下文中连续返回 empty response。` +
+                    `Dominds 已在 ${String(XCODE_BEST_EMPTY_RESPONSE_GIVE_UP_THRESHOLD)} 次 empty response 后停止继续重试，因为这通常表示 provider 侧该对话上下文已经卡住；` +
+                    '继续调整常规重试策略也无助于恢复。请新开对话继续。',
+                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; adjusting the normal retry policies will not recover it. ' +
+                    'Start a new dialog to continue.',
+            };
+            return {
+                kind: 'give_up',
+                message: `${providerName} returned empty responses repeatedly for the same dialog context; ` +
+                    'automatic retries will not help until a new dialog is started.',
+                summaryTextI18n,
+            };
+        },
+    };
+}
+const FAILURE_QUIRK_HANDLER_FACTORIES = {
+    'xcode.best': createXcodeBestFailureQuirkHandlerSession,
+};
+function normalizeProviderApiQuirks(providerConfig) {
+    const raw = providerConfig.apiQuirks;
+    if (typeof raw === 'string') {
+        return raw.trim().length > 0 ? new Set([raw.trim()]) : new Set();
+    }
+    if (Array.isArray(raw)) {
+        return new Set(raw.flatMap((entry) => {
+            if (typeof entry !== 'string')
+                return [];
+            const trimmed = entry.trim();
+            return trimmed === '' ? [] : [trimmed];
+        }));
+    }
+    return new Set();
+}
+function createLlmFailureQuirkHandlerSession(providerConfig) {
+    const sessions = [];
+    for (const quirk of normalizeProviderApiQuirks(providerConfig)) {
+        const factory = FAILURE_QUIRK_HANDLER_FACTORIES[quirk];
+        if (!factory)
+            continue;
+        sessions.push(factory(providerConfig));
+    }
+    if (sessions.length === 0) {
+        return undefined;
+    }
+    return {
+        onFailure(args) {
+            for (const session of sessions) {
+                const handling = session.onFailure(args);
+                if (handling.kind !== 'default') {
+                    return handling;
+                }
+            }
+            return { kind: 'default' };
+        },
+    };
+}

package/dist/llm/defaults.yaml

@@ -5,7 +5,9 @@
 # - llm_retry_backoff_multiplier: exponential factor between retries (default 1.5).
 # - llm_retry_max_delay_ms: upper bound for retry delay (default 1800000 / 30m).
 # - apiQuirks: optional provider/gateway quirk profile(s) for non-standard transport behavior
-#   and retry classification. Example: `apiQuirks: xcode.best`.
+#   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.
 # - 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

@@ -1,3 +1,10 @@
 import type { LlmFailureDisposition } from '../gen';
+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

@@ -1,5 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+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;
 function isPlainObject(value) {
@@ -11,6 +18,12 @@ function readNestedError(error) {
     }
     return error.error;
 }
+function readNestedResponse(error) {
+    if (!isPlainObject(error) || !('response' in error) || !isPlainObject(error.response)) {
+        return undefined;
+    }
+    return error.response;
+}
 function readErrorStatus(error) {
     if (isPlainObject(error)) {
         if ('status' in error && typeof error.status === 'number') {
@@ -79,6 +92,96 @@ function readErrorMessage(error) {
     }
     return undefined;
 }
+function readErrorHeaders(error) {
+    if (isPlainObject(error) && 'headers' in error && isPlainObject(error.headers)) {
+        return error.headers;
+    }
+    const nested = readNestedError(error);
+    if (nested && 'headers' in nested && isPlainObject(nested.headers)) {
+        return nested.headers;
+    }
+    const response = readNestedResponse(error);
+    if (response && 'headers' in response && isPlainObject(response.headers)) {
+        return response.headers;
+    }
+    return undefined;
+}
+function readHeaderValue(headers, headerName) {
+    const target = headerName.toLowerCase();
+    for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() === target) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function parseRetryAfterHeaderMs(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return Math.max(0, Math.floor(value * 1000));
+    }
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    if (trimmed === '')
+        return undefined;
+    const numeric = Number(trimmed);
+    if (Number.isFinite(numeric)) {
+        return Math.max(0, Math.floor(numeric * 1000));
+    }
+    const parsedDateMs = Date.parse(trimmed);
+    if (!Number.isFinite(parsedDateMs))
+        return undefined;
+    return Math.max(0, parsedDateMs - Date.now());
+}
+function parseDelayFieldMs(value, unit) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        const ms = unit === 'seconds' ? value * 1000 : value;
+        return Math.max(0, Math.floor(ms));
+    }
+    if (typeof value !== 'string')
+        return undefined;
+    const numeric = Number(value.trim());
+    if (!Number.isFinite(numeric))
+        return undefined;
+    const ms = unit === 'seconds' ? numeric * 1000 : numeric;
+    return Math.max(0, Math.floor(ms));
+}
+function readProviderSuggestedRetryAfterMs(error) {
+    const headers = readErrorHeaders(error);
+    if (headers) {
+        const retryAfter = parseRetryAfterHeaderMs(readHeaderValue(headers, 'retry-after'));
+        if (retryAfter !== undefined)
+            return retryAfter;
+        const resetAfter = parseDelayFieldMs(readHeaderValue(headers, 'x-ratelimit-reset-after'), 'seconds') ??
+            parseDelayFieldMs(readHeaderValue(headers, 'ratelimit-reset-after'), 'seconds');
+        if (resetAfter !== undefined)
+            return resetAfter;
+    }
+    const roots = [];
+    if (isPlainObject(error))
+        roots.push(error);
+    const nested = readNestedError(error);
+    if (nested)
+        roots.push(nested);
+    const response = readNestedResponse(error);
+    if (response)
+        roots.push(response);
+    for (const root of roots) {
+        const retryAfterMs = parseDelayFieldMs(root.retryAfterMs, 'milliseconds') ??
+            parseDelayFieldMs(root.retry_after_ms, 'milliseconds') ??
+            parseDelayFieldMs(root.resetAfterMs, 'milliseconds') ??
+            parseDelayFieldMs(root.reset_after_ms, 'milliseconds');
+        if (retryAfterMs !== undefined)
+            return retryAfterMs;
+        const retryAfterSeconds = parseDelayFieldMs(root.retryAfter, 'seconds') ??
+            parseDelayFieldMs(root.retry_after, 'seconds') ??
+            parseDelayFieldMs(root.resetAfter, 'seconds') ??
+            parseDelayFieldMs(root.reset_after, 'seconds');
+        if (retryAfterSeconds !== undefined)
+            return retryAfterSeconds;
+    }
+    return undefined;
+}
 function buildFailureMessage(error) {
     return readErrorMessage(error) ?? 'Unknown LLM provider error.';
 }
@@ -110,6 +213,29 @@ function isConservativeRetryMessage(lowerMessage) {
     }
     return lowerMessage.includes('overloaded') && lowerMessage.includes('try again later');
 }
+function isOpenAiLikeOverloadFailure(error) {
+    const lowerMessage = buildFailureMessage(error).toLowerCase();
+    const status = readErrorStatus(error);
+    return status === 503 || status === 529 || isConservativeRetryMessage(lowerMessage);
+}
+function isOpenAiLikeRateLimitFailure(error) {
+    const lowerMessage = buildFailureMessage(error).toLowerCase();
+    const status = readErrorStatus(error);
+    const code = readErrorCode(error)?.toLowerCase();
+    if (status === 429) {
+        return true;
+    }
+    if (typeof code === 'string' && code.includes('rate_limit')) {
+        return true;
+    }
+    if (lowerMessage.includes('rate limit')) {
+        return true;
+    }
+    if (lowerMessage.includes('requests per min')) {
+        return true;
+    }
+    return lowerMessage.includes('rpm') && lowerMessage.includes('limit');
+}
 function classifyOpenAiLikeFailure(error) {
     const message = buildFailureMessage(error);
     const lowerMessage = message.toLowerCase();
@@ -132,7 +258,7 @@ function classifyOpenAiLikeFailure(error) {
             retryStrategy: 'aggressive',
         };
     }
-    if (status === 503 || status === 529 || isConservativeRetryMessage(lowerMessage)) {
+    if (isOpenAiLikeOverloadFailure(error)) {
         return {
             kind: 'retriable',
             message,
@@ -141,6 +267,16 @@ function classifyOpenAiLikeFailure(error) {
             retryStrategy: 'conservative',
         };
     }
+    if (isOpenAiLikeRateLimitFailure(error)) {
+        return {
+            kind: 'retriable',
+            message,
+            status,
+            code,
+            retryStrategy: 'smart_rate',
+            retryAfterMs: readProviderSuggestedRetryAfterMs(error),
+        };
+    }
     if (isOpenAiRetriableProcessingFailureMessage(lowerMessage)) {
         return {
             kind: 'retriable',

package/dist/llm/gen/openai.js

@@ -16,6 +16,7 @@ const openai_1 = __importDefault(require("openai"));
 const log_1 = require("../../log");
 const i18n_text_1 = require("../../runtime/i18n-text");
 const work_language_1 = require("../../runtime/work-language");
+const api_quirks_1 = require("../api-quirks");
 const artifacts_1 = require("./artifacts");
 const failure_classifier_1 = require("./failure-classifier");
 const tool_call_context_1 = require("./tool-call-context");
@@ -86,19 +87,9 @@ function readEventType(value) {
     }
     return value.type;
 }
-function normalizeProviderApiQuirks(providerConfig) {
-    const raw = providerConfig.apiQuirks;
-    if (typeof raw === 'string') {
-        return raw.trim().length > 0 ? new Set([raw.trim()]) : new Set();
-    }
-    if (Array.isArray(raw)) {
-        return new Set(raw.filter((entry) => typeof entry === 'string' && entry.trim() !== ''));
-    }
-    return new Set();
-}
 function resolveOpenAiVendorHeartbeatEventTypes(providerConfig) {
     const eventTypes = new Set();
-    for (const quirk of normalizeProviderApiQuirks(providerConfig)) {
+    for (const quirk of (0, api_quirks_1.normalizeProviderApiQuirks)(providerConfig)) {
         const vendorEventTypes = OPENAI_API_QUIRK_VENDOR_HEARTBEAT_EVENT_TYPES[quirk];
         if (!vendorEventTypes)
             continue;
@@ -109,7 +100,7 @@ function resolveOpenAiVendorHeartbeatEventTypes(providerConfig) {
     return eventTypes;
 }
 function maybeAnnotateOpenAiQuirkFailure(providerConfig, error) {
-    const quirks = normalizeProviderApiQuirks(providerConfig);
+    const quirks = (0, api_quirks_1.normalizeProviderApiQuirks)(providerConfig);
     const message = error instanceof Error
         ? error.message
         : typeof error === 'string'

package/dist/llm/gen.d.ts

@@ -23,13 +23,14 @@ export interface LlmBatchResult {
     usage: LlmUsageStats;
     llmGenModel?: string;
 }
-export type LlmRetryStrategy = 'aggressive' | 'conservative';
+export type LlmRetryStrategy = 'aggressive' | 'conservative' | 'smart_rate';
 export type LlmFailureDisposition = {
     kind: 'retriable' | 'rejected' | 'fatal';
     message: string;
     status?: number;
     code?: string;
     retryStrategy?: LlmRetryStrategy;
+    retryAfterMs?: number;
 };
 export type LlmFailureClassifier = (error: unknown) => LlmFailureDisposition | undefined;
 export interface LlmRequestContext {