dominds 1.12.2 → 1.13.1

package/dist/llm/client.d.ts

@@ -57,6 +57,7 @@ export type ProviderConfig = {
     tool_result_max_chars?: number;
     llm_retry_max_retries?: number;
     llm_retry_initial_delay_ms?: number;
+    llm_retry_conservative_delay_ms?: number;
     llm_retry_backoff_multiplier?: number;
     llm_retry_max_delay_ms?: number;
     tech_spec_url?: string;

package/dist/llm/defaults.yaml

@@ -1,6 +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_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).
 # - llm_retry_max_delay_ms: upper bound for retry delay (default 1800000 / 30m).
 # - tool_result_max_chars: optional transport-level cap for a single tool-result text payload

package/dist/llm/gen/anthropic.d.ts

@@ -3,7 +3,7 @@ import type { LlmUsageStats } from '@longrun-ai/kernel/types/context-health';
 import type { Team } from '../../team';
 import type { FuncTool } from '../../tool';
 import type { ChatMessage, ProviderConfig } from '../client';
-import type { LlmBatchResult, LlmGenerator, LlmRequestContext, LlmStreamReceiver, LlmStreamResult } from '../gen';
+import type { LlmBatchResult, LlmFailureDisposition, LlmGenerator, LlmRequestContext, LlmStreamReceiver, LlmStreamResult } from '../gen';
 export type AnthropicStreamConsumeResult = {
     usage: LlmUsageStats;
     llmGenModel?: string;
@@ -28,6 +28,7 @@ export declare function reconstructAnthropicContextWrapperAsync(persistedMessage
  */
 export declare class AnthropicGen implements LlmGenerator {
     get apiType(): string;
+    classifyFailure(error: unknown): LlmFailureDisposition | undefined;
     genToReceiver(providerConfig: ProviderConfig, agent: Team.Member, systemPrompt: string, funcTools: FuncTool[], _requestContext: LlmRequestContext, context: ChatMessage[], receiver: LlmStreamReceiver, _genseq: number, abortSignal?: AbortSignal): Promise<LlmStreamResult>;
     genMoreMessages(providerConfig: ProviderConfig, agent: Team.Member, systemPrompt: string, funcTools: FuncTool[], _requestContext: LlmRequestContext, context: ChatMessage[], genseq: number, abortSignal?: AbortSignal): Promise<LlmBatchResult>;
 }

package/dist/llm/gen/anthropic.js

@@ -15,6 +15,7 @@ const log_1 = require("../../log");
 const i18n_text_1 = require("../../runtime/i18n-text");
 const work_language_1 = require("../../runtime/work-language");
 const artifacts_1 = require("./artifacts");
+const failure_classifier_1 = require("./failure-classifier");
 const tool_call_context_1 = require("./tool-call-context");
 const tool_output_limit_1 = require("./tool-output-limit");
 const log = (0, log_1.createLogger)('llm/anthropic');
@@ -822,6 +823,9 @@ class AnthropicGen {
     get apiType() {
         return 'anthropic';
     }
+    classifyFailure(error) {
+        return (0, failure_classifier_1.classifyAnthropicFailure)(error);
+    }
     async genToReceiver(providerConfig, agent, systemPrompt, funcTools, _requestContext, context, receiver, _genseq, abortSignal) {
         const apiKey = process.env[providerConfig.apiKeyEnvVar];
         if (!apiKey)

package/dist/llm/gen/codex.d.ts

@@ -7,10 +7,11 @@ import type { ChatGptResponsesRequest } from '@longrun-ai/codex-auth';
 import type { Team } from '../../team';
 import type { FuncTool } from '../../tool';
 import type { ChatMessage, ProviderConfig } from '../client';
-import type { LlmBatchResult, LlmGenerator, LlmRequestContext, LlmStreamReceiver, LlmStreamResult } from '../gen';
+import type { LlmBatchResult, LlmFailureDisposition, LlmGenerator, LlmRequestContext, LlmStreamReceiver, LlmStreamResult } from '../gen';
 export declare function resolveCodexServiceTier(serviceTier: ChatGptResponsesRequest['service_tier'] | undefined): Exclude<NonNullable<ChatGptResponsesRequest['service_tier']>, 'default'> | undefined;
 export declare class CodexGen implements LlmGenerator {
     get apiType(): string;
+    classifyFailure(error: unknown): LlmFailureDisposition | undefined;
     genToReceiver(providerConfig: ProviderConfig, agent: Team.Member, systemPrompt: string, funcTools: FuncTool[], requestContext: LlmRequestContext, context: ChatMessage[], receiver: LlmStreamReceiver, _genseq: number, abortSignal?: AbortSignal): Promise<LlmStreamResult>;
     genMoreMessages(_providerConfig: ProviderConfig, _agent: Team.Member, _systemPrompt: string, _funcTools: FuncTool[], _requestContext: LlmRequestContext, _context: ChatMessage[], _genseq: number): Promise<LlmBatchResult>;
 }

package/dist/llm/gen/codex.js

@@ -39,6 +39,7 @@ const log_1 = require("../../log");
 const i18n_text_1 = require("../../runtime/i18n-text");
 const work_language_1 = require("../../runtime/work-language");
 const artifacts_1 = require("./artifacts");
+const failure_classifier_1 = require("./failure-classifier");
 const tool_call_context_1 = require("./tool-call-context");
 const tool_output_limit_1 = require("./tool-output-limit");
 const log = (0, log_1.createLogger)('llm/codex');
@@ -443,6 +444,9 @@ class CodexGen {
     get apiType() {
         return 'codex';
     }
+    classifyFailure(error) {
+        return (0, failure_classifier_1.classifyOpenAiLikeFailure)(error);
+    }
     async genToReceiver(providerConfig, agent, systemPrompt, funcTools, requestContext, context, receiver, _genseq, abortSignal) {
         const codexHomeValue = process.env[providerConfig.apiKeyEnvVar] || '~/.codex';
         const codexHome = codexHomeValue.startsWith('~')

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

@@ -0,0 +1,3 @@
+import type { LlmFailureDisposition } from '../gen';
+export declare function classifyOpenAiLikeFailure(error: unknown): LlmFailureDisposition | undefined;
+export declare function classifyAnthropicFailure(error: unknown): LlmFailureDisposition | undefined;

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

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyOpenAiLikeFailure = classifyOpenAiLikeFailure;
+exports.classifyAnthropicFailure = classifyAnthropicFailure;
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function readNestedError(error) {
+    if (!isPlainObject(error) || !('error' in error) || !isPlainObject(error.error)) {
+        return undefined;
+    }
+    return error.error;
+}
+function readErrorStatus(error) {
+    if (isPlainObject(error)) {
+        if ('status' in error && typeof error.status === 'number') {
+            return error.status;
+        }
+        if ('statusCode' in error && typeof error.statusCode === 'number') {
+            return error.statusCode;
+        }
+    }
+    const nested = readNestedError(error);
+    if (!nested) {
+        return undefined;
+    }
+    if ('status' in nested && typeof nested.status === 'number') {
+        return nested.status;
+    }
+    if ('statusCode' in nested && typeof nested.statusCode === 'number') {
+        return nested.statusCode;
+    }
+    return undefined;
+}
+function readErrorCode(error) {
+    if (isPlainObject(error)) {
+        if ('code' in error && typeof error.code === 'string') {
+            return error.code;
+        }
+        if ('errno' in error && typeof error.errno === 'string') {
+            return error.errno;
+        }
+    }
+    const nested = readNestedError(error);
+    if (nested && 'code' in nested && typeof nested.code === 'string') {
+        return nested.code;
+    }
+    return undefined;
+}
+function readErrorType(error) {
+    if (isPlainObject(error) && 'type' in error && typeof error.type === 'string') {
+        return error.type;
+    }
+    const nested = readNestedError(error);
+    if (nested && 'type' in nested && typeof nested.type === 'string') {
+        return nested.type;
+    }
+    return undefined;
+}
+function readErrorMessage(error) {
+    if (error instanceof Error) {
+        const message = error.message.trim();
+        return message.length > 0 ? message : error.name;
+    }
+    if (typeof error === 'string') {
+        const message = error.trim();
+        return message.length > 0 ? message : undefined;
+    }
+    if (isPlainObject(error) && 'message' in error && typeof error.message === 'string') {
+        const message = error.message.trim();
+        if (message.length > 0) {
+            return message;
+        }
+    }
+    const nested = readNestedError(error);
+    if (nested && 'message' in nested && typeof nested.message === 'string') {
+        const message = nested.message.trim();
+        return message.length > 0 ? message : undefined;
+    }
+    return undefined;
+}
+function buildFailureMessage(error) {
+    return readErrorMessage(error) ?? 'Unknown LLM provider error.';
+}
+function isOpenAiRetriableProcessingFailureMessage(lowerMessage) {
+    if (!lowerMessage.includes('processing your request')) {
+        return false;
+    }
+    if (lowerMessage.includes('you can retry your request') ||
+        lowerMessage.includes('please retry your request')) {
+        return true;
+    }
+    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')) {
+        return true;
+    }
+    if (lowerMessage.includes('currently overloaded')) {
+        return true;
+    }
+    if (lowerMessage.includes('temporarily overloaded')) {
+        return true;
+    }
+    if (lowerMessage.includes('service unavailable')) {
+        return true;
+    }
+    return lowerMessage.includes('overloaded') && lowerMessage.includes('try again later');
+}
+function classifyOpenAiLikeFailure(error) {
+    const message = buildFailureMessage(error);
+    const lowerMessage = message.toLowerCase();
+    const status = readErrorStatus(error);
+    const code = readErrorCode(error);
+    if (status === 503 || status === 529 || isConservativeRetryMessage(lowerMessage)) {
+        return {
+            kind: 'retriable',
+            message,
+            status,
+            code,
+            retryStrategy: 'conservative',
+        };
+    }
+    if (isOpenAiRetriableProcessingFailureMessage(lowerMessage)) {
+        return {
+            kind: 'retriable',
+            message,
+            status,
+            code,
+            retryStrategy: 'aggressive',
+        };
+    }
+    return undefined;
+}
+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)) {
+        return {
+            kind: 'retriable',
+            message,
+            status,
+            code,
+            retryStrategy: 'conservative',
+        };
+    }
+    return undefined;
+}

package/dist/llm/gen/openai-compatible.d.ts

@@ -12,13 +12,14 @@ import type { ChatCompletionMessageParam } from 'openai/resources/chat/completio
 import type { Team } from '../../team';
 import type { FuncTool } from '../../tool';
 import type { ChatMessage, ProviderConfig } from '../client';
-import type { LlmBatchResult, LlmGenerator, LlmRequestContext, LlmStreamReceiver, LlmStreamResult } from '../gen';
+import type { LlmBatchResult, LlmFailureDisposition, LlmGenerator, LlmRequestContext, LlmStreamReceiver, LlmStreamResult } from '../gen';
 export declare function buildOpenAiCompatibleRequestMessagesWrapper(systemPrompt: string, context: ChatMessage[], options?: {
     reasoningContentMode?: boolean;
     providerConfig?: ProviderConfig;
 }): Promise<ChatCompletionMessageParam[]>;
 export declare class OpenAiCompatibleGen implements LlmGenerator {
     get apiType(): string;
+    classifyFailure(error: unknown): LlmFailureDisposition | undefined;
     genToReceiver(providerConfig: ProviderConfig, agent: Team.Member, systemPrompt: string, funcTools: FuncTool[], _requestContext: LlmRequestContext, context: ChatMessage[], receiver: LlmStreamReceiver, genseq: number, abortSignal?: AbortSignal): Promise<LlmStreamResult>;
     genMoreMessages(providerConfig: ProviderConfig, agent: Team.Member, systemPrompt: string, funcTools: FuncTool[], _requestContext: LlmRequestContext, context: ChatMessage[], genseq: number, abortSignal?: AbortSignal): Promise<LlmBatchResult>;
 }

package/dist/llm/gen/openai-compatible.js

@@ -20,6 +20,7 @@ const log_1 = require("../../log");
 const i18n_text_1 = require("../../runtime/i18n-text");
 const work_language_1 = require("../../runtime/work-language");
 const artifacts_1 = require("./artifacts");
+const failure_classifier_1 = require("./failure-classifier");
 const tool_call_context_1 = require("./tool-call-context");
 const tool_output_limit_1 = require("./tool-output-limit");
 const log = (0, log_1.createLogger)('llm/openai-compatible');
@@ -476,6 +477,9 @@ class OpenAiCompatibleGen {
     get apiType() {
         return 'openai-compatible';
     }
+    classifyFailure(error) {
+        return (0, failure_classifier_1.classifyOpenAiLikeFailure)(error);
+    }
     async genToReceiver(providerConfig, agent, systemPrompt, funcTools, _requestContext, context, receiver, genseq, abortSignal) {
         const apiKey = process.env[providerConfig.apiKeyEnvVar];
         if (!apiKey)

package/dist/llm/gen/openai.d.ts

@@ -7,10 +7,11 @@ import type { ResponseInputItem } from 'openai/resources/responses/responses';
 import type { Team } from '../../team';
 import type { FuncTool } from '../../tool';
 import type { ChatMessage, ProviderConfig } from '../client';
-import type { LlmBatchResult, LlmGenerator, LlmRequestContext, LlmStreamReceiver, LlmStreamResult } from '../gen';
+import type { LlmBatchResult, LlmFailureDisposition, LlmGenerator, LlmRequestContext, LlmStreamReceiver, LlmStreamResult } from '../gen';
 export declare function buildOpenAiRequestInputWrapper(context: ChatMessage[], providerConfig?: ProviderConfig): Promise<ResponseInputItem[]>;
 export declare class OpenAiGen implements LlmGenerator {
     get apiType(): string;
+    classifyFailure(error: unknown): LlmFailureDisposition | undefined;
     genToReceiver(providerConfig: ProviderConfig, agent: Team.Member, systemPrompt: string, funcTools: FuncTool[], _requestContext: LlmRequestContext, context: ChatMessage[], receiver: LlmStreamReceiver, _genseq: number, abortSignal?: AbortSignal): Promise<LlmStreamResult>;
     genMoreMessages(providerConfig: ProviderConfig, agent: Team.Member, systemPrompt: string, funcTools: FuncTool[], _requestContext: LlmRequestContext, context: ChatMessage[], genseq: number, abortSignal?: AbortSignal): Promise<LlmBatchResult>;
 }

package/dist/llm/gen/openai.js

@@ -15,6 +15,7 @@ const log_1 = require("../../log");
 const i18n_text_1 = require("../../runtime/i18n-text");
 const work_language_1 = require("../../runtime/work-language");
 const artifacts_1 = require("./artifacts");
+const failure_classifier_1 = require("./failure-classifier");
 const tool_call_context_1 = require("./tool-call-context");
 const tool_output_limit_1 = require("./tool-output-limit");
 const log = (0, log_1.createLogger)('llm/openai');
@@ -463,6 +464,9 @@ class OpenAiGen {
     get apiType() {
         return 'openai';
     }
+    classifyFailure(error) {
+        return (0, failure_classifier_1.classifyOpenAiLikeFailure)(error);
+    }
     async genToReceiver(providerConfig, agent, systemPrompt, funcTools, _requestContext, context, receiver, _genseq, abortSignal) {
         const apiKey = process.env[providerConfig.apiKeyEnvVar];
         if (!apiKey)

package/dist/llm/gen.d.ts

@@ -12,6 +12,15 @@ export interface LlmBatchResult {
     usage: LlmUsageStats;
     llmGenModel?: string;
 }
+export type LlmRetryStrategy = 'aggressive' | 'conservative';
+export type LlmFailureDisposition = {
+    kind: 'retriable' | 'rejected' | 'fatal';
+    message: string;
+    status?: number;
+    code?: string;
+    retryStrategy?: LlmRetryStrategy;
+};
+export type LlmFailureClassifier = (error: unknown) => LlmFailureDisposition | undefined;
 export interface LlmRequestContext {
     dialogSelfId: string;
     dialogRootId: string;
@@ -47,6 +56,7 @@ export interface LlmStreamReceiver {
 }
 export interface LlmGenerator {
     readonly apiType: string;
+    classifyFailure?: LlmFailureClassifier;
     genToReceiver: (providerConfig: ProviderConfig, agent: Team.Member, systemPrompt: string, funcTools: FuncTool[], requestContext: LlmRequestContext, context: ChatMessage[], receiver: LlmStreamReceiver, genseq: number, abortSignal?: AbortSignal) => Promise<LlmStreamResult>;
     genMoreMessages: (providerConfig: ProviderConfig, agent: Team.Member, systemPrompt: string, funcTools: FuncTool[], requestContext: LlmRequestContext, context: ChatMessage[], genseq: number, abortSignal?: AbortSignal) => Promise<LlmBatchResult>;
 }

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

@@ -30,6 +30,7 @@ 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
     initialDelayMs: 1000,
+    conservativeDelayMs: 30000,
     backoffMultiplier: 1.5,
     maxDelayMs: 30 * 60 * 1000, // 30 minutes
 };
@@ -136,6 +137,16 @@ function resolveRetryBackoffMultiplier(raw) {
     }
     return raw;
 }
+function resolveRetryConservativeDelayMs(raw) {
+    if (typeof raw !== 'number' || !Number.isFinite(raw)) {
+        return KERNEL_DRIVER_DEFAULT_RETRY_POLICY.conservativeDelayMs;
+    }
+    const normalized = Math.floor(raw);
+    if (normalized < 0) {
+        return KERNEL_DRIVER_DEFAULT_RETRY_POLICY.conservativeDelayMs;
+    }
+    return normalized;
+}
 function resolveRetryMaxDelayMs(raw) {
     if (typeof raw !== 'number' || !Number.isFinite(raw)) {
         return KERNEL_DRIVER_DEFAULT_RETRY_POLICY.maxDelayMs;
@@ -149,13 +160,15 @@ function resolveRetryMaxDelayMs(raw) {
 function resolveKernelDriverRetryPolicy(providerCfg) {
     const maxRetries = resolveRetryMaxRetries(providerCfg.llm_retry_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,
         initialDelayMs,
+        conservativeDelayMs: Math.max(initialDelayMs, conservativeDelayMs),
         backoffMultiplier,
-        maxDelayMs: Math.max(initialDelayMs, maxDelayMs),
+        maxDelayMs: Math.max(initialDelayMs, conservativeDelayMs, maxDelayMs),
     };
 }
 function hasMeaningfulBatchOutput(messages) {
@@ -1465,8 +1478,10 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             abortSignal,
                             maxRetries: retryPolicy.maxRetries,
                             retryInitialDelayMs: retryPolicy.initialDelayMs,
+                            retryConservativeDelayMs: retryPolicy.conservativeDelayMs,
                             retryBackoffMultiplier: retryPolicy.backoffMultiplier,
                             retryMaxDelayMs: retryPolicy.maxDelayMs,
+                            classifyFailure: llmGen.classifyFailure?.bind(llmGen),
                             canRetry: () => true,
                             doRequest: async () => {
                                 const batchResult = await llmGen.genMoreMessages(providerCfg, agent, systemPrompt, funcTools, {
@@ -1622,8 +1637,10 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         abortSignal,
                         maxRetries: retryPolicy.maxRetries,
                         retryInitialDelayMs: retryPolicy.initialDelayMs,
+                        retryConservativeDelayMs: retryPolicy.conservativeDelayMs,
                         retryBackoffMultiplier: retryPolicy.backoffMultiplier,
                         retryMaxDelayMs: retryPolicy.maxDelayMs,
+                        classifyFailure: llmGen.classifyFailure?.bind(llmGen),
                         canRetry: () => true,
                         onRetry: rollbackStreamAttempt,
                         onGiveUp: rollbackStreamAttempt,

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

@@ -10,6 +10,7 @@ const log_1 = require("../../log");
 const load_1 = require("../../minds/load");
 const persistence_1 = require("../../persistence");
 const driver_messages_1 = require("../../runtime/driver-messages");
+const reply_prompt_copy_1 = require("../../runtime/reply-prompt-copy");
 const work_language_1 = require("../../runtime/work-language");
 const client_1 = require("../client");
 const context_health_1 = require("./context-health");
@@ -28,24 +29,16 @@ function isReplyToolReminderPrompt(prompt) {
 function isIgnorablePostResponseAnchorTailEvent(type) {
     return type === 'tellask_reply_resolution_record' || type === 'gen_finish_record';
 }
-function buildReplyToolReminderPrompt(args) {
-    const toolName = args.directive.expectedReplyCallName;
-    if (args.language === 'zh') {
-        return [
-            REPLY_TOOL_REMINDER_PREFIX_ZH,
-            '',
-            `你刚才给出了正文，但尚未调用必需的 \`${toolName}\`。`,
-            `请现在立刻调用 \`${toolName}({ replyContent })\` 完成本次对话间回贴，不要再直接输出最终消息。`,
-            '如果你再次直接输出最终消息而仍不调用该工具，运行时当前会暂按 direct-reply fallback 投递，并在 UI/传递正文中明确标注。',
-        ].join('\n');
-    }
-    return [
-        REPLY_TOOL_REMINDER_PREFIX_EN,
-        '',
-        `You produced a reply body but did not call the required \`${toolName}\` tool.`,
-        `Call \`${toolName}({ replyContent })\` now to deliver this inter-dialog reply. Do not emit another plain final message.`,
-        'If you still emit a plain final message without the tool, runtime will currently deliver it via direct-reply fallback and label that path explicitly in UI and transfer text.',
-    ].join('\n');
+async function buildReplyToolReminderPrompt(args) {
+    return (0, reply_prompt_copy_1.buildReplyToolReminderText)({
+        language: args.language,
+        directive: args.directive,
+        prefix: args.language === 'zh' ? REPLY_TOOL_REMINDER_PREFIX_ZH : REPLY_TOOL_REMINDER_PREFIX_EN,
+        replyTargetAgentId: await (0, reply_guidance_1.resolveReplyTargetAgentId)({
+            dlg: args.dlg,
+            directive: args.directive,
+        }),
+    });
 }
 async function loadPendingDiagnosticsSnapshot(args) {
     const ownerDialogIdObj = new dialog_1.DialogID(args.ownerDialogId, args.rootId);
@@ -224,7 +217,8 @@ async function maybeResolveDeferredReplyReassertionPrompt(dialog) {
     await persistence_1.DialogPersistence.setDeferredReplyReassertion(dialog.id, undefined, dialog.status);
     const language = (0, work_language_1.getWorkLanguage)();
     return {
-        content: (0, reply_guidance_1.buildReplyObligationReassertionPrompt)({
+        content: await (0, reply_guidance_1.buildReplyObligationReassertionPrompt)({
+            dlg: dialog,
             directive: deferredReplyReassertion.directive,
             language,
         }),
@@ -637,7 +631,8 @@ async function executeDriveRound(args) {
             if (!activePromptWasReplyToolReminder) {
                 const language = (0, work_language_1.getWorkLanguage)();
                 followUp = {
-                    prompt: buildReplyToolReminderPrompt({
+                    prompt: await buildReplyToolReminderPrompt({
+                        dlg: dialog,
                         directive: activeTellaskReplyDirective,
                         language,
                     }),

package/dist/llm/kernel-driver/reply-guidance.d.ts

@@ -1,5 +1,10 @@
+import type { TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
 import { Dialog } from '../../dialog';
 import type { KernelDriverHumanPrompt } from './types';
+export declare function resolveReplyTargetAgentId(args: {
+    dlg: Dialog;
+    directive: TellaskReplyDirective;
+}): Promise<string | undefined>;
 export declare function resolvePromptReplyGuidance(args: {
     dlg: Dialog;
     prompt: KernelDriverHumanPrompt | undefined;
@@ -16,6 +21,7 @@ export declare function buildReplyObligationSuppressionGuide(args: {
     language: 'zh' | 'en';
 }): string;
 export declare function buildReplyObligationReassertionPrompt(args: {
+    dlg: Dialog;
     directive: NonNullable<KernelDriverHumanPrompt['tellaskReplyDirective']>;
     language: 'zh' | 'en';
-}): string;
+}): Promise<string>;

package/dist/llm/kernel-driver/reply-guidance.js

@@ -1,14 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveReplyTargetAgentId = resolveReplyTargetAgentId;
 exports.resolvePromptReplyGuidance = resolvePromptReplyGuidance;
 exports.buildReplyObligationSuppressionGuide = buildReplyObligationSuppressionGuide;
 exports.buildReplyObligationReassertionPrompt = buildReplyObligationReassertionPrompt;
 const dialog_1 = require("../../dialog");
+const dialog_instance_registry_1 = require("../../dialog-instance-registry");
 const reply_prompt_copy_1 = require("../../runtime/reply-prompt-copy");
 const work_language_1 = require("../../runtime/work-language");
 const tellask_special_1 = require("./tellask-special");
 const REPLY_TOOL_REMINDER_PREFIX_EN = '[Dominds replyTellask required]';
 const REPLY_TOOL_REMINDER_PREFIX_ZH = '[Dominds 必须调用回复工具]';
+async function resolveReplyTargetAgentId(args) {
+    switch (args.directive.expectedReplyCallName) {
+        case 'replyTellaskBack': {
+            const rootDialog = args.dlg instanceof dialog_1.RootDialog
+                ? args.dlg
+                : args.dlg instanceof dialog_1.SubDialog
+                    ? args.dlg.rootDialog
+                    : undefined;
+            if (!rootDialog) {
+                return undefined;
+            }
+            const targetDialogId = new dialog_1.DialogID(args.directive.targetDialogId, rootDialog.id.rootId);
+            const targetDialog = rootDialog.lookupDialog(targetDialogId.selfId) ??
+                (await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, targetDialogId, rootDialog.status));
+            return targetDialog?.agentId;
+        }
+        case 'replyTellask':
+        case 'replyTellaskSessionless':
+            return args.dlg instanceof dialog_1.SubDialog ? args.dlg.assignmentFromSup.originMemberId : undefined;
+    }
+}
 function buildPromptContentWithExactReplyToolName(args) {
     const isFbrSubdialog = args.dlg instanceof dialog_1.SubDialog && args.dlg.assignmentFromSup.callName === 'freshBootsReasoning';
     const noActivePrefix = args.language === 'zh'
@@ -48,13 +71,12 @@ function buildPromptContentWithExactReplyToolName(args) {
     if (args.prompt.content.startsWith(activePrefix)) {
         return args.prompt.content;
     }
-    const toolName = directive.expectedReplyCallName;
     if (reminderPrefixes.some((prefix) => args.prompt.content.startsWith(prefix))) {
         return args.prompt.content;
     }
     const note = (0, reply_prompt_copy_1.buildActiveReplyToolNote)({
         language: args.language,
-        toolName,
+        toolName: directive.expectedReplyCallName,
     });
     return `${note}\n\n${args.prompt.content}`;
 }
@@ -109,9 +131,13 @@ async function resolvePromptReplyGuidance(args) {
 function buildReplyObligationSuppressionGuide(args) {
     return (0, reply_prompt_copy_1.buildReplyObligationSuppressionGuideText)(args.language);
 }
-function buildReplyObligationReassertionPrompt(args) {
+async function buildReplyObligationReassertionPrompt(args) {
     return (0, reply_prompt_copy_1.buildReplyObligationReassertionText)({
         language: args.language,
-        toolName: args.directive.expectedReplyCallName,
+        directive: args.directive,
+        replyTargetAgentId: await resolveReplyTargetAgentId({
+            dlg: args.dlg,
+            directive: args.directive,
+        }),
     });
 }

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

@@ -1,5 +1,6 @@
 import { Dialog } from '../../dialog';
 import type { FuncTool, ToolArguments } from '../../tool';
+import type { LlmFailureClassifier } from '../gen';
 import type { KernelDriverHumanPrompt } from './types';
 export declare function maybePrepareDiligenceAutoContinuePrompt(options: {
     dlg: Dialog;
@@ -37,8 +38,10 @@ export declare function runLlmRequestWithRetry<T>(params: {
     abortSignal?: AbortSignal;
     maxRetries: number;
     retryInitialDelayMs: number;
+    retryConservativeDelayMs: number;
     retryBackoffMultiplier: number;
     retryMaxDelayMs: number;
+    classifyFailure?: LlmFailureClassifier;
     canRetry: () => boolean;
     onRetry?: () => Promise<void> | void;
     onGiveUp?: () => Promise<void> | void;