dominds 1.15.4 → 1.16.0

package/dist/apps/assigned-port.d.ts

@@ -1,4 +1,4 @@
-import type { DomindsAppInstallJsonV1 } from '@longrun-ai/kernel/app-json';
+import type { DomindsAppInstallJson } from '@longrun-ai/kernel/app-json';
 import type { AppsResolutionEntry } from './resolution-file';
 export type AssignedPortResolutionReason = 'no_frontend' | 'kept_existing' | 'selected_default' | 'allocated_stable_range' | 'reassigned_from_existing_conflict' | 'reassigned_from_existing_unbindable';
 export type AssignedPortResolution = Readonly<{
@@ -16,13 +16,13 @@ export type AssignedPortResolution = Readonly<{
  */
 export declare function resolveStableAssignedPort(params: {
     appId: string;
-    installJson: DomindsAppInstallJsonV1;
+    installJson: DomindsAppInstallJson;
     existingApps: ReadonlyArray<AppsResolutionEntry>;
     existingAssignedPort: number | null;
 }): Promise<number | null>;
 export declare function resolveStableAssignedPortWithReason(params: {
     appId: string;
-    installJson: DomindsAppInstallJsonV1;
+    installJson: DomindsAppInstallJson;
     existingApps: ReadonlyArray<AppsResolutionEntry>;
     existingAssignedPort: number | null;
 }): Promise<AssignedPortResolution>;

package/dist/apps/resolution-file.d.ts

@@ -1,4 +1,4 @@
-import { type DomindsAppInstallJsonV1 } from '@longrun-ai/kernel/app-json';
+import { type DomindsAppInstallJson } from '@longrun-ai/kernel/app-json';
 export type AppsResolutionSchemaVersion = 1;
 export type AppsResolutionSource = Readonly<{
     kind: 'npx';
@@ -12,7 +12,7 @@ export type AppsResolutionEntry = Readonly<{
     enabled: boolean;
     source: AppsResolutionSource;
     assignedPort: number | null;
-    installJson: DomindsAppInstallJsonV1;
+    installJson: DomindsAppInstallJson;
 }>;
 export type AppsResolutionFile = Readonly<{
     schemaVersion: AppsResolutionSchemaVersion;

package/dist/apps/run-app-json.d.ts

@@ -1,8 +1,8 @@
-import { type DomindsAppInstallJsonV1 } from '@longrun-ai/kernel/app-json';
+import { type DomindsAppInstallJson } from '@longrun-ai/kernel/app-json';
 export declare function runDomindsAppJsonViaNpx(params: {
     spec: string;
     cwdAbs: string;
-}): Promise<DomindsAppInstallJsonV1>;
+}): Promise<DomindsAppInstallJson>;
 export declare function runDomindsAppJsonViaLocalPackage(params: {
     packageRootAbs: string;
-}): Promise<DomindsAppInstallJsonV1>;
+}): Promise<DomindsAppInstallJson>;

package/dist/apps-host/client.d.ts

@@ -1,12 +1,12 @@
 import type { DomindsAppDynamicToolsetsContext, DomindsAppReminderOwnerApplyContext, DomindsAppReminderOwnerRenderContext, DomindsAppReminderOwnerUpdateContext, DomindsAppRunControlContext, DomindsAppRunControlResult } from '@longrun-ai/kernel/app-host-contract';
