dominds 1.23.2 → 1.23.4

package/dist/llm/gen/mock.js

@@ -379,10 +379,14 @@ responses:
         const matched = this.findMatchingResponse(db, content, role, context) ??
             this.buildReplyToolReminderAutoResponse(content, role, context);
         await delayWithAbort(matched?.delayMs ?? 0, abortSignal);
-        await receiver.thinkingStart();
-        await receiver.thinkingChunk(`[${modelName}] `);
-        await receiver.thinkingChunk(content.substring(0, 50) || '(empty)');
-        await receiver.thinkingFinish();
+        const thinkingText = matched?.omitDefaultThinking === true
+            ? (matched.thinkingResponse ?? '')
+            : (matched?.thinkingResponse ?? `[${modelName}] ${content.substring(0, 50) || '(empty)'}`);
+        if (thinkingText !== '') {
+            await receiver.thinkingStart();
+            await receiver.thinkingChunk(thinkingText);
+            await receiver.thinkingFinish();
+        }
         if (matched?.streamError) {
             if (matched.emitStreamErrorBeforeThrow && receiver.streamError) {
                 await receiver.streamError(matched.streamError);
@@ -470,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) {
@@ -488,12 +496,17 @@ responses:
                 this.buildReplyToolReminderAutoResponse(content, role, context);
             await delayWithAbort(matched?.delayMs ?? 0, abortSignal);
             const responseText = matched?.response ?? this.makeFallbackResponse(dbPath, content, role, modelName);
-            const thinking = {
-                type: 'thinking_msg',
-                role: 'assistant',
-                genseq,
-                content: `[${modelName}] ${content.substring(0, 100)}`,
-            };
+            const thinkingText = matched?.omitDefaultThinking === true
+                ? (matched.thinkingResponse ?? '')
+                : (matched?.thinkingResponse ?? `[${modelName}] ${content.substring(0, 100)}`);
+            const thinking = thinkingText === ''
+                ? undefined
+                : {
+                    type: 'thinking_msg',
+                    role: 'assistant',
+                    genseq,
+                    content: thinkingText,
+                };
             const saying = matched?.streamError || responseText !== ''
                 ? {
                     type: 'saying_msg',
@@ -566,8 +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: saying ? [thinking, saying, ...funcMsgs] : [thinking, ...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"));
@@ -48,7 +49,6 @@ const OPENAI_COMPATIBLE_REJECTED_REQUEST_ERROR_CODE = 'OPENAI_COMPATIBLE_REJECTE
 const KIMI_CODE_API_QUIRK = 'kimi-code';
 const KIMI_CODE_REASONING_EFFORTS = new Set(['low', 'medium', 'high']);
 const KIMI_CLI_CLOAK_API_QUIRK = 'kimi-cli-cloak';
-const KIMI_CLI_USER_AGENT = 'KimiCLI/1.41.0';
 const DISABLE_ASSISTANT_TOOL_CALL_REASONING_CONTENT_API_QUIRK = 'disable-assistant-tool-call-reasoning-content';
 const JSON_SCHEMA_COMBINATOR_KEYS = new Set([
     'anyOf',
@@ -578,7 +578,7 @@ function createOpenAiCompatibleClient(args) {
     };
     if (isKimiCliCloakProvider(args.providerConfig)) {
         options.defaultHeaders = {
-            'User-Agent': KIMI_CLI_USER_AGENT,
+            'User-Agent': `KimiCLI/Dominds/${dominds_running_version_1.DOMINDS_RUNNING_VERSION}`,
         };
     }
     else if (isKimiCodeProvider(args.providerConfig)) {
@@ -1476,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;
@@ -1483,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 : '{}';
@@ -1695,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)) {
@@ -1731,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';
@@ -1899,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' };
@@ -1908,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/context-health.d.ts

@@ -3,10 +3,7 @@ export type KernelDriverContextHealthDecision = Readonly<{
     kind: 'proceed';
 }> | Readonly<{
     kind: 'continue';
-    reason: 'caution_soft_remediation' | 'critical_countdown_remediation' | 'critical_force_new_course';
-}> | Readonly<{
-    kind: 'suspend';
-    reason: 'critical_wait_human';
+    reason: 'caution_soft_remediation' | 'critical_countdown_remediation' | 'critical_user_prompt_remediation' | 'critical_force_new_course';
 }>;
 export declare const KERNEL_DRIVER_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS = 5;
 export declare const KERNEL_DRIVER_DEFAULT_CAUTION_REMEDIATION_CADENCE_GENERATIONS = 10;
@@ -18,6 +15,8 @@ export declare function decideKernelDriverContextHealth(args: {
     dialogKey: string;
     snapshot?: ContextHealthSnapshot;
     hadUserPromptThisGen: boolean;
+    hadUserPromptInImmediateToolChain?: boolean;
+    userPromptCriticalRemediationAlreadyApplied?: boolean;
     canInjectPromptThisGen: boolean;
     cautionRemediationCadenceGenerations: number;
     criticalCountdownRemaining: number;

package/dist/llm/kernel-driver/context-health.js

@@ -111,8 +111,11 @@ function decideKernelDriverContextHealth(args) {
         if (args.criticalCountdownRemaining <= 0) {
             return { kind: 'continue', reason: 'critical_force_new_course' };
         }
-        return args.hadUserPromptThisGen
-            ? { kind: 'suspend', reason: 'critical_wait_human' }
+        if (args.userPromptCriticalRemediationAlreadyApplied === true) {
+            return { kind: 'proceed' };
+        }
+        return args.hadUserPromptThisGen || args.hadUserPromptInImmediateToolChain === true
+            ? { kind: 'continue', reason: 'critical_user_prompt_remediation' }
             : { kind: 'continue', reason: 'critical_countdown_remediation' };
     }
     const _exhaustive = snapshot.level;

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

@@ -4,19 +4,15 @@ export type DriveBaseContextParts = Readonly<{
     memories: readonly ChatMessage[];
     taskDocMsg?: ChatMessage;
     coursePrefixMsgs: readonly ChatMessage[];
-    dialogMsgsForContext: readonly ChatMessage[];
-}>;
-export type DriveEphemeralContextParts = Readonly<{
-    sideDialogResponseContextMsgs?: readonly ChatMessage[];
-    runtimeGuideMsgs?: readonly ChatMessage[];
+    historicalDialogMsgsForContext: readonly ChatMessage[];
+    currentTurnDialogMsgsForContext: readonly ChatMessage[];
 }>;
 export type DriveTailContextParts = Readonly<{
     renderedReminders: readonly ChatMessage[];
+    activeReplyObligationContext: readonly ChatMessage[];
+    runtimeGuideMsgs: readonly ChatMessage[];
 }>;
-export declare function buildDriveBaseContextMessages(parts: DriveBaseContextParts): ChatMessage[];
-export declare function appendDriveEphemeralContext(base: readonly ChatMessage[], parts: DriveEphemeralContextParts): ChatMessage[];
 export declare function assembleDriveContextMessages(args: {
     base: DriveBaseContextParts;
-    ephemeral: DriveEphemeralContextParts;
     tail: DriveTailContextParts;
 }): ChatMessage[];

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

@@ -1,36 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildDriveBaseContextMessages = buildDriveBaseContextMessages;
-exports.appendDriveEphemeralContext = appendDriveEphemeralContext;
 exports.assembleDriveContextMessages = assembleDriveContextMessages;
-function buildDriveBaseContextMessages(parts) {
-    return [
-        ...parts.prependedContextMessages,
-        ...parts.memories,
-        ...(parts.taskDocMsg ? [parts.taskDocMsg] : []),
-        ...parts.coursePrefixMsgs,
-        ...parts.dialogMsgsForContext,
-    ];
-}
-function appendDriveEphemeralContext(base, parts) {
-    const next = [...base];
-    if (Array.isArray(parts.sideDialogResponseContextMsgs) &&
-        parts.sideDialogResponseContextMsgs.length > 0) {
-        next.push(...parts.sideDialogResponseContextMsgs);
-    }
-    if (Array.isArray(parts.runtimeGuideMsgs) && parts.runtimeGuideMsgs.length > 0) {
-        next.push(...parts.runtimeGuideMsgs);
-    }
-    return next;
-}
 function assembleDriveContextMessages(args) {
-    const baseMsgs = [
+    return [
         ...args.base.prependedContextMessages,
         ...args.base.memories,
         ...(args.base.taskDocMsg ? [args.base.taskDocMsg] : []),
         ...args.base.coursePrefixMsgs,
+        ...args.base.historicalDialogMsgsForContext,
         ...args.tail.renderedReminders,
-        ...args.base.dialogMsgsForContext,
+        ...args.tail.activeReplyObligationContext,
+        ...args.tail.runtimeGuideMsgs,
+        ...args.base.currentTurnDialogMsgsForContext,
     ];
-    return appendDriveEphemeralContext(baseMsgs, args.ephemeral);
 }