dominds 1.23.3 → 1.23.5

package/dist/dialog.d.ts

@@ -354,6 +354,25 @@ export declare abstract class Dialog {
         skipTaskdoc?: boolean;
         sideDialogReplyTarget: DialogSideDialogReplyTarget;
     }): DialogQueuedPromptState;
+    private persistPendingRuntimePrompt;
+    private runtimePromptCommon;
+    queueRuntimeReplyPrompt(options: {
+        prompt: string;
+        msgId: string;
+        grammar: 'markdown';
+        userLanguageCode?: LanguageCode;
+        tellaskReplyDirective: TellaskReplyDirective;
+        skipTaskdoc?: boolean;
+    }): Promise<DialogQueuedPromptState>;
+    queueRuntimeSideDialogPrompt(options: {
+        prompt: string;
+        msgId: string;
+        grammar: 'markdown';
+        userLanguageCode?: LanguageCode;
+        tellaskReplyDirective: TellaskReplyDirective;
+        skipTaskdoc?: boolean;
+        sideDialogReplyTarget: DialogSideDialogReplyTarget;
+    }): Promise<DialogQueuedPromptState>;
     hasUpNext(): boolean;
     peekUpNext(): DialogQueuedPromptState | undefined;
     takeUpNext(): DialogQueuedPromptState | undefined;
@@ -678,6 +697,7 @@ export declare abstract class DialogStore {
      * Start a new course in storage
      */
     startNewCourse(_dialog: Dialog, _newCoursePrompt: DialogRuntimePrompt): Promise<void>;
+    persistPendingRuntimePrompt(_dialog: Dialog, _prompt: DialogRuntimePrompt): Promise<void>;
     /**
      * Handle stream error
      */

package/dist/dialog.js

@@ -1018,6 +1018,65 @@ class Dialog {
         this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
         return merged;
     }
+    async persistPendingRuntimePrompt(prompt) {
+        await this.dlgStore.persistPendingRuntimePrompt(this, prompt);
+    }
+    runtimePromptCommon(options) {
+        const trimmed = options.prompt.trim();
+        if (!trimmed) {
+            throw new Error('Prompt is required to queue runtime prompt');
+        }
+        return {
+            prompt: trimmed,
+            msgId: options.msgId,
+            grammar: options.grammar,
+            userLanguageCode: options.userLanguageCode ?? this._lastUserLanguageCode,
+            origin: 'runtime',
+            runControl: undefined,
+        };
+    }
+    async queueRuntimeReplyPrompt(options) {
+        const common = this.runtimePromptCommon(options);
+        const created = {
+            ...common,
+            kind: 'new_course_runtime_reply',
+            tellaskReplyDirective: options.tellaskReplyDirective,
+            skipTaskdoc: options.skipTaskdoc,
+        };
+        this.enqueueQueuedPromptState(created);
+        await this.persistPendingRuntimePrompt({
+            content: created.prompt,
+            msgId: created.msgId,
+            grammar: created.grammar ?? 'markdown',
+            userLanguageCode: created.userLanguageCode,
+            origin: 'runtime',
+            tellaskReplyDirective: created.tellaskReplyDirective,
+            skipTaskdoc: created.skipTaskdoc,
+        });
+        return created;
+    }
+    async queueRuntimeSideDialogPrompt(options) {
+        const common = this.runtimePromptCommon(options);
+        const created = {
+            ...common,
+            kind: 'new_course_runtime_sideDialog',
+            tellaskReplyDirective: options.tellaskReplyDirective,
+            skipTaskdoc: options.skipTaskdoc,
+            sideDialogReplyTarget: options.sideDialogReplyTarget,
+        };
+        this.enqueueQueuedPromptState(created);
+        await this.persistPendingRuntimePrompt({
+            content: created.prompt,
+            msgId: created.msgId,
+            grammar: created.grammar ?? 'markdown',
+            userLanguageCode: created.userLanguageCode,
+            origin: 'runtime',
+            tellaskReplyDirective: created.tellaskReplyDirective,
+            skipTaskdoc: created.skipTaskdoc,
+            sideDialogReplyTarget: created.sideDialogReplyTarget,
+        });
+        return created;
+    }
     hasUpNext() {
         return this._upNextQueue.length > 0;
     }
@@ -1905,6 +1964,7 @@ class DialogStore {
      * Start a new course in storage
      */
     async startNewCourse(_dialog, _newCoursePrompt) { }
+    async persistPendingRuntimePrompt(_dialog, _prompt) { }
     /**
      * Handle stream error
      */

package/dist/llm/defaults.yaml

@@ -581,6 +581,7 @@ providers:
         context_window: '204K'
       glm-5.1:
         name: GLM-5.1
+        optimal_max_tokens: 180000
         supports_thinking: true
         default_thinking: true
         supports_image_input: false
@@ -590,6 +591,7 @@ providers:
         context_window: '256K'
       glm-4.7:
         name: GLM-4.7
+        optimal_max_tokens: 180000
         supports_thinking: true
         default_thinking: false
         supports_image_input: false

package/dist/llm/gen/anthropic.js

@@ -1955,9 +1955,13 @@ class AnthropicGen {
             completionTokens,
             totalTokens: promptTokens + completionTokens,
         };
+        const messages = anthropicToChatMessages(response, genseq, forceJsonResponse ? ANTHROPIC_JSON_RESPONSE_TOOL_NAME : undefined);
+        const orderedOutputs = outputs.length > 0
+            ? [...outputs, ...messages.map((message) => ({ kind: 'message', message }))]
+            : [];
         return {
-            messages: anthropicToChatMessages(response, genseq, forceJsonResponse ? ANTHROPIC_JSON_RESPONSE_TOOL_NAME : undefined),
-            ...(outputs.length > 0 ? { outputs } : {}),
+            messages,
+            ...(orderedOutputs.length > 0 ? { outputs: orderedOutputs } : {}),
             usage,
             llmGenModel: returnedModel,
         };

package/dist/llm/gen/mock.js

@@ -474,6 +474,10 @@ responses:
                 : `mock_func_${String(i + 1)}_${call.name}`;
             await receiver.funcCall(callId, call.name, this.normalizeFuncCallArgs(call.arguments));
         }
+        const invalidFuncCalls = matched?.invalidFuncCalls ?? [];
+        for (const call of invalidFuncCalls) {
+            await receiver.invalidFuncCall?.(call);
+        }
         return { usage, llmGenModel: modelName };
     }
     async genMoreMessages(providerConfig, agent, systemPrompt, _funcTools, _requestContext, context, genseq, abortSignal) {
@@ -575,14 +579,28 @@ responses:
                     arguments: this.normalizeFuncCallArgs(call.arguments),
                 };
             }) ?? [];
