dominds 1.12.2 → 1.13.2

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

@@ -265,16 +265,6 @@ function isRetriableLlmErrorCode(code) {
         return false;
     return RETRIABLE_LLM_ERROR_CODES.has(code);
 }
-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 isRetriableLlmMessage(message) {
     const lower = message.toLowerCase();
     if (lower.includes('fetch failed') || lower.includes('socket hang up')) {
@@ -286,12 +276,25 @@ function isRetriableLlmMessage(message) {
     if (lower.includes('timeout') || lower.includes('timed out') || lower.includes('rate limit')) {
         return true;
     }
-    if (isOpenAiRetriableProcessingFailureMessage(lower)) {
-        return true;
-    }
     return false;
 }
-function classifyLlmFailure(err) {
+function normalizeFailureDisposition(err, disposition) {
+    const fallbackMessage = err instanceof Error
+        ? err.message || err.name
+        : typeof err === 'string'
+            ? err
+            : JSON.stringify(err);
+    const errCode = readErrorCode(err);
+    const causeCode = readErrorCode(readErrorCause(err));
+    return {
+        kind: disposition.kind,
+        message: disposition.message.trim().length > 0 ? disposition.message : fallbackMessage,
+        status: disposition.status,
+        code: disposition.code ?? errCode ?? causeCode,
+        retryStrategy: disposition.retryStrategy,
+    };
+}
+function classifyGenericLlmFailure(err) {
     const fallbackMessage = err instanceof Error
         ? err.message || err.name
         : typeof err === 'string'
@@ -304,10 +307,20 @@ function classifyLlmFailure(err) {
         return { kind: 'fatal', message: 'Aborted.' };
     }
     if (isRetriableLlmErrorCode(errCode)) {
-        return { kind: 'retriable', code: errCode, message: fallbackMessage };
+        return {
+            kind: 'retriable',
+            code: errCode,
+            message: fallbackMessage,
+            retryStrategy: 'aggressive',
+        };
     }
     if (isRetriableLlmErrorCode(causeCode)) {
-        return { kind: 'retriable', code: causeCode, message: fallbackMessage };
+        return {
+            kind: 'retriable',
+            code: causeCode,
+            message: fallbackMessage,
+            retryStrategy: 'aggressive',
+        };
     }
     {
         const msg = err instanceof Error
@@ -319,7 +332,12 @@ function classifyLlmFailure(err) {
                 : undefined;
         if (typeof msg === 'string' && msg.length > 0) {
             if (isRetriableLlmMessage(msg)) {
-                return { kind: 'retriable', code: errCode ?? causeCode, message: msg };
+                return {
+                    kind: 'retriable',
+                    code: errCode ?? causeCode,
+                    message: msg,
+                    retryStrategy: 'aggressive',
+                };
             }
         }
     }
@@ -335,21 +353,38 @@ function classifyLlmFailure(err) {
             : fallbackMessage;
         if (typeof status === 'number') {
             if (status === 408 || status === 429 || status >= 500) {
-                return { kind: 'retriable', status, message: msg };
+                return {
+                    kind: 'retriable',
+                    status,
+                    message: msg,
+                    retryStrategy: status === 503 || status === 529 ? 'conservative' : 'aggressive',
+                };
             }
             if (status >= 400 && status < 500) {
                 return { kind: 'rejected', status, message: msg };
             }
         }
         if (isRetriableLlmErrorCode(code)) {
-            return { kind: 'retriable', code, message: msg };
+            return { kind: 'retriable', code, message: msg, retryStrategy: 'aggressive' };
         }
         if (isRetriableLlmMessage(msg)) {
-            return { kind: 'retriable', code: code ?? causeCode, message: msg };
+            return {
+                kind: 'retriable',
+                code: code ?? causeCode,
+                message: msg,
+                retryStrategy: 'aggressive',
+            };
         }
     }
     return { kind: 'fatal', message: fallbackMessage };
 }
+function classifyLlmFailure(err, classifyFailure) {
+    const providerDisposition = classifyFailure?.(err);
+    if (providerDisposition) {
+        return normalizeFailureDisposition(err, providerDisposition);
+    }
+    return classifyGenericLlmFailure(err);
+}
 async function sleepWithAbort(ms, abortSignal) {
     if (abortSignal?.aborted) {
         throw new Error('AbortError');
@@ -373,6 +408,14 @@ function normalizeRetryInitialDelayMs(value) {
     const normalized = Math.floor(value);
     return normalized >= 0 ? normalized : 1000;
 }
+function normalizeRetryConservativeDelayMs(value, fallbackMin) {
+    if (!Number.isFinite(value))
+        return Math.max(30000, fallbackMin);
+    const normalized = Math.floor(value);
+    if (normalized < 0)
+        return Math.max(30000, fallbackMin);
+    return Math.max(fallbackMin, normalized);
+}
 function normalizeRetryBackoffMultiplier(value) {
     if (!Number.isFinite(value))
         return 2;
@@ -399,6 +442,8 @@ function emitLlmRetryEventBestEffort(args) {
         genseq: Math.floor(rawGenseq),
         phase: args.phase,
         provider: args.provider,
+        retryStrategy: args.retryStrategy,
+        retryForever: args.retryForever,
         attempt: args.attempt,
         totalAttempts: args.totalAttempts,
         maxRetries: args.maxRetries,
@@ -413,23 +458,28 @@ function emitLlmRetryEventBestEffort(args) {
 }
 async function runLlmRequestWithRetry(params) {
     const providerProblemId = `llm/provider_rejected/${params.dlg.id.valueOf()}`;
-    const totalAttempts = params.maxRetries + 1;
+    const aggressiveTotalAttempts = params.maxRetries + 1;
     const retryInitialDelayMs = normalizeRetryInitialDelayMs(params.retryInitialDelayMs);
+    const retryConservativeDelayMs = normalizeRetryConservativeDelayMs(params.retryConservativeDelayMs, retryInitialDelayMs);
     const retryBackoffMultiplier = normalizeRetryBackoffMultiplier(params.retryBackoffMultiplier);
-    const retryMaxDelayMs = normalizeRetryMaxDelayMs(params.retryMaxDelayMs, retryInitialDelayMs);
+    const retryMaxDelayMs = normalizeRetryMaxDelayMs(params.retryMaxDelayMs, Math.max(retryInitialDelayMs, retryConservativeDelayMs));
     const retryFlowStartedAtMs = Date.now();
     let activeRetryContext;
-    for (let attempt = 0; attempt <= params.maxRetries; attempt++) {
+    for (let attempt = 0;; attempt++) {
         try {
             if (attempt > 0 && activeRetryContext) {
+                const retryStrategy = activeRetryContext.failure.retryStrategy ?? 'aggressive';
+                const retryForever = retryStrategy === 'conservative';
                 emitLlmRetryEventBestEffort({
                     dlg: params.dlg,
                     phase: 'running',
                     provider: params.provider,
+                    retryStrategy,
+                    retryForever,
                     attempt: attempt + 1,
-                    totalAttempts,
+                    totalAttempts: retryForever ? 0 : aggressiveTotalAttempts,
                     maxRetries: params.maxRetries,
-                    retriesRemaining: Math.max(0, params.maxRetries - attempt),
+                    retriesRemaining: retryForever ? undefined : Math.max(0, params.maxRetries - attempt),
                     failure: activeRetryContext.failure,
                     errorText: activeRetryContext.errorText,
                 });
@@ -442,19 +492,24 @@ async function runLlmRequestWithRetry(params) {
             if (params.abortSignal?.aborted) {
                 throw err;
             }
-            const failure = classifyLlmFailure(err);
+            const failure = classifyLlmFailure(err, params.classifyFailure);
             const detail = (0, log_1.extractErrorDetails)(err).message;
             const errorCode = readErrorCode(err);
             const cause = readErrorCause(err);
             const causeCode = readErrorCode(cause);
             const causeMessage = cause === undefined || cause === null ? undefined : (0, log_1.extractErrorDetails)(cause).message;
             const attemptNo = attempt + 1;
-            const retriesRemaining = Math.max(0, params.maxRetries - attempt);
+            const retryStrategy = failure.retryStrategy ?? 'aggressive';
+            const retryForever = retryStrategy === 'conservative';
+            const retriesRemaining = retryForever ? undefined : Math.max(0, params.maxRetries - attempt);
+            const totalAttempts = retryForever ? 0 : aggressiveTotalAttempts;
             log_1.log.warn('LLM request attempt failed', err, {
                 provider: params.provider,
                 dialogId: params.dlg.id.valueOf(),
                 rootId: params.dlg.id.rootId,
                 selfId: params.dlg.id.selfId,
+                retryStrategy,
+                retryForever,
                 attempt: attemptNo,
                 totalAttempts,
                 retriesRemaining,
@@ -489,17 +544,19 @@ async function runLlmRequestWithRetry(params) {
                 throw new Error(`Provider '${params.provider}' rejected the request: ${failure.message}`);
             }
             const canRetry = failure.kind === 'retriable' && params.canRetry();
-            const isLastAttempt = attempt >= params.maxRetries;
+            const isLastAttempt = retryForever ? false : attempt >= params.maxRetries;
             if (!canRetry || isLastAttempt) {
                 if (params.onGiveUp) {
                     await params.onGiveUp();
                 }
                 if (failure.kind === 'retriable') {
-                    const suggestion = `Consider increasing providers.${params.provider}.llm_retry_max_retries / llm_retry_initial_delay_ms / llm_retry_backoff_multiplier / llm_retry_max_delay_ms in .minds/llm.yaml, and verify provider/network stability.`;
+                    const suggestion = `Consider adjusting providers.${params.provider}.llm_retry_max_retries / llm_retry_initial_delay_ms / llm_retry_conservative_delay_ms / llm_retry_backoff_multiplier / llm_retry_max_delay_ms in .minds/llm.yaml, and verify provider/network stability.`;
                     emitLlmRetryEventBestEffort({
                         dlg: params.dlg,
                         phase: 'exhausted',
                         provider: params.provider,
+                        retryStrategy,
+                        retryForever,
                         attempt: attemptNo,
                         totalAttempts,
                         maxRetries: params.maxRetries,
@@ -513,10 +570,13 @@ async function runLlmRequestWithRetry(params) {
                         dialogId: params.dlg.id.valueOf(),
                         rootId: params.dlg.id.rootId,
                         selfId: params.dlg.id.selfId,
+                        retryStrategy,
+                        retryForever,
                         attempt: attemptNo,
                         totalAttempts,
                         maxRetries: params.maxRetries,
                         retryInitialDelayMs,
+                        retryConservativeDelayMs,
                         retryBackoffMultiplier,
                         retryMaxDelayMs,
                         errorText: detail,
@@ -537,6 +597,7 @@ async function runLlmRequestWithRetry(params) {
                         maxRetries: params.maxRetries,
                         elapsedMs: Date.now() - retryFlowStartedAtMs,
                         retryInitialDelayMs,
+                        retryConservativeDelayMs,
                         retryBackoffMultiplier,
                         retryMaxDelayMs,
                         errorText: detail,
@@ -545,11 +606,16 @@ async function runLlmRequestWithRetry(params) {
                 }
                 throw new Error(`LLM failed: ${failure.message}`);
             }
-            const backoffMs = Math.min(retryMaxDelayMs, Math.max(0, Math.floor(retryInitialDelayMs * retryBackoffMultiplier ** attempt)));
+            const conservativeRampAttempt = Math.max(0, Math.floor(attempt / 10));
+            const backoffMs = retryStrategy === 'conservative'
+                ? Math.min(retryMaxDelayMs, Math.max(0, Math.floor(retryConservativeDelayMs * retryBackoffMultiplier ** conservativeRampAttempt)))
+                : Math.min(retryMaxDelayMs, Math.max(0, Math.floor(retryInitialDelayMs * retryBackoffMultiplier ** attempt)));
             emitLlmRetryEventBestEffort({
                 dlg: params.dlg,
                 phase: 'waiting',
                 provider: params.provider,
+                retryStrategy,
+                retryForever,
                 attempt: attemptNo,
                 totalAttempts,
                 maxRetries: params.maxRetries,
@@ -564,9 +630,12 @@ async function runLlmRequestWithRetry(params) {
             };
             log_1.log.warn(`Retrying LLM request after retriable error`, undefined, {
                 provider: params.provider,
+                retryStrategy,
+                retryForever,
                 attempt: attemptNo,
                 backoffMs,
                 retryInitialDelayMs,
+                retryConservativeDelayMs,
                 retryBackoffMultiplier,
                 retryMaxDelayMs,
                 failure,
@@ -607,11 +676,13 @@ function formatLlmRetryExhaustedInterruptionDetail(args) {
             `（初始请求 1 次 + 重试 ${args.maxRetries} 次），总耗时 ${durationText}。` +
             `当前重试配置：llm_retry_max_retries=${args.maxRetries}，` +
             `llm_retry_initial_delay_ms=${args.retryInitialDelayMs}，` +
+            `llm_retry_conservative_delay_ms=${args.retryConservativeDelayMs}，` +
             `llm_retry_backoff_multiplier=${args.retryBackoffMultiplier}，` +
             `llm_retry_max_delay_ms=${args.retryMaxDelayMs}。` +
             `若想增加重试次数或拉长重试间隔，请编辑 \`.minds/llm.yaml\` 中的 ` +
             `\`${providerPath}.llm_retry_max_retries\`、` +
             `\`${providerPath}.llm_retry_initial_delay_ms\`、` +
+            `\`${providerPath}.llm_retry_conservative_delay_ms\`、` +
             `\`${providerPath}.llm_retry_backoff_multiplier\`、` +
             `\`${providerPath}.llm_retry_max_delay_ms\`，并检查 provider / network 稳定性。` +
             `最后错误：${trimmedError}`);
@@ -620,11 +691,13 @@ function formatLlmRetryExhaustedInterruptionDetail(args) {
         `(1 initial request + ${args.maxRetries} retries), elapsed ${durationText}. ` +
         `Current retry config: llm_retry_max_retries=${args.maxRetries}, ` +
         `llm_retry_initial_delay_ms=${args.retryInitialDelayMs}, ` +
+        `llm_retry_conservative_delay_ms=${args.retryConservativeDelayMs}, ` +
         `llm_retry_backoff_multiplier=${args.retryBackoffMultiplier}, ` +
         `llm_retry_max_delay_ms=${args.retryMaxDelayMs}. ` +
         `If you want more retries or longer retry intervals, edit ` +
         `\`.minds/llm.yaml\`: \`${providerPath}.llm_retry_max_retries\`, ` +
         `\`${providerPath}.llm_retry_initial_delay_ms\`, ` +
+        `\`${providerPath}.llm_retry_conservative_delay_ms\`, ` +
         `\`${providerPath}.llm_retry_backoff_multiplier\`, ` +
         `\`${providerPath}.llm_retry_max_delay_ms\`, and verify provider/network stability. ` +
         `Last error: ${trimmedError}`);

package/dist/persistence.js

@@ -2792,23 +2792,48 @@ exports.DiskFileDialogStore = DiskFileDialogStore;
  */
 class DialogPersistence {
     static async repairInterruptedFunctionCallsOnRestore(args) {
-        if (args.status !== 'running') {
-            return args.events;
-        }
+        const repaired = [];
         const unresolvedById = new Map();
         for (const event of args.events) {
             if (event.type === 'func_call_record') {
                 unresolvedById.set(event.id, event);
+                repaired.push(event);
                 continue;
             }
             if (event.type === 'func_result_record') {
-                unresolvedById.delete(event.id);
+                if (!unresolvedById.has(event.id)) {
+                    const repairCall = {
+                        ts: event.ts,
+                        type: 'func_call_record',
+                        genseq: event.genseq,
+                        id: event.id,
+                        name: event.name,
+                        arguments: {},
+                    };
+                    log_1.log.error('Recovered orphaned persisted func_result_record by synthesizing missing func_call_record during dialog restore', new Error('dialog_restore_recovered_orphaned_func_result'), {
+                        rootId: args.dialogId.rootId,
+                        selfId: args.dialogId.selfId,
+                        course: args.course,
+                        genseq: event.genseq,
+                        callId: event.id,
+                        toolName: event.name,
+                    });
+                    repaired.push(repairCall);
+                }
+                else {
+                    unresolvedById.delete(event.id);
+                }
+                repaired.push(event);
+                continue;
             }
+            repaired.push(event);
+        }
+        if (args.status !== 'running') {
+            return repaired;
         }
         if (unresolvedById.size === 0) {
-            return args.events;
+            return repaired;
         }
-        const repaired = [...args.events];
         for (const call of unresolvedById.values()) {
             const repairRecord = {
                 ts: (0, time_1.formatUnifiedTimestamp)(new Date()),

package/dist/runtime/inter-dialog-format.js

@@ -24,17 +24,18 @@ exports.formatTellaskCarryoverResultContent = formatTellaskCarryoverResultConten
 const driver_messages_1 = require("./driver-messages");
 const markdown_format_1 = require("./markdown-format");
 const reply_prompt_copy_1 = require("./reply-prompt-copy");
+const tellask_labels_1 = require("./tellask-labels");
 function getRuntimeTransferMarkers(language) {
     if (language === 'zh') {
         return {
-            tellaskBack: '【回问诉请】',
+            tellaskBack: (0, tellask_labels_1.getTellaskKindLabel)({ language, name: 'tellaskBack', bracketed: true }),
             finalCompleted: '【最终完成】',
             fbrDirectReply: '【FBR-直接回复】',
             fbrReasoningOnly: '【FBR-仅推理】',
         };
     }
     return {
-        tellaskBack: '【TellaskBack】',
+        tellaskBack: (0, tellask_labels_1.getTellaskKindLabel)({ language, name: 'tellaskBack', bracketed: true }),
         finalCompleted: '【Completed】',
         fbrDirectReply: '【FBR-Direct Reply】',
         fbrReasoningOnly: '【FBR-Reasoning Only】',
@@ -103,6 +104,14 @@ function stripMentionPrefix(value) {
         return '';
     return trimmed.startsWith('@') ? trimmed.slice(1).trim() : trimmed;
 }
+function formatQuotedRequestBlock(args) {
+    const lines = [args.title, ''];
+    if (args.mentionLine && args.mentionLine.trim() !== '') {
+        lines.push((0, markdown_format_1.markdownQuote)(args.mentionLine));
+    }
+    lines.push((0, markdown_format_1.markdownQuote)(requireNonEmpty(args.body, 'body')));
+    return lines.join('\n');
+}
 function formatAssignmentFromSupdialog(input) {
     const language = input.language ?? 'en';
     const runtimeMarkers = getRuntimeTransferMarkers(language);
@@ -159,12 +168,16 @@ function formatAssignmentFromSupdialog(input) {
     const sessionSlug = input.sessionSlug?.trim() ?? '';
     const greeting = language === 'zh'
         ? sessionSlug === ''
-            ? '现在：'
-            : `现在（${sessionSlug}）：`
+            ? '诉请内容：'
+            : `诉请内容（${sessionSlug}）：`
         : sessionSlug === ''
-            ? 'Now:'
-            : `Now (${sessionSlug}):`;
-    return `${roleHeader}\n\n${markerProtocolNote}\n\n${greeting}\n\n${(0, markdown_format_1.markdownQuote)(mentionLine)}\n${(0, markdown_format_1.markdownQuote)(tellaskContent)}\n`;
+            ? 'Request:'
+            : `Request (${sessionSlug}):`;
+    return `${roleHeader}\n\n${markerProtocolNote}\n\n${formatQuotedRequestBlock({
+        title: greeting,
+        mentionLine,
+        body: tellaskContent,
+    })}\n`;
 }
 function formatUpdatedAssignmentFromSupdialog(input) {
     const language = input.language ?? 'en';
@@ -182,24 +195,41 @@ function formatSupdialogCallPrompt(input) {
     const supMention = (() => {
         if (input.supdialogAssignment.callName === 'tellask' ||
             input.supdialogAssignment.callName === 'tellaskSessionless') {
-            return (0, markdown_format_1.markdownQuote)(requireMentionLine(input.supdialogAssignment.mentionList ?? []));
+            return requireMentionLine(input.supdialogAssignment.mentionList ?? []);
         }
         return '';
     })();
-    const hello = language === 'zh'
-        ? `你好 @${requireNonEmpty(input.toAgentId, 'toAgentId')}，在处理 ${supMention} 以下任务期间（如下引文）：`
-        : `Hi @${requireNonEmpty(input.toAgentId, 'toAgentId')}, while working on the following original task of ${supMention} (quoted following):`;
-    const asking = language === 'zh'
-        ? `\`@${requireNonEmpty(input.fromAgentId, 'fromAgentId')}\` 回问：`
-        : `\`@${requireNonEmpty(input.fromAgentId, 'fromAgentId')}\` TellaskBack:`;
+    const fromAgentId = requireNonEmpty(input.fromAgentId, 'fromAgentId');
+    const toAgentId = requireNonEmpty(input.toAgentId, 'toAgentId');
+    const askBackLabel = (0, tellask_labels_1.getTellaskKindLabel)({ language, name: 'tellaskBack', bracketed: true });
     const subMention = (() => {
         if (input.subdialogRequest.callName === 'tellask' ||
             input.subdialogRequest.callName === 'tellaskSessionless') {
-            return (0, markdown_format_1.markdownQuote)(requireMentionLine(input.subdialogRequest.mentionList ?? []));
+            return requireMentionLine(input.subdialogRequest.mentionList ?? []);
         }
         return '';
     })();
-    return `${hello}\n\n${(0, markdown_format_1.markdownQuote)(requireNonEmpty(input.supdialogAssignment.tellaskContent, 'assignmentTellaskContent'))}\n\n${asking}\n\n${subMention ? `${subMention}\n` : ''}${(0, markdown_format_1.markdownQuote)(requireNonEmpty(input.subdialogRequest.tellaskContent, 'requestTellaskContent'))}\n`;
+    const intro = language === 'zh'
+        ? `@${fromAgentId} 发来一条 ${askBackLabel} 给 @${toAgentId}。`
+        : `@${fromAgentId} sent a ${askBackLabel} to @${toAgentId}.`;
+    const originalTitle = language === 'zh' ? '原诉请：' : 'Original request:';
+    const askBackTitle = language === 'zh' ? '回问内容：' : 'Ask-back content:';
+    return [
+        intro,
+        '',
+        formatQuotedRequestBlock({
+            title: originalTitle,
+            mentionLine: supMention,
+            body: requireNonEmpty(input.supdialogAssignment.tellaskContent, 'assignmentTellaskContent'),
+        }),
+        '',
+        formatQuotedRequestBlock({
+            title: askBackTitle,
+            mentionLine: subMention,
+            body: requireNonEmpty(input.subdialogRequest.tellaskContent, 'requestTellaskContent'),
+        }),
+        '',
+    ].join('\n');
 }
 function formatTellaskResponseContent(input) {
     const language = input.language ?? 'en';

package/dist/runtime/reply-prompt-copy.d.ts

@@ -1,10 +1,16 @@
 import type { LanguageCode } from '@longrun-ai/kernel/types/language';
+import type { TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
 export declare const ACTIVE_REPLY_TOOL_PREFIX_EN = "[Dominds active reply tool]";
 export declare const ACTIVE_REPLY_TOOL_PREFIX_ZH = "[Dominds \u5F53\u524D\u56DE\u590D\u5DE5\u5177]";
 export declare const REPLY_REASSERTION_PREFIX_EN = "[Dominds long-line reminder]";
 export declare const REPLY_REASSERTION_PREFIX_ZH = "[Dominds \u957F\u7EBF\u63D0\u9192]";
 export declare const REPLY_SUPPRESSION_PREFIX_EN = "[Dominds handle this interjection first]";
 export declare const REPLY_SUPPRESSION_PREFIX_ZH = "[Dominds \u5148\u63A5\u4F4F\u8FD9\u8F6E]";
+type ReplyObligationCopyArgs = {
+    language: LanguageCode;
+    directive: TellaskReplyDirective;
+    replyTargetAgentId?: string;
+};
 export declare function buildActiveReplyToolNote(args: {
     language: LanguageCode;
     toolName: 'replyTellask' | 'replyTellaskSessionless' | 'replyTellaskBack';
@@ -16,8 +22,12 @@ export declare function buildSubdialogRoleHeaderCopy(args: {
     expectedReplyTool?: 'replyTellask' | 'replyTellaskSessionless' | 'replyTellaskBack' | undefined;
 }): string;
 export declare function buildReplyObligationSuppressionGuideText(language: LanguageCode): string;
-export declare function buildReplyObligationReassertionText(args: {
+export declare function buildReplyObligationReassertionText(args: ReplyObligationCopyArgs): string;
+export declare function buildReplyToolReminderText(args: {
     language: LanguageCode;
-    toolName: 'replyTellask' | 'replyTellaskSessionless' | 'replyTellaskBack';
+    directive: TellaskReplyDirective;
+    prefix: string;
+    replyTargetAgentId?: string;
 }): string;
 export declare function isStandaloneRuntimeGuidePromptContent(content: string): boolean;
+export {};

package/dist/runtime/reply-prompt-copy.js

@@ -6,13 +6,45 @@ exports.buildSidelineCompletionRule = buildSidelineCompletionRule;
 exports.buildSubdialogRoleHeaderCopy = buildSubdialogRoleHeaderCopy;
 exports.buildReplyObligationSuppressionGuideText = buildReplyObligationSuppressionGuideText;
 exports.buildReplyObligationReassertionText = buildReplyObligationReassertionText;
+exports.buildReplyToolReminderText = buildReplyToolReminderText;
 exports.isStandaloneRuntimeGuidePromptContent = isStandaloneRuntimeGuidePromptContent;
+const tellask_labels_1 = require("./tellask-labels");
 exports.ACTIVE_REPLY_TOOL_PREFIX_EN = '[Dominds active reply tool]';
 exports.ACTIVE_REPLY_TOOL_PREFIX_ZH = '[Dominds 当前回复工具]';
 exports.REPLY_REASSERTION_PREFIX_EN = '[Dominds long-line reminder]';
 exports.REPLY_REASSERTION_PREFIX_ZH = '[Dominds 长线提醒]';
 exports.REPLY_SUPPRESSION_PREFIX_EN = '[Dominds handle this interjection first]';
 exports.REPLY_SUPPRESSION_PREFIX_ZH = '[Dominds 先接住这轮]';
+function formatReplyTargetAgentId(agentId, language) {
+    if (agentId && agentId.trim() !== '') {
+        return `@${agentId}`;
+    }
+    return language === 'zh' ? '对方' : 'the other dialog';
+}
+function buildReplyObligationReassertionLine(args) {
+    const toolName = args.directive.expectedReplyCallName;
+    const replyTarget = formatReplyTargetAgentId(args.replyTargetAgentId, args.language);
+    const kindLabel = (0, tellask_labels_1.getTellaskKindLabel)({
+        language: args.language,
+        name: args.directive.expectedReplyCallName,
+        bracketed: true,
+    });
+    return args.language === 'zh'
+        ? `${replyTarget} 的${kindLabel}还在等你的回复。等你准备好回复内容后，调用 \`${toolName}\` 完成回复。这里不是催你立刻回复。`
+        : `${replyTarget}'s ${kindLabel} is still waiting for your reply. Once your reply content is ready, call \`${toolName}\` to deliver it. This is not asking you to reply immediately.`;
+}
+function buildReplyToolReminderLine(args) {
+    const toolName = args.directive.expectedReplyCallName;
+    const replyTarget = formatReplyTargetAgentId(args.replyTargetAgentId, args.language);
+    const kindLabel = (0, tellask_labels_1.getTellaskKindLabel)({
+        language: args.language,
+        name: args.directive.expectedReplyCallName,
+        bracketed: true,
+    });
+    return args.language === 'zh'
+        ? `${replyTarget} 的${kindLabel}还在等你的回复。请现在调用 \`${toolName}({ replyContent })\` 完成回复。`
+        : `${replyTarget}'s ${kindLabel} is still waiting for your reply. Call \`${toolName}({ replyContent })\` now to deliver it.`;
+}
 function buildActiveReplyToolNote(args) {
     if (args.language === 'zh') {
         return [
@@ -33,14 +65,20 @@ function buildSidelineCompletionRule(language) {
         : 'If the current sideline is complete and can deliver the final result: stay focused on finishing the actual task first; if runtime names an exact reply function, call that function only at final upstream delivery, do not switch among `reply*` variants, and do not use `tellaskBack` for final delivery.';
 }
 function buildSubdialogRoleHeaderCopy(args) {
+    const requester = `@${args.requesterId}`;
     if (args.expectedReplyTool === undefined) {
         return args.language === 'zh'
-            ? `你是当前被诉请者对话（tellaskee dialog）的主理人；诉请者对话（tellasker dialog）为 @${args.requesterId}（当前发起本次诉请）。只有在需要回问上游时才调用 \`tellaskBack\`。`
-            : `You are the responder (tellaskee dialog) for this dialog; the tellasker dialog is @${args.requesterId} (the current caller). Call \`tellaskBack\` only when you need to ask back upstream.`;
+            ? `${requester} 的诉请已交给你处理。只有需要回问时，才调用 \`tellaskBack\`。`
+            : `You are handling ${requester}'s request. Call \`tellaskBack\` only when you truly need to ask back.`;
     }
+    const kindLabel = (0, tellask_labels_1.getTellaskKindLabel)({
+        language: args.language,
+        name: args.expectedReplyTool,
+        bracketed: true,
+    });
     return args.language === 'zh'
-        ? `你是当前被诉请者对话（tellaskee dialog）的主理人；诉请者对话（tellasker dialog）为 @${args.requesterId}（当前发起本次诉请）。先把当前任务做对；若本轮最终需要对上游完成交付，必须精确调用 \`${args.expectedReplyTool}\` 收口，不要改选其他 \`reply*\`。只有在需要回问上游时才调用 \`tellaskBack\`。`
-        : `You are the responder (tellaskee dialog) for this dialog; the tellasker dialog is @${args.requesterId} (the current caller). First, do the current task correctly; if this round ultimately needs final delivery back upstream, you must close with \`${args.expectedReplyTool}\` exactly and must not switch to another \`reply*\` variant. Call \`tellaskBack\` only when you need to ask back upstream.`;
+        ? `${requester} 的${kindLabel}已交给你处理。等你准备好回复内容后，调用 \`${args.expectedReplyTool}\` 完成回复。只有需要回问时，才调用 \`tellaskBack\`。`
+        : `${requester}'s ${kindLabel} is now assigned to you. Once your reply content is ready, call \`${args.expectedReplyTool}\` to deliver it. Call \`tellaskBack\` only when you truly need to ask back.`;
 }
 function buildReplyObligationSuppressionGuideText(language) {
     if (language === 'zh') {
@@ -59,20 +97,40 @@ function buildReplyObligationSuppressionGuideText(language) {
     ].join('\n');
 }
 function buildReplyObligationReassertionText(args) {
-    if (args.language === 'zh') {
-        return [
+    return args.language === 'zh'
+        ? [
             exports.REPLY_REASSERTION_PREFIX_ZH,
-            '刚才那轮用户插话已经先接住了，现在继续原来那条长线任务本身。',
-            '继续做该做的事，别只盯着 `reply*` 工具名。',
-            `真走到需要对上游完成交付的时候，再精确调用 \`${args.toolName}\`；这条提醒不是在催你立刻收口。`,
+            '',
+            '刚才那轮插话已经处理完了，现在继续原来的长线任务。',
+            '',
+            buildReplyObligationReassertionLine(args),
+        ].join('\n')
+        : [
+            exports.REPLY_REASSERTION_PREFIX_EN,
+            '',
+            'The interjection has been handled. Now continue the original longer-running task.',
+            '',
+            buildReplyObligationReassertionLine(args),
+        ].join('\n');
+}
+function buildReplyToolReminderText(args) {
+    return args.language === 'zh'
+        ? [
+            args.prefix,
+            '',
+            `你刚才已经写了正文，但还没调用 \`${args.directive.expectedReplyCallName}\`。`,
+            '',
+            buildReplyToolReminderLine(args),
+            '如果你再次直接输出最终消息而仍不调用该工具，运行时当前会暂按 direct-reply fallback 投递，并在 UI/传递正文中明确标注。',
+        ].join('\n')
+        : [
+            args.prefix,
+            '',
+            `You already wrote the reply body, but you still have not called \`${args.directive.expectedReplyCallName}\`.`,
+            '',
+            buildReplyToolReminderLine(args),
+            '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');
-    }
-    return [
-        exports.REPLY_REASSERTION_PREFIX_EN,
-        'The user interjection has already been handled first; now continue the original longer-running task itself.',
-        'Keep doing the actual work instead of fixating on the `reply*` tool name.',
-        `Only when that work truly reaches final delivery upstream should you call \`${args.toolName}\`; this reminder is not asking you to close immediately.`,
-    ].join('\n');
 }
 function isStandaloneRuntimeGuidePromptContent(content) {
     return (content.startsWith(exports.REPLY_REASSERTION_PREFIX_ZH) ||

package/dist/runtime/tellask-labels.d.ts

@@ -0,0 +1,8 @@
+import type { LanguageCode } from '@longrun-ai/kernel/types/language';
+type TellaskKindName = 'tellaskBack' | 'tellask' | 'tellaskSessionless' | 'freshBootsReasoning' | 'replyTellaskBack' | 'replyTellask' | 'replyTellaskSessionless';
+export declare function getTellaskKindLabel(args: {
+    language: LanguageCode;
+    name: TellaskKindName;
+    bracketed?: boolean;
+}): string;
+export {};