dominds 1.13.2 → 1.15.2

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

@@ -105,7 +105,7 @@ function resolveAppRunControlSource(args) {
     if (!prompt) {
         return null;
     }
-    return Array.isArray(prompt.q4hAnswerCallIds) && prompt.q4hAnswerCallIds.length > 0
+    return typeof prompt.q4hAnswerCallId === 'string' && prompt.q4hAnswerCallId.trim() !== ''
         ? 'drive_dialog_by_user_answer'
         : 'drive_dlg_by_user_msg';
 }
@@ -250,7 +250,7 @@ async function resolveEffectivePrompt(dialog, humanPrompt) {
             userLanguageCode: upNext.userLanguageCode === 'zh' || upNext.userLanguageCode === 'en'
                 ? upNext.userLanguageCode
                 : undefined,
-            q4hAnswerCallIds: upNext.q4hAnswerCallIds,
+            q4hAnswerCallId: upNext.q4hAnswerCallId,
             tellaskReplyDirective: upNext.tellaskReplyDirective,
             skipTaskdoc: upNext.skipTaskdoc,
             subdialogReplyTarget: upNext.subdialogReplyTarget,
@@ -681,7 +681,7 @@ async function executeDriveRound(args) {
                 userLanguageCode: followUp.userLanguageCode === 'zh' || followUp.userLanguageCode === 'en'
                     ? followUp.userLanguageCode
                     : undefined,
-                q4hAnswerCallIds: followUp.q4hAnswerCallIds,
+                q4hAnswerCallId: followUp.q4hAnswerCallId,
                 tellaskReplyDirective: followUp.tellaskReplyDirective,
                 skipTaskdoc: followUp.skipTaskdoc,
                 subdialogReplyTarget: followUp.subdialogReplyTarget,

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

@@ -12,7 +12,7 @@ export type KernelDriverPolicyState = Readonly<{
     effectiveAgentTools: readonly Tool[];
     prependedContextMessages: readonly ChatMessage[];
     tellaskPolicy: KernelDriverTellaskPolicy;
-    allowTellaskSpecialFunctions: boolean;
+    allowTellaskFunctions: boolean;
     allowFunctionCalls: boolean;
 }>;
 export type KernelDriverPolicyViolationKind = 'tellask' | 'tool' | 'tellask_and_tool';

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

@@ -34,7 +34,7 @@ function buildKernelDriverPolicy(args) {
             effectiveAgentTools: agentTools,
             prependedContextMessages: [],
             tellaskPolicy: 'allow_any',
-            allowTellaskSpecialFunctions: true,
+            allowTellaskFunctions: true,
             allowFunctionCalls: true,
         };
     }
@@ -57,7 +57,7 @@ function buildKernelDriverPolicy(args) {
             },
         ],
         tellaskPolicy: 'deny_all',
-        allowTellaskSpecialFunctions: false,
+        allowTellaskFunctions: false,
         allowFunctionCalls: isConclusionPhase,
     };
 }