+            const invalidFuncCalls = matched?.invalidFuncCalls ?? [];
+            const invalidFuncCallOutputs = invalidFuncCalls.map((call) => ({
+                kind: 'invalid_func_call',
+                call,
+            }));
+            const messages = thinking !== undefined
+                ? saying
+                    ? [thinking, saying, ...funcMsgs]
+                    : [thinking, ...funcMsgs]
+                : saying
+                    ? [saying, ...funcMsgs]
+                    : [...funcMsgs];
             return {
-                messages: thinking !== undefined
-                    ? saying
-                        ? [thinking, saying, ...funcMsgs]
-                        : [thinking, ...funcMsgs]
-                    : saying
-                        ? [saying, ...funcMsgs]
-                        : [...funcMsgs],
+                messages,
+                ...(invalidFuncCallOutputs.length > 0
+                    ? {
+                        outputs: [
+                            ...messages.map((message) => ({ kind: 'message', message })),
+                            ...invalidFuncCallOutputs,
+                        ],
+                    }
+                    : {}),
                 usage,
                 llmGenModel: modelName,
             };

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

@@ -14,7 +14,7 @@ import type { ChatCompletion, ChatCompletionChunk, ChatCompletionMessageParam }
 import type { Team } from '../../team';
 import type { FuncTool } from '../../tool';
 import type { ChatMessage, ModelInfo, ProviderConfig } from '../client';
-import { type LlmBatchResult, type LlmFailureDisposition, type LlmGenerator, type LlmRequestContext, type LlmStreamReceiver, type LlmStreamResult } from '../gen';
+import { type LlmBatchOutput, type LlmBatchResult, type LlmFailureDisposition, type LlmGenerator, type LlmRequestContext, type LlmStreamReceiver, type LlmStreamResult } from '../gen';
 type OpenAiCompatibleChatExtraParams = {
     thinking?: boolean | Record<string, unknown>;
     reasoning_effort?: NonNullable<Team.ModelParams['openai-compatible']>['reasoning_effort'];
@@ -48,6 +48,7 @@ export declare function consumeOpenAiCompatibleChatCompletionStreamForTest(args:
     abortSignal?: AbortSignal;
 }): Promise<LlmStreamResult>;
 export declare function chatCompletionToChatMessagesForTest(response: ChatCompletion, genseq: number): ChatMessage[];
