dominds 1.23.3 → 1.23.4

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/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.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',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "1.23.3",
+  "version": "1.23.4",
   "description": "Dominds CLI and aggregation shell for the LongRun AI kernel/runtime packages.",
   "type": "commonjs",
   "publishConfig": {