@@ -68,8 +68,8 @@ function validateKernelDriverPolicyInvariants(policy, language) {
     if (policy.tellaskPolicy !== 'deny_all') {
         return { ok: false, detail: 'FBR tellaskPolicy must be deny_all.' };
     }
-    if (policy.allowTellaskSpecialFunctions) {
-        return { ok: false, detail: 'FBR allowTellaskSpecialFunctions must be false.' };
+    if (policy.allowTellaskFunctions) {
+        return { ok: false, detail: 'FBR allowTellaskFunctions must be false.' };
     }
     if (policy.prependedContextMessages.length !== 1) {
         return { ok: false, detail: 'FBR must prepend exactly one no-tools notice message.' };

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

@@ -44,12 +44,10 @@ const id_1 = require("@longrun-ai/kernel/utils/id");
 const time_1 = require("@longrun-ai/kernel/utils/time");
 const evt_registry_1 = require("../../evt-registry");
 const log_1 = require("../../log");
-const persistence_1 = require("../../persistence");
 const problems_1 = require("../../problems");
 const driver_messages_1 = require("../../runtime/driver-messages");
 const work_language_1 = require("../../runtime/work-language");
 const tool_1 = require("../../tool");
-const id_2 = require("../../utils/id");
 function isNodeErrorWithCode(error) {
     return error instanceof Error && 'code' in error;
 }
@@ -157,34 +155,18 @@ async function maybePrepareDiligenceAutoContinuePrompt(options) {
 }
 async function suspendForKeepGoingBudgetExhausted(options) {
     const { dlg, maxInjectCount } = options;
-    const questionId = `q4h-${(0, id_2.generateDialogID)()}`;
     const language = dlg.getLastUserLanguageCode();
-    const question = {
-        id: questionId,
-        tellaskContent: (0, driver_messages_1.formatQ4HDiligencePushBudgetExhausted)(language, { maxInjectCount }),
-        askedAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
-        callSiteRef: {
-            course: dlg.currentCourse,
-            messageIndex: dlg.msgs.length,
-        },
-    };
-    await persistence_1.DialogPersistence.appendQuestion4HumanState(dlg.id, question);
-    const newQuestionEvent = {
-        type: 'new_q4h_asked',
-        question: {
-            id: question.id,
-            selfId: dlg.id.selfId,
-            tellaskContent: question.tellaskContent,
-            askedAt: question.askedAt,
-            callId: question.callId,
-            remainingCallIds: question.remainingCallIds,
-            callSiteRef: question.callSiteRef,
-            rootId: dlg.id.rootId,
-            agentId: dlg.agentId,
-            taskDocPath: dlg.taskDocPath,
-        },
-    };
-    (0, evt_registry_1.postDialogEvent)(dlg, newQuestionEvent);
+    const content = (0, driver_messages_1.formatQ4HDiligencePushBudgetExhausted)(language, { maxInjectCount });
+    const genseq = dlg.activeGenSeqOrUndefined ?? 1;
+    // This is informational only: it stops further automatic diligence pushes, but does not create
+    // a Q4H wait state and does not participate in revive gating.
+    await dlg.persistUiOnlyMarkdown(content, genseq);
+    (0, evt_registry_1.postDialogEvent)(dlg, {
+        type: 'ui_only_markdown_evt',
+        content,
+        course: dlg.currentCourse,
+        genseq,
+    });
 }
 function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);

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

@@ -357,25 +357,76 @@ async function supplyResponseToSupdialog(args) {
         });
         const immediateMirror = carryoverContent !== undefined
             ? {
-                type: 'tellask_carryover_result_msg',
+                type: 'tellask_carryover_msg',
                 role: 'user',
+                genseq: parentDialog.activeGenSeqOrUndefined ?? 1,
                 content: carryoverContent,
                 originCourse: carryoverOriginCourse,
+                carryoverCourse: parentDialog.currentCourse,
                 responderId: result.responderId,
                 callName: result.callName,
                 tellaskContent: result.tellaskContent,
                 status,
+                response: upstreamResponseText,
+                agentId: result.responderAgentId ?? result.responderId,
                 callId: resolvedCallId,
+                originMemberId: requesterId,
+                ...(result.callName === 'tellask'
+                    ? {
+                        mentionList: result.mentionList ?? [],
+                        sessionSlug: result.sessionSlug,
+                    }
+                    : result.callName === 'tellaskSessionless'
+                        ? {
+                            mentionList: result.mentionList ?? [],
+                        }
+                        : {}),
+                ...(calleeResponseRef !== undefined
+                    ? {
+                        calleeDialogId: subdialogId.selfId,
+                        calleeCourse: calleeResponseRef.course,
+                        calleeGenseq: calleeResponseRef.genseq,
+                    }
+                    : {
+                        calleeDialogId: subdialogId.selfId,
+                    }),
             }
             : {
                 type: 'tellask_result_msg',
                 role: 'tool',
-                responderId: result.responderId,
-                mentionList: result.mentionList,
-                tellaskContent: result.tellaskContent,
-                status,
+                genseq: parentDialog.activeGenSeqOrUndefined ?? 1,
                 callId: resolvedCallId,
+                callName: result.callName,
+                status,
                 content: upstreamResponseText,
+                call: result.callName === 'tellask'
+                    ? {
+                        tellaskContent: result.tellaskContent,
+                        mentionList: result.mentionList ?? [],
+                        ...(result.sessionSlug ? { sessionSlug: result.sessionSlug } : {}),
+                    }
+                    : result.callName === 'tellaskSessionless'
+                        ? {
+                            tellaskContent: result.tellaskContent,
+                            mentionList: result.mentionList ?? [],
+                        }
+                        : {
+                            tellaskContent: result.tellaskContent,
+                        },
+                responder: {
+                    responderId: result.responderId,
+                    agentId: result.responderAgentId ?? result.responderId,
+                    originMemberId: requesterId,
+                },
+                route: {
+                    calleeDialogId: subdialogId.selfId,
+                    ...(calleeResponseRef !== undefined
+                        ? {
+                            calleeCourse: calleeResponseRef.course,
+                            calleeGenseq: calleeResponseRef.genseq,
+                        }
+                        : {}),
+                },
             };
         await parentDialog.addChatMessages(immediateMirror);
         if (result.shouldRevive) {

package/dist/llm/kernel-driver/tellask-special.d.ts

@@ -1,6 +1,6 @@
 import { type TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
 import { Dialog } from '../../dialog';
-import type { ChatMessage, FuncCallMsg } from '../client';
+import type { ChatMessage, FuncCallMsg, FuncResultMsg } from '../client';
 import type { KernelDriverDriveCallbacks } from './types';
 export type TellaskRoutingParseResult = {
     type: 'A';
@@ -14,8 +14,8 @@ export type TellaskRoutingParseResult = {
     agentId: string;
 };
 declare const TELLASK_SPECIAL_FUNCTION_NAMES: readonly ["tellaskBack", "tellask", "tellaskSessionless", "replyTellask", "replyTellaskSessionless", "replyTellaskBack", "askHuman", "freshBootsReasoning"];
-export type TellaskSpecialFunctionName = (typeof TELLASK_SPECIAL_FUNCTION_NAMES)[number];
-export type TellaskSpecialCall = Readonly<{
+export type TellaskCallFunctionName = (typeof TELLASK_SPECIAL_FUNCTION_NAMES)[number];
+export type TellaskCall = Readonly<{
     callId: string;
     callName: 'tellaskBack';
     tellaskContent: string;
@@ -54,11 +54,17 @@ export type TellaskSpecialCall = Readonly<{
     tellaskContent: string;
     effort?: number;
 }>;
-export type TellaskSpecialCallParseIssue = Readonly<{
-    call: FuncCallMsg;
+export type ResolvedTellaskFunctionCall = Readonly<{
+    originalCall: FuncCallMsg;
+    call: TellaskCall;
+}>;
+export type InvalidTellaskFunctionCall = Readonly<{
+    originalCall: FuncCallMsg;
     error: string;
+    rawArgumentsText: string;
+    contextArguments: string;
 }>;
-export declare function isTellaskSpecialFunctionName(name: string): name is TellaskSpecialFunctionName;
+export declare function isTellaskCallFunctionName(name: string): name is TellaskCallFunctionName;
 export declare function loadLatestActiveTellaskReplyDirective(dialog: Dialog): Promise<TellaskReplyDirective | undefined>;
 export declare function deliverTellaskBackReplyFromDirective(args: {
     dlg: Dialog;
@@ -73,19 +79,39 @@ export declare function recoverPendingReplyTellaskCalls(args: {
     dlg: Dialog;
     callbacks: KernelDriverDriveCallbacks;
 }): Promise<number>;
-export declare function classifyTellaskSpecialFunctionCalls(funcCalls: readonly FuncCallMsg[], options?: {
-    allowedSpecials?: ReadonlySet<TellaskSpecialFunctionName>;
+export declare function resolveTellaskFunctionCalls(funcCalls: readonly FuncCallMsg[], options?: {
+    allowedSpecials?: ReadonlySet<TellaskCallFunctionName>;
 }): {
-    specialCalls: TellaskSpecialCall[];
+    validCalls: ResolvedTellaskFunctionCall[];
+    invalidCalls: InvalidTellaskFunctionCall[];
     normalCalls: FuncCallMsg[];
-    parseIssues: TellaskSpecialCallParseIssue[];
 };
-export declare function executeTellaskSpecialCalls(args: {
+export declare function formatTellaskInvalidCallResult(args: {
+    call: FuncCallMsg;
+    error: string;
+}): FuncResultMsg;
+export declare function formatPendingTellaskFuncResultContent(name: TellaskCallFunctionName, startedAtMs: number | null): string;
+export declare function formatResolvedAskHumanResultContent(): string;
+export declare function executeTellaskCalls(args: {
     dlg: Dialog;
-    calls: readonly TellaskSpecialCall[];
+    calls: readonly TellaskCall[];
     callbacks: KernelDriverDriveCallbacks;
 }): Promise<{
     toolOutputs: ChatMessage[];
     successfulReplyCallIds: string[];
 }>;
+export type TellaskFunctionRoundResult = Readonly<{
+    normalCalls: readonly FuncCallMsg[];
+    tellaskCallMessages: readonly FuncCallMsg[];
+    tellaskResults: readonly FuncResultMsg[];
+    toolOutputs: readonly ChatMessage[];
+    handledCallIds: readonly string[];
+    shouldStopAfterReplyTool: boolean;
+}>;
+export declare function processTellaskFunctionRound(args: {
+    dlg: Dialog;
+    funcCalls: readonly FuncCallMsg[];
+    allowedSpecials: ReadonlySet<TellaskCallFunctionName>;
+    callbacks: KernelDriverDriveCallbacks;
+}): Promise<TellaskFunctionRoundResult>;
 export {};