+export declare function chatCompletionToBatchOutputsForTest(response: ChatCompletion, genseq: number): LlmBatchOutput[];
 export declare class OpenAiCompatibleGen implements LlmGenerator {
     get apiType(): string;
     classifyFailure(error: unknown): LlmFailureDisposition | undefined;

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

@@ -22,6 +22,7 @@ exports.wrapOpenAiCompatibleRejectedRequestErrorForTest = wrapOpenAiCompatibleRe
 exports.buildOpenAiCompatibleRequestMessagesWrapper = buildOpenAiCompatibleRequestMessagesWrapper;
 exports.consumeOpenAiCompatibleChatCompletionStreamForTest = consumeOpenAiCompatibleChatCompletionStreamForTest;
 exports.chatCompletionToChatMessagesForTest = chatCompletionToChatMessagesForTest;
+exports.chatCompletionToBatchOutputsForTest = chatCompletionToBatchOutputsForTest;
 const events_1 = require("events");
 const fs_1 = require("fs");
 const promises_1 = __importDefault(require("fs/promises"));
@@ -1475,6 +1476,24 @@ function throwOpenAiCompatibleMalformedBatchToolCall(detail) {
     log.error(message, error);
     throw error;
 }
+function buildInvalidStreamedToolFunctionNameCall(state) {
+    return {
+        provider: 'openai-compatible',
+        callId: state.callId,
+        detail: `OPENAI-COMPATIBLE missing streamed tool function name for callId=${state.callId}`,
+        toolCallIndex: state.index,
+        rawArgumentsText: state.argsJson,
+    };
+}
+function buildInvalidToolFunctionNameCall(args) {
+    return {
+        provider: 'openai-compatible',
+        callId: args.callId,
+        detail: `OPENAI-COMPATIBLE missing tool function name for callId=${args.callId}`,
+        toolCallIndex: args.toolCallIndex,
+        rawArgumentsText: args.rawArgumentsText,
+    };
+}
 async function maybeEmitFuncCall(state, receiver, genseq) {
     if (state.emitted)
         return;
@@ -1482,17 +1501,32 @@ async function maybeEmitFuncCall(state, receiver, genseq) {
         state.callId = synthesizeCallId(genseq, state.index);
     }
     if (state.name.trim().length === 0) {
-        const detail = `OPENAI-COMPATIBLE missing streamed tool function name for callId=${state.callId}`;
+        if (state.argsJson.trim().length === 0) {
+            log.warn('OPENAI-COMPATIBLE ignored empty streamed tool call placeholder', undefined, {
+                callId: state.callId,
+                index: state.index,
+            });
+            state.emitted = true;
+            return;
+        }
+        const invalidCall = buildInvalidStreamedToolFunctionNameCall(state);
+        const detail = invalidCall.detail;
         log.error(detail, new Error('openai_compatible_missing_tool_call_name'), {
             callId: state.callId,
+            index: state.index,
         });
-        if (receiver.streamError) {
-            await receiver.streamError(detail);
+        if (!receiver.invalidFuncCall) {
+            if (receiver.streamError) {
+                await receiver.streamError(detail);
+            }
+            throw buildOpenAiCompatibleStreamError({
+                detail,
+                kind: 'invalid_tool_call',
+            });
         }
-        throw buildOpenAiCompatibleStreamError({
-            detail,
-            kind: 'invalid_tool_call',
-        });
+        state.emitted = true;
+        await receiver.invalidFuncCall(invalidCall);
+        return;
     }
     state.emitted = true;
     const args = state.argsJson.trim().length > 0 ? state.argsJson : '{}';
@@ -1694,25 +1728,27 @@ async function consumeOpenAiCompatibleChatCompletionStreamForTest(args) {
         abortSignal: args.abortSignal,
     });
 }
-function chatCompletionToChatMessages(response, genseq) {
-    const out = [];
+function chatCompletionToBatchOutputs(response, genseq) {
+    const outputs = [];
     const choice = response.choices && response.choices.length > 0 ? response.choices[0] : undefined;
     const msg = choice ? choice.message : undefined;
     if (!msg)
-        return out;
+        return outputs;
     const reasoningContent = extractReasoningContentField(msg);
     if (reasoningContent && reasoningContent.length > 0) {
-        out.push({
+        const message = {
             type: 'thinking_msg',
             role: 'assistant',
             genseq,
             content: reasoningContent,
             reasoning: buildReasoningPayloadFromText(reasoningContent),
-        });
+        };
+        outputs.push({ kind: 'message', message });
     }
     const content = typeof msg.content === 'string' ? msg.content : null;
     if (content && content.length > 0) {
-        out.push({ type: 'saying_msg', role: 'assistant', genseq, content });
+        const message = { type: 'saying_msg', role: 'assistant', genseq, content };
+        outputs.push({ kind: 'message', message });
     }
     const toolCalls = msg.tool_calls;
     if (Array.isArray(toolCalls)) {
@@ -1730,23 +1766,48 @@ function chatCompletionToChatMessages(response, genseq) {
             const name = typeof call.function?.name === 'string' ? call.function.name : '';
             const args = typeof call.function?.arguments === 'string' ? call.function.arguments : '';
             if (name.trim().length === 0) {
-                throwOpenAiCompatibleMalformedBatchToolCall(`missing tool function name for callId=${callId}`);
+                const invalidCall = buildInvalidToolFunctionNameCall({
+                    callId,
+                    toolCallIndex: index,
+                    rawArgumentsText: args,
+                });
+                log.error(invalidCall.detail, new Error('openai_compatible_missing_tool_call_name'), {
+                    callId,
+                    index,
+                });
+                outputs.push({ kind: 'invalid_func_call', call: invalidCall });
+                continue;
             }
-            out.push({
+            const message = {
                 type: 'func_call_msg',
                 role: 'assistant',
                 genseq,
                 id: callId,
                 name,
                 arguments: args,
-            });
+            };
+            outputs.push({ kind: 'message', message });
         }
     }
+    return outputs;
+}
+function batchOutputsToChatMessages(outputs) {
+    return outputs
+        .filter((output) => {
+        return output.kind === 'message';
+    })
+        .map((output) => output.message);
+}
+function chatCompletionToChatMessages(response, genseq) {
+    const out = batchOutputsToChatMessages(chatCompletionToBatchOutputs(response, genseq));
     return out;
 }
 function chatCompletionToChatMessagesForTest(response, genseq) {
     return chatCompletionToChatMessages(response, genseq);
 }
+function chatCompletionToBatchOutputsForTest(response, genseq) {
+    return chatCompletionToBatchOutputs(response, genseq);
+}
 class OpenAiCompatibleGen {
     get apiType() {
         return 'openai-compatible';
@@ -1898,7 +1959,15 @@ class OpenAiCompatibleGen {
             const response = await client.chat.completions.create(payload, {
                 ...(abortSignal ? { signal: abortSignal } : {}),
             });
-            const messagesOut = chatCompletionToChatMessages(response, genseq);
+            const batchOutputs = chatCompletionToBatchOutputs(response, genseq);
+            const messagesOut = batchOutputsToChatMessages(batchOutputs);
+            const orderedOutputs = outputs.length > 0
+                ? [
+                    ...outputs,
+                    ...messagesOut.map((message) => ({ kind: 'message', message })),
+                    ...batchOutputs.filter((output) => output.kind !== 'message'),
+                ]
+                : batchOutputs;
             const usage = response.usage
                 ? tryExtractChatUsage(response.usage)
                 : { kind: 'unavailable' };
@@ -1907,7 +1976,7 @@ class OpenAiCompatibleGen {
                 : undefined;
             return {
                 messages: messagesOut,
-                ...(outputs.length > 0 ? { outputs } : {}),
+                ...(orderedOutputs.length > 0 ? { outputs: orderedOutputs } : {}),
                 usage,
                 ...(model ? { llmGenModel: model } : {}),
             };

package/dist/llm/gen.d.ts

@@ -20,6 +20,9 @@ export declare class LlmStreamErrorEmittedError extends Error {
 export type LlmBatchOutput = {
     kind: 'message';
     message: ChatMessage;
+} | {
+    kind: 'invalid_func_call';
+    call: LlmInvalidFuncCall;
 } | {
     kind: 'web_search_call';
     call: LlmWebSearchCall;
@@ -138,6 +141,14 @@ export type OpenAiResponsesCustomToolCall = {
     detail?: string;
 };
 export type OpenAiResponsesNativeToolCall = OpenAiResponsesNonCustomNativeToolCall | OpenAiResponsesCustomToolCall;
+export type LlmInvalidFuncCall = Readonly<{
+    provider: string;
+    callId: string;
+    detail: string;
+    toolCallIndex?: number;
+    rawFunctionName?: string;
+    rawArgumentsText?: string;
+}>;
 export interface LlmStreamReceiver {
     thinkingStart: () => Promise<void>;
     thinkingChunk: (chunk: string) => Promise<void>;
@@ -149,6 +160,7 @@ export interface LlmStreamReceiver {
         rawCallId?: string;
         effectiveCallId?: string;
     }) => Promise<void>;
+    invalidFuncCall?: (call: LlmInvalidFuncCall) => Promise<void>;
     webSearchCall?: (call: LlmWebSearchCall) => Promise<void>;
     nativeToolCall?: (call: OpenAiResponsesNativeToolCall) => Promise<void>;
     toolResultImageIngest?: (ingest: ToolResultImageIngest) => Promise<void>;

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

@@ -205,6 +205,9 @@ async function persistAndEmitRuntimeGuide(dlg, content) {
         role: 'assistant',
         content,
     });
+    await persistAndPostRuntimeGuide(dlg, content);
+}
+async function persistAndPostRuntimeGuide(dlg, content) {
     await persistence_1.DialogPersistence.persistRuntimeGuide(dlg, content, dlg.activeGenSeq);
     (0, evt_registry_1.postDialogEvent)(dlg, {
         type: 'runtime_guide_evt',
@@ -301,6 +304,9 @@ function hasMeaningfulBatchOutput(batch) {
             if (output.kind === 'user_image_ingest') {
                 continue;
             }
+            if (output.kind === 'invalid_func_call') {
+                return true;
+            }
             if (output.kind !== 'message') {
                 return true;
             }
@@ -910,6 +916,75 @@ async function emitAssistantSaying(dlg, content) {
     await dlg.sayingChunk(content);
     await dlg.sayingFinish();
 }
+function formatInvalidFuncCallRuntimeGuide(language, call) {
+    const rawName = call.rawFunctionName !== undefined && call.rawFunctionName.trim() !== ''
+        ? call.rawFunctionName.trim()
+        : '<missing>';
+    const rawArguments = call.rawArgumentsText !== undefined && call.rawArgumentsText.trim() !== ''
+        ? call.rawArgumentsText
+        : '<empty>';
+    const indexLine = call.toolCallIndex === undefined ? undefined : `- toolCallIndex: ${String(call.toolCallIndex)}`;
+    if (language === 'en') {
+        return [
+            '[Runtime notice] The previous model output contained an invalid tool-call payload that could not be represented as a normal provider tool call in the next generation context.',
+            '',
+            `- provider: ${call.provider}`,
+            `- callId: ${call.callId}`,
+            `- problem: ${call.detail}`,
+            `- rawFunctionName: ${rawName}`,
+            `- rawArgumentsText:`,
+            '```json',
+            rawArguments,
+            '```',
+            ...(indexLine === undefined ? [] : [indexLine]),
+            '',
+            'Treat that payload as failed. Do not assume the tool ran. Continue from the current task, and if a tool call is still needed, emit a new valid tool call with a non-empty function name and valid arguments.',
+        ]
+            .filter((line) => line.length > 0)
+            .join('\n');
+    }
+    return [
+        '[运行时提示] 上一轮模型输出包含一个无效工具调用载荷，无法按正常 provider tool call 形态进入下一轮生成上下文。',
+        '',
+        `- provider: ${call.provider}`,
+        `- callId: ${call.callId}`,
+        `- 问题: ${call.detail}`,
+        `- rawFunctionName: ${rawName}`,
+        `- rawArgumentsText:`,
+        '```json',
+        rawArguments,
+        '```',
+        ...(indexLine === undefined ? [] : [indexLine]),
+        '',
+        '请把该载荷视为调用失败，不要假设工具已经执行。继续当前任务；如果仍需要调用工具，请重新发起一个函数名非空、参数有效的新工具调用。',
+    ]
+        .filter((line) => line.length > 0)
+        .join('\n');
+}
+async function persistInvalidFuncCallRuntimeGuide(args) {
+    const { dlg, call } = args;
+    const sourceText = args.source === 'streamed' ? 'streamed' : 'batch';
+    log_1.log.error(`kernel-driver received invalid ${sourceText} function call payload`, new Error(`kernel_driver_invalid_${sourceText}_function_call_payload`), {
+        rootId: dlg.id.rootId,
+        selfId: dlg.id.selfId,
+        course: dlg.activeGenCourseOrUndefined ?? dlg.currentCourse,
+        genseq: dlg.activeGenSeq,
+        callId: call.callId,
+        provider: call.provider,
+        detail: call.detail,
+        toolCallIndex: call.toolCallIndex,
+    });
+    if (args.emitStreamError) {
+        await dlg.streamError(call.detail);
+    }
+    const content = formatInvalidFuncCallRuntimeGuide((0, work_language_1.getWorkLanguage)(), call);
+    args.newMsgs.push({
+        type: 'transient_guide_msg',
+        role: 'assistant',
+        content,
+    });
+    await persistAndPostRuntimeGuide(dlg, content);
+}
 function resolveFuncToolFollowupMode(tool) {
     return tool?.followupMode ?? 'immediate';
 }
@@ -1895,6 +1970,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     const streamedFuncCalls = [];
                     let sawWebSearchSideChannelOutput = false;
                     let sawNativeToolSideChannelOutput = false;
+                    let invalidFuncCallCount = 0;
                     const streamOrBatch = async () => {
                         let batchAttemptCourse;
                         let batchAttemptCheckpointOffset;
@@ -1911,6 +1987,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             });
                             sawWebSearchSideChannelOutput = false;
                             sawNativeToolSideChannelOutput = false;
+                            invalidFuncCallCount = 0;
                             streamedFuncCalls.length = 0;
                             newMsgs.length = 0;
                         };
@@ -2004,6 +2081,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             sawWebSearchSideChannelOutput = false;
                             sawNativeToolSideChannelOutput = false;
                             streamedFuncCalls.length = 0;
+                            invalidFuncCallCount = 0;
                             newMsgs.length = 0;
                         };
                         const receiver = {
@@ -2127,6 +2205,17 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                     arguments: argsStr,
                                 });
                             },
+                            invalidFuncCall: async (call) => {
+                                throwIfAborted(abortSignal, dlg);
+                                invalidFuncCallCount += 1;
+                                await persistInvalidFuncCallRuntimeGuide({
+                                    dlg,
+                                    call,
+                                    source: 'streamed',
+                                    newMsgs,
+                                    emitStreamError: true,
+                                });
+                            },
                             webSearchCall: async (call) => {
                                 throwIfAborted(abortSignal, dlg);
                                 sawWebSearchSideChannelOutput = true;
@@ -2177,6 +2266,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 sawWebSearchSideChannelOutput = false;
                                 sawNativeToolSideChannelOutput = false;
                                 streamedFuncCalls.length = 0;
+                                invalidFuncCallCount = 0;
                                 newMsgs.length = 0;
                                 const promptCacheKey = prepareLlmRequestContextKey();
                                 const streamResult = await llmGen.genToReceiver(providerCfg, agent, systemPrompt, funcTools, {
@@ -2192,6 +2282,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 const hasFunctionCall = streamedFuncCalls.length > 0;
                                 if (!hasFinishedMessageContent &&
                                     !hasFunctionCall &&
+                                    invalidFuncCallCount === 0 &&
                                     !sawWebSearchSideChannelOutput &&
                                     !sawNativeToolSideChannelOutput) {
                                     throw {
@@ -2259,6 +2350,17 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 }
                                 break;
                             }
+                            case 'invalid_func_call': {
+                                invalidFuncCallCount += 1;
+                                await persistInvalidFuncCallRuntimeGuide({
+                                    dlg,
+                                    call: output.call,
+                                    source: 'batch',
+                                    newMsgs,
+                                    emitStreamError: true,
+                                });
+                                break;
+                            }
                             case 'web_search_call': {
                                 sawWebSearchSideChannelOutput = true;
                                 await dlg.webSearchCall(projectLlmWebSearchCall(output.call));
@@ -2468,7 +2570,9 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     // warrant same-drive LLM reaction right away. Provider-native side-channel UI events are
                     // meaningful output, but they are not transcript/context inputs and therefore must not
                     // trigger another immediate generation round by themselves.
-                    const shouldStartImmediatePostToolGeneration = routed.hasImmediateFollowupToolCalls || routed.tellaskToolOutputs.length > 0;
+                    const shouldStartImmediatePostToolGeneration = routed.hasImmediateFollowupToolCalls ||
+                        routed.tellaskToolOutputs.length > 0 ||
+                        invalidFuncCallCount > 0;
                     if (!shouldStartImmediatePostToolGeneration) {
                         const healthFirst = await maybeContinueWithHealthPromptBeforeDiligence({
                             dlg,

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

@@ -23,6 +23,28 @@ const idle_reminder_wake_1 = require("./idle-reminder-wake");
 const reply_guidance_1 = require("./reply-guidance");
 const sideDialog_1 = require("./sideDialog");
 const tellask_special_1 = require("./tellask-special");
+async function queueReplyReminderFollowUp(args) {
+    if (args.followUp.kind === 'runtime_sideDialog_reply_reminder') {
+        await args.dialog.queueRuntimeSideDialogPrompt({
+            prompt: args.followUp.prompt,
+            msgId: args.followUp.msgId,
+            grammar: args.followUp.grammar ?? 'markdown',
+            userLanguageCode: args.followUp.userLanguageCode,
+            tellaskReplyDirective: args.followUp.tellaskReplyDirective,
+            skipTaskdoc: args.followUp.skipTaskdoc,
+            sideDialogReplyTarget: args.followUp.sideDialogReplyTarget,
+        });
+        return;
+    }
+    await args.dialog.queueRuntimeReplyPrompt({
+        prompt: args.followUp.prompt,
+        msgId: args.followUp.msgId,
+        grammar: args.followUp.grammar ?? 'markdown',
+        userLanguageCode: args.followUp.userLanguageCode,
+        tellaskReplyDirective: args.followUp.tellaskReplyDirective,
+        skipTaskdoc: args.followUp.skipTaskdoc,
+    });
+}
 function isReplyToolReminderPrompt(prompt) {
     return typeof prompt?.content === 'string' && (0, reply_prompt_copy_1.isReplyToolReminderPromptContent)(prompt.content);
 }
@@ -1084,6 +1106,18 @@ async function executeDriveRound(args) {
                 }
             }
             if (followUp) {
+                if (followUp.kind === 'runtime_reply_reminder' ||
+                    followUp.kind === 'runtime_sideDialog_reply_reminder') {
+                    await queueReplyReminderFollowUp({ dialog, followUp });
+                    args.scheduleDrive(dialog, {
+                        waitInQue: true,
+                        driveOptions: {
+                            source: 'kernel_driver_follow_up',
+                            reason: 'follow_up_prompt',
+                        },
+                    });
+                    return driveResult;
+                }
                 args.scheduleDrive(dialog, {
                     waitInQue: true,
                     driveOptions: {
@@ -1116,9 +1150,7 @@ async function executeDriveRound(args) {
                             case 'registered_assignment_update':
                             case 'new_course_runtime_guide':
                             case 'new_course_runtime_reply':
-                            case 'new_course_runtime_sideDialog':
-                            case 'runtime_reply_reminder':
-                            case 'runtime_sideDialog_reply_reminder': {
+                            case 'new_course_runtime_sideDialog': {
                                 const runtimeCommon = {
                                     ...common,
                                     origin: 'runtime',
@@ -1127,8 +1159,7 @@ async function executeDriveRound(args) {
                                         : { skipTaskdoc: followUp.skipTaskdoc }),
                                 };
                                 if (followUp.kind === 'registered_assignment_update' ||
-                                    followUp.kind === 'new_course_runtime_sideDialog' ||
-                                    followUp.kind === 'runtime_sideDialog_reply_reminder') {
+                                    followUp.kind === 'new_course_runtime_sideDialog') {
                                     const prompt = {
                                         ...runtimeCommon,
                                         tellaskReplyDirective: followUp.tellaskReplyDirective,
@@ -1136,8 +1167,7 @@ async function executeDriveRound(args) {
                                     };
                                     return prompt;
                                 }
-                                if (followUp.kind === 'new_course_runtime_reply' ||
-                                    followUp.kind === 'runtime_reply_reminder') {
+                                if (followUp.kind === 'new_course_runtime_reply') {
                                     const prompt = {
                                         ...runtimeCommon,
                                         tellaskReplyDirective: followUp.tellaskReplyDirective,

package/dist/log.js

@@ -78,6 +78,39 @@ const DETAIL_INSPECT_PROFILES = [
         maxStringLength: 192,
     },
 ];
+const LOG_KEY_PRIORITY = new Map([
+    'rootId',
+    'selfId',
+    'dialogId',
+    'course',
+    'genseq',
+    'callId',
+    'questionId',
+    'agentId',
+    'toolName',
+    'provider',
+    'model',
+    'dialogClass',
+    'status',
+    'error',
+    'detail',
+    'message',
+    'code',
+    'name',
+    'type',
+].map((key, index) => [key, index]));
+function compareLogObjectKeys(left, right) {
+    const leftPriority = LOG_KEY_PRIORITY.get(left);
+    const rightPriority = LOG_KEY_PRIORITY.get(right);
+    if (leftPriority !== undefined || rightPriority !== undefined) {
+        return (leftPriority ?? Number.MAX_SAFE_INTEGER) - (rightPriority ?? Number.MAX_SAFE_INTEGER);
+    }
+    const leftInternal = left.startsWith('_') || left.startsWith('__');
+    const rightInternal = right.startsWith('_') || right.startsWith('__');
+    if (leftInternal !== rightInternal)
+        return leftInternal ? 1 : -1;
+    return left.localeCompare(right);
+}
 function truncateText(value, maxChars, suffix) {
     if (maxChars <= 0) {
         return { text: '', truncated: value.length > 0 };
@@ -248,7 +281,7 @@ function pruneForLog(value, profile, depth, seen) {
             return { value: `[${ctorName} byteLength=${byteLen}]`, pruned: true };
         }
         const source = value;
-        const allKeys = Object.keys(source).sort();
+        const allKeys = Object.keys(source).sort(compareLogObjectKeys);
         const visibleKeys = allKeys.slice(0, profile.maxObjectKeys);
         const ctorName = getConstructorName(value);
         const reduced = {};
@@ -286,7 +319,7 @@ function inspectAdaptive(value, maxChars) {
             depth: null,
             breakLength: 120,
             compact: false,
-            sorted: true,
+            sorted: false,
             maxArrayLength: profile.maxArrayItems,
             maxStringLength: profile.maxStringLength,
         });

package/dist/persistence.d.ts

@@ -131,6 +131,7 @@ export declare class DiskFileDialogStore extends DialogStore {
      * Start new course (append-only JSONL + exceptional reminder persistence)
      */
     startNewCourse(dialog: Dialog, newCoursePrompt: DialogRuntimePrompt): Promise<void>;
+    persistPendingRuntimePrompt(dialog: Dialog, prompt: DialogRuntimePrompt): Promise<void>;
     /**
      * Persist reminder state (exceptional overwrite pattern)
      * Note: Event emission is handled by processReminderUpdates() in Dialog

package/dist/persistence.js

@@ -2573,9 +2573,20 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
      * Emit stream error for current generation lifecycle (uses active genseq when present)
      */
     async streamError(dialog, error) {
-        log_1.log.error(`Dialog stream error '${error}'`, new Error(), { dialog });
         const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
         const genseq = dialog.activeGenSeqOrUndefined;
+        log_1.log.error(`Dialog stream error '${error}'`, new Error(), {
+            dialogId: dialog.id.valueOf(),
+            rootId: dialog.id.rootId,
+            selfId: dialog.id.selfId,
+            course,
+            genseq,
+            agentId: dialog.agentId,
+            dialogClass: dialog.constructor.name,
+            status: dialog.status,
+            activeGeneration: dialog.hasActiveGeneration,
+            dialogSnapshot: dialog,
+        });
         // Enhanced stream error event with better error classification
         const streamErrorEvent = {
             type: 'stream_error_evt',
@@ -2628,6 +2639,18 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         };
         (0, evt_registry_1.postDialogEvent)(dialog, courseUpdateEvt);
     }
+    async persistPendingRuntimePrompt(dialog, prompt) {
+        if (prompt.origin !== 'runtime') {
+            throw new Error(`persistPendingRuntimePrompt invariant violation: pending prompt must have runtime origin for dialog=${dialog.id.valueOf()}`);
+        }
+        await DialogPersistence.mutateDialogLatest(dialog.id, () => ({
+            kind: 'patch',
+            patch: {
+                needsDrive: true,
+                pendingCourseStartPrompt: prompt,
+            },
+        }), dialog.status);
+    }
     /**
      * Persist reminder state (exceptional overwrite pattern)
      * Note: Event emission is handled by processReminderUpdates() in Dialog

package/dist/runtime/driver-messages.js

@@ -217,14 +217,14 @@ function formatReminderContextGuide(language) {
     if (language === 'zh') {
         return [
             `${formatSystemNoticePrefix(language)} 提醒项上下文块开始`,
-            '以下是当前可见提醒项的运行时上下文投影。由于当前 LLM Provider 通常不支持 role=environment，Dominds 默认把系统运行时提醒包装投影为 role=user；个别提醒项可由其 owner 按自身契约选择 role。无论最终 role 如何，它们都不是新的用户指令/诉求，也不是聊天正文。',
+            '以下是当前可见提醒项的运行时上下文投影。由于当前 LLM Provider 通常不支持 role=environment，Dominds 默认把系统运行时提醒包装投影为 role=user；个别提醒项可由其 owner 按自身契约选择 role。无论最终 role 如何，它们都不是用户的新诉求/指令，也不是聊天正文。',
             '在 WebUI 中，用户通过独立的 Reminder 小组件/面板项看到这些提醒，并能把它们和聊天正文区分开。',
             '请把提醒项作为工作集/状态参考；只有实际改变你的判断、计划或风险的信息，才需要提炼进后续有实质内容的对外回复。不要为了提醒项单独回复“收到/已了解/静默吸收”。',
         ].join('\n');
     }
     return [
         `${formatSystemNoticePrefix(language)} Reminder context block begins`,
-        'The following visible reminders are runtime-added context projections. Because current LLM providers usually do not support role=environment, Dominds projects default system-runtime reminder wrappers as role=user; individual reminder owners may choose the role required by their own contract. Regardless of their final role, these reminders are not new user instructions or requests, and not chat transcript text.',
+        'The following visible reminders are runtime-added context projections. Because current LLM providers usually do not support role=environment, Dominds projects default system-runtime reminder wrappers as role=user; individual reminder owners may choose the role required by their own contract. Regardless of their final role, these reminders are not new user requests/instructions, and not chat transcript text.',
         'In the WebUI, the user sees these reminders through a separate Reminder widget/panel item and can distinguish them from the chat transcript.',
         'Use reminders as workset/state references; only carry information into a later substantive outward reply when it materially changes your current judgment, plan, or risk. Do not send a standalone "acknowledged/noted/silently absorbed" reply for reminder items.',
     ].join('\n');
@@ -234,23 +234,27 @@ function formatReminderItemProjectionNote(language) {
 }
 function formatReminderContextFooter(language, followingState) {
     if (language === 'zh') {
-        const base = `${formatSystemNoticePrefix(language)} 提醒项上下文块结束。以上从“提醒项上下文块开始”到“提醒项上下文块结束”之间的提醒项均为系统提醒，并非用户指令；该块之外的后续对话消息不受此说明影响。`;
+        const base = `${formatSystemNoticePrefix(language)} 提醒项上下文块结束。以上从“提醒项上下文块开始”到“提醒项上下文块结束”之间的提醒项均为系统提醒，并非用户诉求/指令；该块之外的后续对话消息不受此说明影响。`;
         if (followingState === 'user_message') {
-            return `${base}本轮提醒项块之后会接着出现本轮新的用户消息；请以那条用户消息作为当前轮真实诉求。`;
+            return (`${base}本轮提醒项块之后会紧接一条本轮真实的新用户消息；后续消息是用户的新诉求/指令，不是提醒项投影。` +
+                '提醒项块说明到此为止，不得外溢到那条消息：不要把后续用户消息称为“系统提示/没有新消息”，也不要因为本块说明而降低它的指令优先级。' +
+                '请按那条用户消息的原始语义继续处理；若它要求更新你的职责、偏好或心智资产，应照常落实。');
         }
         if (followingState === 'runtime_notice') {
-            return `${base}本轮提醒项块之后会接着出现一条运行时提示；它不是新的用户诉求，请按其中的运行时要求继续推进。`;
+            return `${base}本轮提醒项块之后会接着出现一条运行时提示；它不是用户的新诉求/指令，请按其中的运行时要求继续推进。`;
         }
         return `${base}本轮没有新的用户消息或运行时提示；这是工具调用后的自动续推，请基于已有任务状态继续推进，不要把“没有新消息”理解为空系统提示。`;
     }
     const base = `${formatSystemNoticePrefix(language)} Reminder context block ends. The reminder items between ` +
         '"Reminder context block begins" and "Reminder context block ends" are system reminders, ' +
-        'not user instructions; this note does not apply to subsequent dialog messages outside this block. ';
+        'not user requests/instructions; this reminder-block guidance does not apply to subsequent dialog messages outside this block. ';
     if (followingState === 'user_message') {
-        return `${base}A new user message for this round follows this reminder block; treat that user message as the real current request.`;
+        return (`${base}A real new user message for this round immediately follows this reminder block; the following message is a new user request/instruction, not a reminder projection. ` +
+            'The reminder-block guidance ends here and must not spill over onto that message: do not label the following user message as a "system notice" or "no new message", and do not lower its instruction priority because of this block. ' +
+            'Handle that user message according to its original meaning; if it asks you to update your responsibilities, preferences, or mind assets, carry that out normally.');
     }
     if (followingState === 'runtime_notice') {
-        return `${base}A runtime notice follows this reminder block in this round; it is not a new user request, so follow that runtime guidance and continue the work.`;
+        return `${base}A runtime notice follows this reminder block in this round; it is not a new user request/instruction, so follow that runtime guidance and continue the work.`;
     }
     return `${base}There is no new user message or runtime notice in this round; this is an automatic continuation after a tool call. Continue from the existing task state, and do not interpret the absence of a new message as an empty system notice.`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "1.23.3",
+  "version": "1.23.5",
   "description": "Dominds CLI and aggregation shell for the LongRun AI kernel/runtime packages.",
   "type": "commonjs",
   "publishConfig": {
@@ -53,8 +53,8 @@
     "yaml": "^2.8.2",
     "zod": "^4.3.6",
     "@longrun-ai/codex-auth": "0.13.0",
-    "@longrun-ai/kernel": "1.13.1",
-    "@longrun-ai/shell": "1.13.1"
+    "@longrun-ai/kernel": "1.13.2",
+    "@longrun-ai/shell": "1.13.2"
   },
   "devDependencies": {
     "@types/node": "^25.3.5",