-import type { DomindsAppHostReminderUpdateResult, DomindsAppHostToolResult, DomindsAppInstallJsonV1, DomindsAppReminderApplyRequest, DomindsAppReminderApplyResult } from '@longrun-ai/kernel/app-json';
+import type { DomindsAppHostReminderUpdateResult, DomindsAppHostToolResult, DomindsAppInstallJson, DomindsAppReminderApplyRequest, DomindsAppReminderApplyResult } from '@longrun-ai/kernel/app-json';
 import type { ChatMessage } from '../llm/client';
 import type { ToolArguments } from '../tool';
 import type { AppsHostMessageToKernel } from './ipc-types';
 export type EnabledAppForHost = Readonly<{
     appId: string;
     runtimePort: number | null;
-    installJson: DomindsAppInstallJsonV1;
+    installJson: DomindsAppInstallJson;
     hostSourceVersion: string | null;
 }>;
 export type AppsHostClient = Readonly<{

package/dist/apps-host/host.js

@@ -33,12 +33,14 @@ function isStringArray(value) {
     return Array.isArray(value) && value.every((item) => typeof item === 'string');
 }
 function isToolCallOutput(value) {
-    if (typeof value === 'string')
-        return true;
     if (!isRecord(value))
         return false;
     if (typeof value['content'] !== 'string')
         return false;
+    const outcome = value['outcome'];
+    if (outcome !== 'success' && outcome !== 'failure' && outcome !== 'partial_failure') {
+        return false;
+    }
     const contentItems = value['contentItems'];
     return contentItems === undefined || Array.isArray(contentItems);
 }
@@ -183,15 +185,12 @@ function isChatMessage(value) {
     return true;
 }
 function normalizeToolResult(value) {
-    if (isToolCallOutput(value)) {
-        return { output: value };
-    }
     if (!isRecord(value)) {
-        throw new Error('Invalid app tool result: expected ToolCallOutput or structured object');
+        throw new Error('Invalid app tool result: expected { output: { content, outcome, contentItems? }, ... }');
     }
     const output = value['output'];
     if (!isToolCallOutput(output)) {
-        throw new Error('Invalid app tool result: output must be ToolCallOutput');
+        throw new Error('Invalid app tool result: output must be { content, outcome, contentItems? }');
     }
     const reminderRequestsRaw = value['reminderRequests'];
     if (reminderRequestsRaw !== undefined && !Array.isArray(reminderRequestsRaw)) {

package/dist/apps-host/ipc-types.d.ts

@@ -1,5 +1,5 @@
 import type { DomindsAppRunControlResult } from '@longrun-ai/kernel/app-host-contract';
-import type { DomindsAppDialogReminderRequestBatch, DomindsAppHostReminderUpdateResult, DomindsAppInstallJsonV1, DomindsAppReminderApplyRequest, DomindsAppReminderApplyResult, DomindsAppReminderState } from '@longrun-ai/kernel/app-json';
+import type { DomindsAppDialogReminderRequestBatch, DomindsAppHostReminderUpdateResult, DomindsAppInstallJson, DomindsAppReminderApplyRequest, DomindsAppReminderApplyResult, DomindsAppReminderState } from '@longrun-ai/kernel/app-json';
 import type { LanguageCode } from '@longrun-ai/kernel/types/language';
 import type { ChatMessage } from '../llm/client';
 import type { ToolArguments, ToolCallOutput } from '../tool';
@@ -13,7 +13,7 @@ export type AppsHostKernelInitMessage = Readonly<{
     apps: ReadonlyArray<Readonly<{
         appId: string;
         runtimePort: number | null;
-        installJson: DomindsAppInstallJsonV1;
+        installJson: DomindsAppInstallJson;
     }>>;
 }>;
 export type AppsHostKernelToolCallMessage = Readonly<{

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

@@ -25,6 +25,9 @@ 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 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,9 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setDisplayStateBroadcaster = setDisplayStateBroadcaster;
+exports.isStoppedReasonResumable = isStoppedReasonResumable;
+exports.isDisplayStateResumable = isDisplayStateResumable;
+exports.isExecutionMarkerResumable = isExecutionMarkerResumable;
 exports.getRunControlCountsSnapshot = getRunControlCountsSnapshot;
 exports.broadcastRunControlCountsSnapshot = broadcastRunControlCountsSnapshot;
 exports.hasActiveRun = hasActiveRun;
@@ -58,13 +61,22 @@ 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 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 +103,7 @@ async function getRunControlCountsSnapshot() {
         if (latest?.generating === true) {
             proceeding++;
         }
-        else if (latest?.executionMarker?.kind === 'interrupted') {
+        else if (isExecutionMarkerResumable(latest?.executionMarker)) {
             resumable++;
         }
     }
@@ -219,7 +231,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 +282,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 +291,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 +314,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 +323,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 +378,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 +388,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/docs/app-constitution.md

@@ -222,7 +222,7 @@ Recommended user mental model:
 
 (Current: implemented) existing anchors:
 
-- JSON schema: `dominds/main/apps/app-json.ts` (`DomindsAppInstallJsonV1`).
+- JSON schema: `dominds/main/apps/app-json.ts` (`DomindsAppInstallJson`).
 - Apps configuration file: `dominds/main/apps/configuration-file.ts`.
 - Apps resolution file: `dominds/main/apps/resolution-file.ts`.
 

package/dist/docs/app-constitution.zh.md

@@ -221,7 +221,7 @@ Install JSON 是 app 与 Kernel/CLI 之间的**安装/运行握手载荷**。它
 
 （现状：已实现）install json schema 与 apps 配置/解析锚点仍可参考：
 
-- JSON schema：`dominds/main/apps/app-json.ts`（`DomindsAppInstallJsonV1`）。
+- JSON schema：`dominds/main/apps/app-json.ts`（`DomindsAppInstallJson`）。
 - `.apps/configuration.yaml`：`dominds/main/apps/configuration-file.ts`。
 - `.apps/resolution.yaml`：`dominds/main/apps/resolution-file.ts`。
 

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 {