dominds 1.16.1 → 1.16.2

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

@@ -1,13 +1,25 @@
-import type { DialogLlmRetryExhaustedReason } from '@longrun-ai/kernel/types/display-state';
+import type { DialogDisplayTextI18n, DialogLlmRetryExhaustedReason } from '@longrun-ai/kernel/types/display-state';
 import { Dialog } from '../../dialog';
 import type { FuncTool, ToolArguments } from '../../tool';
+import { type LlmFailureQuirkHandlerSession } from '../api-quirks';
 import type { ProviderConfig } from '../client';
-import type { LlmFailureClassifier } from '../gen';
+import { type LlmFailureClassifier } from '../gen';
 import type { KernelDriverHumanPrompt } from './types';
 export declare class LlmRetryStoppedError extends Error {
     readonly reason: DialogLlmRetryExhaustedReason;
     constructor(reason: DialogLlmRetryExhaustedReason, message: string);
 }
+export declare class LlmRequestFailedError extends Error {
+    readonly detail: string;
+    readonly streamErrorEmitted: boolean;
+    readonly i18nStopReason?: DialogDisplayTextI18n;
+    constructor(args: {
+        message: string;
+        detail: string;
+        streamErrorEmitted: boolean;
+        i18nStopReason?: DialogDisplayTextI18n;
+    });
+}
 export declare function maybePrepareDiligenceAutoContinuePrompt(options: {
     dlg: Dialog;
     isRootDialog: boolean;
@@ -50,8 +62,10 @@ export declare function runLlmRequestWithRetry<T>(params: {
     retryBackoffMultiplier: number;
     retryMaxDelayMs: number;
     classifyFailure?: LlmFailureClassifier;
+    quirkFailureHandlerSession?: LlmFailureQuirkHandlerSession;
     canRetry: () => boolean;
     onRetry?: () => Promise<void> | void;
     onGiveUp?: () => Promise<void> | void;
+    onRetryStopped?: (reason: DialogLlmRetryExhaustedReason) => Promise<'continue' | 'stop'> | 'continue' | 'stop';
     doRequest: () => Promise<T>;
 }): Promise<T>;

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

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LlmRetryStoppedError = void 0;
+exports.LlmRequestFailedError = exports.LlmRetryStoppedError = void 0;
 exports.maybePrepareDiligenceAutoContinuePrompt = maybePrepareDiligenceAutoContinuePrompt;
 exports.suspendForKeepGoingBudgetExhausted = suspendForKeepGoingBudgetExhausted;
 exports.validateFuncToolArguments = validateFuncToolArguments;
@@ -50,6 +50,8 @@ const driver_messages_1 = require("../../runtime/driver-messages");
 const work_language_1 = require("../../runtime/work-language");
 const tool_1 = require("../../tool");
 const api_quirks_1 = require("../api-quirks");
+const gen_1 = require("../gen");
+const stop_reason_i18n_1 = require("../stop-reason-i18n");
 class LlmRetryStoppedError extends Error {
     constructor(reason, message) {
         super(message);
@@ -58,6 +60,16 @@ class LlmRetryStoppedError extends Error {
     }
 }
 exports.LlmRetryStoppedError = LlmRetryStoppedError;
+class LlmRequestFailedError extends Error {
+    constructor(args) {
+        super(args.message);
+        this.name = 'LlmRequestFailedError';
+        this.detail = args.detail;
+        this.streamErrorEmitted = args.streamErrorEmitted;
+        this.i18nStopReason = args.i18nStopReason;
+    }
+}
+exports.LlmRequestFailedError = LlmRequestFailedError;
 function isNodeErrorWithCode(error) {
     return error instanceof Error && 'code' in error;
 }
@@ -616,6 +628,7 @@ function buildLlmRetryExhaustedReason(args) {
         kind: 'llm_retry_stopped',
         error: args.errorText,
         display: args.display,
+        recoveryAction: args.recoveryAction ?? { kind: 'none' },
     };
 }
 async function runLlmRequestWithRetry(params) {
@@ -626,7 +639,7 @@ async function runLlmRequestWithRetry(params) {
     const retryMaxDelayMs = normalizeRetryMaxDelayMs(params.retryMaxDelayMs, Math.max(retryInitialDelayMs, retryConservativeDelayMs));
     const retryFlowStartedAtMs = Date.now();
     let activeRetryContext;
-    const quirkFailureHandler = (0, api_quirks_1.createLlmFailureQuirkHandlerSession)(params.providerConfig);
+    const quirkFailureHandler = params.quirkFailureHandlerSession ?? (0, api_quirks_1.createLlmFailureQuirkHandlerSession)(params.providerConfig);
     let policyRetryCount = 0;
     for (let attempt = 0;; attempt++) {
         try {
@@ -647,6 +660,7 @@ async function runLlmRequestWithRetry(params) {
                 });
             }
             const res = await params.doRequest();
+            quirkFailureHandler?.onRequestSucceeded?.();
             decaySmartRateAdaptiveState({
                 providerId: params.provider,
                 modelId: params.modelId,
@@ -672,6 +686,9 @@ async function runLlmRequestWithRetry(params) {
             if (params.abortSignal?.aborted) {
                 throw err;
             }
+            if (err instanceof gen_1.LlmStreamErrorEmittedError) {
+                throw err;
+            }
             const defaultFailure = classifyLlmFailure(err, params.classifyFailure);
             const handledFailure = applyQuirkFailureHandling(defaultFailure, quirkFailureHandler?.onFailure({
                 provider: params.provider,
@@ -699,6 +716,7 @@ async function runLlmRequestWithRetry(params) {
                 policyRetryCount,
                 failureKind: failure.kind,
                 quirkHandling: handledFailure.handling.kind,
+                quirkSource: handledFailure.handling.sourceQuirk,
                 status: failure.status,
                 code: failure.code,
                 errorCode,
@@ -720,13 +738,26 @@ async function runLlmRequestWithRetry(params) {
                         errorText: detail,
                     },
                 });
+                let streamErrorEmitted = false;
                 try {
                     await params.dlg.streamError(detail);
+                    streamErrorEmitted = true;
                 }
                 catch {
                     // best-effort
                 }
-                throw new Error(`Provider '${params.provider}' rejected the request: ${failure.message}`);
+                throw new LlmRequestFailedError({
+                    message: `Provider '${params.provider}' rejected the request: ${failure.message}`,
+                    detail,
+                    streamErrorEmitted,
+                    i18nStopReason: (0, stop_reason_i18n_1.buildHumanSystemStopReasonTextI18n)({
+                        detail,
+                        providerName: params.providerConfig.name.trim().length > 0
+                            ? params.providerConfig.name
+                            : params.provider,
+                        kind: 'provider_rejected',
+                    }),
+                });
             }
             const canRetry = failure.kind === 'retriable' && params.canRetry();
             const stopRetryByQuirk = handledFailure.handling.kind === 'give_up';
@@ -757,13 +788,32 @@ async function runLlmRequestWithRetry(params) {
                     const interruptionReason = buildLlmRetryExhaustedReason({
                         errorText: detail,
                         display,
+                        recoveryAction: handledFailure.handling.kind === 'give_up'
+                            ? handledFailure.handling.recoveryAction
+                            : undefined,
                     });
-                    emitLlmRetryEventBestEffort({
-                        dlg: params.dlg,
-                        phase: 'stopped',
-                        continueEnabled: false,
-                        reason: interruptionReason,
-                    });
+                    const retryStoppedDecision = params.onRetryStopped
+                        ? await params.onRetryStopped(interruptionReason)
+                        : 'stop';
+                    if (retryStoppedDecision === 'continue') {
+                        quirkFailureHandler?.onRecoveryActionUsed?.({
+                            action: interruptionReason.recoveryAction,
+                            sourceQuirk: handledFailure.handling.sourceQuirk,
+                        });
+                    }
+                    if (retryStoppedDecision !== 'continue') {
+                        // Keep the retry-stop progress event non-resumable by default. Do not flip this to
+                        // true just because the eventual finalized stopped state may allow manual Continue:
+                        // this event is emitted before the driver has fully unwound, cleared interrupted
+                        // markers, and persisted the terminal projection, so enabling Continue here would
+                        // advertise a resume action that is not yet safe or actually available.
+                        emitLlmRetryEventBestEffort({
+                            dlg: params.dlg,
+                            phase: 'stopped',
+                            continueEnabled: false,
+                            reason: interruptionReason,
+                        });
+                    }
                     log_1.log.warn('LLM retriable failure stopped retry flow', undefined, {
                         provider: params.provider,
                         dialogId: params.dlg.id.valueOf(),
@@ -780,6 +830,8 @@ async function runLlmRequestWithRetry(params) {
                         retryMaxDelayMs,
                         stopRetryByQuirk,
                         errorText: detail,
+                        retryStoppedDecision,
+                        quirkSource: handledFailure.handling.sourceQuirk,
                         summaryTextI18nOverride,
                     });
                     const interruptionDetail = formatLlmRetryExhaustedInterruptionDetail({
@@ -789,8 +841,10 @@ async function runLlmRequestWithRetry(params) {
                     });
                     retryStoppedError = new LlmRetryStoppedError(interruptionReason, interruptionDetail);
                 }
+                let streamErrorEmitted = false;
                 try {
                     await params.dlg.streamError(detail);
+                    streamErrorEmitted = true;
                 }
                 catch {
                     // best-effort
@@ -798,7 +852,18 @@ async function runLlmRequestWithRetry(params) {
                 if (retryStoppedError) {
                     throw retryStoppedError;
                 }
-                throw new Error(`LLM failed: ${failure.message}`);
+                throw new LlmRequestFailedError({
+                    message: `LLM failed: ${failure.message}`,
+                    detail,
+                    streamErrorEmitted,
+                    i18nStopReason: (0, stop_reason_i18n_1.buildHumanSystemStopReasonTextI18n)({
+                        detail,
+                        providerName: params.providerConfig.name.trim().length > 0
+                            ? params.providerConfig.name
+                            : params.provider,
+                        fallbackKind: 'request_failed',
+                    }),
+                });
             }
             const conservativeRampAttempt = Math.max(0, Math.floor(attempt / 10));
             const backoffMs = handledFailure.handling.kind === 'single_retry'

package/dist/llm/stop-reason-i18n.d.ts

@@ -0,0 +1,9 @@
+import type { DialogDisplayTextI18n } from '@longrun-ai/kernel/types/display-state';
+type HumanStopReasonKind = 'aborted' | 'transport_interrupted' | 'malformed_stream' | 'conflicting_stream' | 'invalid_tool_call' | 'incomplete_tool_call_stream' | 'invalid_tool_context' | 'provider_rejected' | 'request_failed' | 'identical_update_plan_loop' | 'generic';
+export declare function buildHumanSystemStopReasonTextI18n(args: {
+    detail: string;
+    providerName?: string;
+    kind?: Exclude<HumanStopReasonKind, 'generic'>;
+    fallbackKind?: Exclude<HumanStopReasonKind, 'generic'>;
+}): DialogDisplayTextI18n;
+export {};

package/dist/llm/stop-reason-i18n.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildHumanSystemStopReasonTextI18n = buildHumanSystemStopReasonTextI18n;
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim() !== '';
+}
+function formatUpstreamRawMessage(detail, language) {
+    const trimmed = detail.trim();
+    if (trimmed === '') {
+        return '';
+    }
+    return language === 'zh' ? `上游原文：${trimmed}` : `Upstream message: ${trimmed}`;
+}
+function inferHumanStopReasonKind(detail) {
+    const lower = detail.toLowerCase();
+    if (lower === 'aborted.' || lower === 'aborted') {
+        return 'aborted';
+    }
+    if (lower.includes('unexpected eof')) {
+        return 'transport_interrupted';
+    }
+    if (lower.includes('malformed stream event')) {
+        return 'malformed_stream';
+    }
+    if (lower.includes('stream overlap violation') || lower.startsWith('protocol violation:')) {
+        return 'conflicting_stream';
+    }
+    if (lower.includes('invalid tool call index')) {
+        return 'invalid_tool_call';
+    }
+    if (lower.includes('incomplete function-call stream state')) {
+        return 'incomplete_tool_call_stream';
+    }
+    if (lower.includes('tool_call_adjacency_violation') || lower.includes('tool call adjacency')) {
+        return 'invalid_tool_context';
+    }
+    if (lower.includes('provider projection') || lower.includes('context reconstruction')) {
+        return 'invalid_tool_context';
+    }
+    return 'generic';
+}
+function renderHumanStopReason(args) {
+    const providerText = isNonEmptyString(args.providerName)
+        ? args.language === 'zh'
+            ? `模型服务“${args.providerName}”`
+            : `LLM provider '${args.providerName}'`
+        : args.language === 'zh'
+            ? '模型服务'
+            : 'The LLM service';
+    switch (args.kind) {
+        case 'aborted':
+            return args.language === 'zh' ? '已中止。' : 'Aborted.';
+        case 'transport_interrupted':
+            return args.language === 'zh'
+                ? '与模型服务的连接意外中断，本次生成已停止。'
+                : 'The connection to the LLM service ended unexpectedly. This generation was stopped.';
+        case 'malformed_stream':
+            return args.language === 'zh'
+                ? '模型服务返回了格式异常的流式事件，本次生成已停止。'
+                : 'The LLM service returned a malformed stream event. This generation was stopped.';
+        case 'conflicting_stream':
+            return args.language === 'zh'
+                ? '模型服务返回了互相冲突的流式片段，本次生成已停止。'
+                : 'The LLM service returned conflicting stream segments. This generation was stopped.';
+        case 'invalid_tool_call':
+            return args.language === 'zh'
+                ? '模型服务返回了无效的工具调用信息，本次生成已停止。'
+                : 'The LLM service returned invalid tool-call data. This generation was stopped.';
+        case 'incomplete_tool_call_stream':
+            return args.language === 'zh'
+                ? '模型服务返回了不完整的工具调用流，本次生成已停止。'
+                : 'The LLM service returned an incomplete tool-call stream. This generation was stopped.';
+        case 'invalid_tool_context':
+            return args.language === 'zh'
+                ? '当前对话中的工具调用上下文不一致，本次生成已停止。'
+                : 'The tool-call context in this dialog became inconsistent. This generation was stopped.';
+        case 'provider_rejected':
+            return args.language === 'zh'
+                ? `${providerText}拒绝了这次请求，本次生成已停止。${formatUpstreamRawMessage(args.detail, 'zh')}`
+                : `${providerText} rejected this request. This generation was stopped. ${formatUpstreamRawMessage(args.detail, 'en')}`;
+        case 'request_failed':
+            return args.language === 'zh'
+                ? `本次生成因上游报错而停止。${formatUpstreamRawMessage(args.detail, 'zh')}`
+                : `This generation was stopped because the upstream service returned an error. ${formatUpstreamRawMessage(args.detail, 'en')}`;
+        case 'identical_update_plan_loop':
+            return args.language === 'zh'
+                ? '模型连续重复相同的 update_plan 结果，本次生成已停止。'
+                : 'The model repeated the same update_plan result multiple times. This generation was stopped.';
+        case 'generic':
+            return args.language === 'zh'
+                ? `本次生成已因系统错误停止。${formatUpstreamRawMessage(args.detail, 'zh')}`
+                : `This generation was stopped because of a system error. ${formatUpstreamRawMessage(args.detail, 'en')}`;
+    }
+}
+function buildHumanSystemStopReasonTextI18n(args) {
+    const inferredKind = args.kind ?? inferHumanStopReasonKind(args.detail);
+    const resolvedKind = inferredKind === 'generic' && args.fallbackKind !== undefined
+        ? args.fallbackKind
+        : inferredKind;
+    return {
+        zh: renderHumanStopReason({
+            language: 'zh',
+            kind: resolvedKind,
+            detail: args.detail,
+            providerName: args.providerName,
+        }),
+        en: renderHumanStopReason({
+            language: 'en',
+            kind: resolvedKind,
+            detail: args.detail,
+            providerName: args.providerName,
+        }),
+    };
+}

package/dist/persistence-errors.d.ts

@@ -0,0 +1,26 @@
+export type DomindsPersistenceFileSource = 'dialog_state' | 'dialog_latest' | 'dialog_metadata' | 'dialog_course_events' | 'reminder_state' | 'questions4human_state' | 'pending_subdialogs' | 'subdialog_responses' | 'subdialog_registry';
+export type DomindsPersistenceFileOperation = 'read' | 'parse';
+export type DomindsPersistenceFileFormat = 'yaml' | 'json' | 'jsonl';
+type DomindsPersistenceFileErrorArgs = {
+    message: string;
+    source: DomindsPersistenceFileSource;
+    operation: DomindsPersistenceFileOperation;
+    format: DomindsPersistenceFileFormat;
+    filePath: string;
+    eofLike: boolean;
+    lineNumber?: number;
+    cause?: unknown;
+};
+export declare class DomindsPersistenceFileError extends Error {
+    readonly code = "DOMINDS_PERSISTENCE_FILE_ERROR";
+    readonly source: DomindsPersistenceFileSource;
+    readonly operation: DomindsPersistenceFileOperation;
+    readonly format: DomindsPersistenceFileFormat;
+    readonly filePath: string;
+    readonly eofLike: boolean;
+    readonly lineNumber?: number;
+    readonly cause?: unknown;
+    constructor(args: DomindsPersistenceFileErrorArgs);
+}
+export declare function findDomindsPersistenceFileError(error: unknown): DomindsPersistenceFileError | undefined;
+export {};

package/dist/persistence-errors.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomindsPersistenceFileError = void 0;
+exports.findDomindsPersistenceFileError = findDomindsPersistenceFileError;
+class DomindsPersistenceFileError extends Error {
+    constructor(args) {
+        super(args.message);
+        this.code = 'DOMINDS_PERSISTENCE_FILE_ERROR';
+        this.name = 'DomindsPersistenceFileError';
+        this.source = args.source;
+        this.operation = args.operation;
+        this.format = args.format;
+        this.filePath = args.filePath;
+        this.eofLike = args.eofLike;
+        this.lineNumber = args.lineNumber;
+        this.cause = args.cause;
+    }
+}
+exports.DomindsPersistenceFileError = DomindsPersistenceFileError;
+function isObjectLike(value) {
+    return typeof value === 'object' && value !== null;
+}
+function readNestedError(value) {
+    if (typeof value === 'object' &&
+        value !== null &&
+        'error' in value &&
+        typeof value.error === 'object' &&
+        value.error !== null) {
+        return value.error;
+    }
+    return undefined;
+}
+function readCause(value) {
+    if (value instanceof Error) {
+        const withCause = value;
+        return withCause.cause;
+    }
+    if (typeof value === 'object' && value !== null && 'cause' in value) {
+        return value.cause;
+    }
+    return undefined;
+}
+function findDomindsPersistenceFileError(error) {
+    const queue = [error];
+    const visited = new Set();
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (current instanceof DomindsPersistenceFileError) {
+            return current;
+        }
+        if (!isObjectLike(current)) {
+            continue;
+        }
+        if (visited.has(current)) {
+            continue;
+        }
+        visited.add(current);
+        const nestedError = readNestedError(current);
+        if (nestedError !== undefined) {
+            queue.push(nestedError);
+        }
+        const cause = readCause(current);
+        if (cause !== undefined) {
+            queue.push(cause);
+        }
+    }
+    return undefined;
+}