dominds 1.22.0 → 1.23.0

package/dist/llm/gen.d.ts

@@ -56,7 +56,6 @@ export interface LlmRequestContext {
     modelKey?: string;
     promptCacheKey?: string;
     toolUseRequirement?: 'none' | 'auto' | 'required';
-    knownFunctionCallIds?: ReadonlySet<string>;
 }
 export type ToolResultImageIngest = {
     toolCallId: string;
@@ -146,7 +145,10 @@ export interface LlmStreamReceiver {
     sayingStart: () => Promise<void>;
     sayingChunk: (chunk: string) => Promise<void>;
     sayingFinish: () => Promise<void>;
-    funcCall: (callId: string, name: string, args: string) => Promise<void>;
+    funcCall: (callId: string, name: string, args: string, ids?: {
+        rawCallId?: string;
+        effectiveCallId?: string;
+    }) => Promise<void>;
     webSearchCall?: (call: LlmWebSearchCall) => Promise<void>;
     nativeToolCall?: (call: OpenAiResponsesNativeToolCall) => Promise<void>;
     toolResultImageIngest?: (ingest: ToolResultImageIngest) => Promise<void>;

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

@@ -555,10 +555,11 @@ function resolveMemberDiligencePushMax(team, agentId) {
 function emitDiligenceBudgetEvent(dlg, options) {
     const maxInjectCount = Math.max(0, Math.floor(options.maxInjectCount));
     const remainingCount = Math.max(0, Math.floor(options.nextRemainingBudget));
+    const injectedCount = maxInjectCount > 0 ? Math.max(0, maxInjectCount - remainingCount) : 0;
     (0, evt_registry_1.postDialogEvent)(dlg, {
         type: 'diligence_budget_evt',
         maxInjectCount,
-        injectedCount: Math.max(0, maxInjectCount - remainingCount),
+        injectedCount,
         remainingCount,
         disableDiligencePush: dlg.disableDiligencePush,
     });
@@ -873,111 +874,154 @@ function shouldImmediatelyFollowUpToolOutcome(tool, outcome) {
     }
     return shouldImmediatelyFollowUpSuccessfulToolResult(tool);
 }
-async function loadKnownFunctionCallIds(dialog) {
+function trimOptionalCallId(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed === '' ? undefined : trimmed;
+}
+function resolveRawCallId(call) {
+    return trimOptionalCallId(call.rawId) ?? call.id;
+}
+function reserveKnownFunctionCallId(reservation, callId) {
+    const normalized = trimOptionalCallId(callId);
+    if (normalized !== undefined) {
+        reservation.knownCallIds.add(normalized);
+    }
+}
+async function loadKnownFunctionCallIdsForCurrentCourse(dialog) {
     const known = new Set();
-    for (const msg of dialog.msgs) {
-        if (msg.type === 'func_call_msg') {
-            const callId = msg.id.trim();
-            if (callId !== '') {
-                known.add(callId);
-            }
+    const addKnown = (callId) => {
+        const normalized = trimOptionalCallId(callId);
+        if (normalized !== undefined) {
+            known.add(normalized);
         }
-    }
-    const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialog.id, dialog.status);
-    const maxCourse = latest?.currentCourse ?? dialog.currentCourse;
-    for (let course = 1; course <= maxCourse; course += 1) {
-        const events = await persistence_1.DialogPersistence.loadCourseEvents(dialog.id, course, dialog.status);
-        for (const event of events) {
-            if (event.type === 'func_call_record' || event.type === 'tellask_call_record') {
-                const callId = event.id.trim();
-                if (callId !== '') {
-                    known.add(callId);
-                }
+    };
+    const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
+    const events = await persistence_1.DialogPersistence.loadCourseEvents(dialog.id, course, dialog.status);
+    for (const event of events) {
+        if (event.type === 'func_call_record' || event.type === 'tellask_call_record') {
+            addKnown(event.id);
+            if (event.type === 'func_call_record') {
+                addKnown(event.rawId);
+                addKnown(event.effectiveId);
             }
         }
     }
     return known;
 }
-async function loadKnownFunctionCallIdsForProviderQuirks(dialog, providerConfig) {
-    if (!(0, api_quirks_1.normalizeProviderApiQuirks)(providerConfig).has(api_quirks_1.VOLCANO_TOOL_USE_API_QUIRK)) {
-        return undefined;
+function allocateDuplicateEffectiveCallId(args) {
+    const base = args.rawCallId.trim();
+    if (base === '') {
+        throw new Error('kernel-driver function call id invariant violation: empty raw callId');
+    }
+    let suffix = args.reservation.nextDuplicateSuffixByRawId.get(base) ?? 2;
+    for (;;) {
+        const candidate = `${base}__dominds_c${String(args.course)}_g${String(args.genseq)}_${String(suffix)}`;
+        suffix += 1;
+        if (!args.reservation.knownCallIds.has(candidate)) {
+            args.reservation.nextDuplicateSuffixByRawId.set(base, suffix);
+            return candidate;
+        }
     }
-    return await loadKnownFunctionCallIds(dialog);
 }
-function formatDuplicateFunctionCallResult(args) {
-    const language = (0, work_language_1.getWorkLanguage)();
-    if (language === 'zh') {
-        return [
-            `错误：本次函数调用被拒绝，因为 callId \`${args.callId}\` 已经被使用过。`,
-            '',
-            `不要复用已有 callId 调用 \`${args.callName}\`。如果仍需要调用工具，请重新发起一次带全新 callId 的函数调用。`,
-        ].join('\n');
-    }
-    return [
-        `Error: this function call was rejected because callId \`${args.callId}\` has already been used.`,
-        '',
-        `Do not reuse an existing callId for \`${args.callName}\`. If you still need the tool, issue a new function call with a fresh callId.`,
-    ].join('\n');
+function allocateEffectiveFunctionCallId(args) {
+    const rawCallId = args.rawCallId.trim();
+    if (rawCallId === '') {
+        throw new Error('kernel-driver function call id invariant violation: empty raw callId');
+    }
+    const duplicateRawCallId = args.reservation.knownCallIds.has(rawCallId) ||
+        args.reservation.seenRawIdsThisRound.has(rawCallId);
+    if (!duplicateRawCallId) {
+        args.reservation.knownCallIds.add(rawCallId);
+        args.reservation.seenRawIdsThisRound.add(rawCallId);
+        return { effectiveCallId: rawCallId, duplicateRawCallId: false };
+    }
+    const effectiveCallId = allocateDuplicateEffectiveCallId({
+        reservation: args.reservation,
+        rawCallId,
+        course: args.course,
+        genseq: args.genseq,
+    });
+    args.reservation.knownCallIds.add(effectiveCallId);
+    args.reservation.seenRawIdsThisRound.add(rawCallId);
+    log_1.log.warn('Mapped duplicate raw function call id to unique effective id', undefined, {
+        course: args.course,
+        genseq: args.genseq,
+        rawCallId,
+        effectiveCallId,
+    });
+    return { effectiveCallId, duplicateRawCallId: true };
 }
-async function splitPreRejectedFunctionCalls(args) {
-    const knownCallIds = await loadKnownFunctionCallIds(args.dlg);
-    const seenThisRound = new Set();
-    const executableCalls = [];
-    const preRejectedCalls = [];
-    for (let callIndex = 0; callIndex < args.funcCalls.length; callIndex += 1) {
-        const call = args.funcCalls[callIndex];
-        if (!call) {
-            throw new Error(`kernel-driver function call invariant violation: missing call ${callIndex}`);
+async function normalizeGeneratedFunctionCallIds(args) {
+    const reservation = {
+        knownCallIds: new Set(await loadKnownFunctionCallIdsForCurrentCourse(args.dialog)),
+        seenRawIdsThisRound: new Set(),
+        nextDuplicateSuffixByRawId: new Map(),
+    };
+    for (const call of args.calls) {
+        if ((0, tellask_special_1.isTellaskCallFunctionName)(call.name)) {
+            reserveKnownFunctionCallId(reservation, call.id);
+            reserveKnownFunctionCallId(reservation, call.rawId);
         }
-        const callId = call.id.trim();
-        const isDuplicate = callId !== '' && (knownCallIds.has(callId) || seenThisRound.has(callId));
-        if (!isDuplicate) {
-            if (callId !== '') {
-                seenThisRound.add(callId);
+    }
+    return args.calls.map((call) => {
+        const rawCallId = resolveRawCallId(call);
+        if ((0, tellask_special_1.isTellaskCallFunctionName)(call.name)) {
+            if (rawCallId.trim() !== '') {
+                reservation.seenRawIdsThisRound.add(rawCallId);
             }
-            executableCalls.push(call);
-            continue;
+            return {
+                ...call,
+                rawId: rawCallId,
+                effectiveId: call.id,
+            };
         }
-        const genseq = Number.isFinite(call.genseq) && call.genseq > 0
-            ? Math.floor(call.genseq)
-            : (args.dlg.activeGenSeqOrUndefined ?? 1);
-        const result = {
-            type: 'func_result_msg',
-            role: 'tool',
-            genseq,
-            id: call.id,
-            name: call.name,
-            content: formatDuplicateFunctionCallResult({
-                callId: call.id,
-                callName: call.name,
-            }),
+        const effectiveCallId = rawCallId.trim() === ''
+            ? call.id
+            : allocateEffectiveFunctionCallId({
+                reservation,
+                rawCallId,
+                course: args.dialog.activeGenCourseOrUndefined ?? args.dialog.currentCourse,
+                genseq: call.genseq,
+            }).effectiveCallId;
+        return {
+            ...call,
+            id: effectiveCallId,
+            rawId: rawCallId,
+            effectiveId: effectiveCallId,
         };
-        log_1.log.warn('Rejected duplicate function call id from LLM output', undefined, {
-            rootId: args.dlg.id.rootId,
-            selfId: args.dlg.id.selfId,
-            course: args.dlg.currentCourse,
-            genseq,
-            callId: call.id,
-            callName: call.name,
-        });
-        preRejectedCalls.push({ callIndex, result });
-    }
-    return { executableCalls, preRejectedCalls };
+    });
 }
 async function executeFunctionCalls(args) {
     const preparedCalls = args.funcCalls.map((func) => {
         throwIfAborted(args.abortSignal, args.dlg);
         const callGenseq = func.genseq;
         const argsStr = typeof func.arguments === 'string' ? func.arguments : JSON.stringify(func.arguments ?? {});
+        const rawCallId = resolveRawCallId(func);
+        const effectiveCallId = func.id;
+        const normalizedFunc = {
+            ...func,
+            id: effectiveCallId,
+            rawId: rawCallId,
+            effectiveId: effectiveCallId,
+        };
         const tool = args.agentTools.find((t) => t.type === 'func' && t.name === func.name);
         const preparedInvocationArgs = tool !== undefined ? (0, tool_1.resolveFuncToolInvocationArguments)(tool, argsStr) : null;
-        return { func, callGenseq, argsStr, tool, preparedInvocationArgs };
+        return {
+            func: normalizedFunc,
+            originalFunc: func,
+            callGenseq,
+            argsStr,
+            tool,
+            preparedInvocationArgs,
+        };
     });
     for (const prepared of preparedCalls) {
         throwIfAborted(args.abortSignal, args.dlg);
-        await args.dlg.persistFunctionCall(prepared.func.id, prepared.func.name, prepared.argsStr, prepared.callGenseq);
+        await args.dlg.persistFunctionCall(prepared.func.id, prepared.func.name, prepared.argsStr, prepared.callGenseq, prepared.func.rawId);
     }
-    const functionPromises = preparedCalls.map(async ({ func, callGenseq, argsStr, tool, preparedInvocationArgs, }) => {
+    const functionPromises = preparedCalls.map(async ({ func, originalFunc, callGenseq, argsStr, tool, preparedInvocationArgs, }) => {
         throwIfAborted(args.abortSignal, args.dlg);
         let result;
         let outcome = 'success';
@@ -988,6 +1032,8 @@ async function executeFunctionCalls(args) {
             result = {
                 type: 'func_result_msg',
                 id: func.id,
+                rawId: func.rawId,
+                effectiveId: func.effectiveId,
                 name: func.name,
                 content: output.content,
                 role: 'tool',
@@ -1006,6 +1052,8 @@ async function executeFunctionCalls(args) {
                 result = {
                     type: 'func_result_msg',
                     id: func.id,
+                    rawId: func.rawId,
+                    effectiveId: func.effectiveId,
                     name: func.name,
                     content: (0, tool_1.toolFailure)(`Invalid arguments: ${errorText}`).content,
                     role: 'tool',
@@ -1021,6 +1069,8 @@ async function executeFunctionCalls(args) {
                     result = {
                         type: 'func_result_msg',
                         id: func.id,
+                        rawId: func.rawId,
+                        effectiveId: func.effectiveId,
                         name: func.name,
                         content: output.content,
                         contentItems: Array.isArray(output.contentItems)
@@ -1037,6 +1087,8 @@ async function executeFunctionCalls(args) {
                     result = {
                         type: 'func_result_msg',
                         id: func.id,
+                        rawId: func.rawId,
+                        effectiveId: func.effectiveId,
                         name: func.name,
                         content: failureOutput.content,
                         role: 'tool',
@@ -1047,6 +1099,8 @@ async function executeFunctionCalls(args) {
                         result = {
                             type: 'func_result_msg',
                             id: func.id,
+                            rawId: func.rawId,
+                            effectiveId: func.effectiveId,
                             name: func.name,
                             content: interruptedOutput.content,
                             role: 'tool',
@@ -1061,7 +1115,7 @@ async function executeFunctionCalls(args) {
         if (rethrowError !== undefined) {
             throw rethrowError;
         }
-        return { outcome, result };
+        return { func, originalFunc, outcome, result };
     });
     return await Promise.all(functionPromises);
 }
@@ -1075,11 +1129,7 @@ async function executeFunctionRound(args) {
         };
     }
     throwIfAborted(args.abortSignal, args.dlg);
-    const { executableCalls, preRejectedCalls } = await splitPreRejectedFunctionCalls({
-        dlg: args.dlg,
-        funcCalls: args.funcCalls,
-    });
-    const preRejectedResultByCall = new Map(preRejectedCalls.map((entry) => [entry.callIndex, entry.result]));
+    const executableCalls = [...args.funcCalls];
     const allowTellaskBack = args.allowTellaskFunctions && args.dlg.id.rootId !== args.dlg.id.selfId;
     const allowedSpecials = args.allowTellaskFunctions
         ? new Set([
@@ -1109,6 +1159,7 @@ async function executeFunctionRound(args) {
         funcCalls: tellaskRound.normalCalls,
         abortSignal: args.abortSignal,
     });
+    const genericExecutionByOriginalCall = new Map(genericExecutions.map((execution) => [execution.originalFunc, execution]));
     const funcToolByName = new Map(args.agentTools
         .filter((tool) => tool.type === 'func')
         .map((tool) => [tool.name, tool]));
@@ -1139,12 +1190,13 @@ async function executeFunctionRound(args) {
     const tellaskCallMsgById = new Map(tellaskRound.tellaskCallMessages.map((msg) => [msg.id, msg]));
     const specialCallIds = new Set(tellaskRound.handledCallIds);
     for (let callIndex = 0; callIndex < args.funcCalls.length; callIndex += 1) {
-        const call = args.funcCalls[callIndex];
-        if (!call) {
+        const originalCall = args.funcCalls[callIndex];
+        if (!originalCall) {
             throw new Error(`kernel-driver function call invariant violation: missing call ${callIndex}`);
         }
-        const preRejectedResult = preRejectedResultByCall.get(callIndex);
-        const tellaskCallMsg = preRejectedResult ? undefined : tellaskCallMsgById.get(call.id);
+        const execution = genericExecutionByOriginalCall.get(originalCall);
+        const call = execution?.func ?? originalCall;
+        const tellaskCallMsg = tellaskCallMsgById.get(call.id);
         if (tellaskCallMsg) {
             pairedMessages.push(tellaskCallMsg);
         }
@@ -1155,14 +1207,12 @@ async function executeFunctionRound(args) {
                 role: 'assistant',
                 genseq: call.genseq,
                 id: call.id,
+                ...(call.rawId !== undefined ? { rawId: call.rawId } : {}),
+                ...(call.effectiveId !== undefined ? { effectiveId: call.effectiveId } : {}),
                 name: call.name,
                 arguments: originalArgsStr,
             });
         }
-        if (preRejectedResult) {
-            pairedMessages.push(preRejectedResult);
-            continue;
-        }
         const result = resultByCallId.get(call.id);
         if (result) {
             pairedMessages.push(result);
@@ -1174,35 +1224,27 @@ async function executeFunctionRound(args) {
         throw new Error(`kernel-driver function result invariant violation: missing result for call id '${call.id}' (${call.name})`);
     }
     return {
-        hasImmediateFollowupToolCalls: hasImmediateFollowupToolCalls ||
-            tellaskRound.hasInvalidTellaskCalls ||
-            preRejectedCalls.length > 0,
+        hasImmediateFollowupToolCalls: hasImmediateFollowupToolCalls || tellaskRound.hasInvalidTellaskCalls,
         shouldStopAfterReplyTool: tellaskRound.shouldStopAfterReplyTool,
         pairedMessages,
         tellaskToolOutputs: [...tellaskRound.toolOutputs],
     };
 }
-async function resetDiligenceBudgetAfterQ4H(dlg, team) {
+async function preserveDiligenceBudgetAcrossQ4H(dlg) {
     try {
         if (!(await dlg.hasPendingQ4H())) {
             return;
         }
-        const configuredMax = resolveMemberDiligencePushMax(team, dlg.agentId);
-        if (typeof configuredMax === 'number' && Number.isFinite(configuredMax)) {
-            const next = Math.floor(configuredMax);
-            dlg.diligencePushRemainingBudget =
-                next > 0 ? next : Math.max(0, Math.floor(dlg.diligencePushRemainingBudget));
-        }
-        else {
-            dlg.diligencePushRemainingBudget = Math.max(0, Math.floor(dlg.diligencePushRemainingBudget));
-        }
+        // Q4H is a suspension boundary, not a reason to reapply member defaults. Keep the dialog's
+        // own remaining budget as the source of truth so operator-adjusted budgets survive Q4H.
+        dlg.diligencePushRemainingBudget = Math.max(0, Math.floor(dlg.diligencePushRemainingBudget));
         void persistence_1.DialogPersistence.mutateDialogLatest(dlg.id, () => ({
             kind: 'patch',
             patch: { diligencePushRemainingBudget: dlg.diligencePushRemainingBudget },
         }));
     }
     catch (err) {
-        log_1.log.error('kernel-driver failed to reset Diligence Push budget after Q4H', err, {
+        log_1.log.error('kernel-driver failed to preserve Diligence Push budget after Q4H', err, {
             dialogId: dlg.id.valueOf(),
         });
         throw err;
@@ -1218,7 +1260,7 @@ async function maybeContinueWithDiligencePrompt(args) {
     });
     if (!suspension.canDrive) {
         if (suspension.q4h) {
-            await resetDiligenceBudgetAfterQ4H(dlg, team);
+            await preserveDiligenceBudgetAcrossQ4H(dlg);
         }
         return { kind: 'break' };
     }
@@ -1991,13 +2033,17 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 streamAttemptSayingContent = currentSayingContent;
                                 streamAttemptSayingGenseq = sayingMessage.genseq;
                             },
-                            funcCall: async (callId, name, argsStr) => {
+                            funcCall: async (callId, name, argsStr, ids) => {
                                 throwIfAborted(abortSignal, dlg);
+                                const rawCallId = trimOptionalCallId(ids?.rawCallId) ?? callId;
+                                const effectiveCallId = trimOptionalCallId(ids?.effectiveCallId) ?? callId;
                                 streamedFuncCalls.push({
                                     type: 'func_call_msg',
                                     role: 'assistant',
                                     genseq: dlg.activeGenSeq,
-                                    id: callId,
+                                    id: effectiveCallId,
+                                    rawId: rawCallId,
+                                    effectiveId: effectiveCallId,
                                     name,
                                     arguments: argsStr,
                                 });
@@ -2051,7 +2097,6 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 sawNativeToolSideChannelOutput = false;
                                 streamedFuncCalls.length = 0;
                                 newMsgs.length = 0;
-                                const knownFunctionCallIds = await loadKnownFunctionCallIdsForProviderQuirks(dlg, providerCfg);
                                 const promptCacheKey = prepareLlmRequestContextKey();
                                 const streamResult = await llmGen.genToReceiver(providerCfg, agent, systemPrompt, funcTools, {
                                     dialogSelfId: dlg.id.selfId,
@@ -2060,7 +2105,6 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                     modelKey: model,
                                     promptCacheKey,
                                     toolUseRequirement: resolveToolUseRequirement(dlg, policy),
-                                    knownFunctionCallIds,
                                 }, ctxMsgs, receiver, dlg.activeGenSeq, abortSignal);
                                 const hasFinishedMessageContent = newMsgs.some((msg) => (msg.type === 'thinking_msg' || msg.type === 'saying_msg') &&
                                     msg.content.trim() !== '');
@@ -2209,6 +2253,12 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         dlg.setFbrConclusionToolsEnabled(false);
                         break;
                     }
+                    const normalizedStreamedFuncCalls = await normalizeGeneratedFunctionCallIds({
+                        calls: streamedFuncCalls,
+                        dialog: dlg,
+                    });
+                    streamedFuncCalls.length = 0;
+                    streamedFuncCalls.push(...normalizedStreamedFuncCalls);
                     for (const call of streamedFuncCalls) {
                         const rawCallGenseq = call.genseq;
                         if (!Number.isFinite(rawCallGenseq) || rawCallGenseq <= 0)
@@ -2317,7 +2367,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         allowPendingSideDialogs: routed.hasImmediateFollowupToolCalls,
                     });
                     if (!suspensionAfterToolRound.canDrive) {
-                        await resetDiligenceBudgetAfterQ4H(dlg, team);
+                        await preserveDiligenceBudgetAcrossQ4H(dlg);
                         break;
                     }
                     // Start an immediate post-tool generation only when this round produced tool outputs that

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

@@ -133,7 +133,10 @@ async function maybePrepareDiligenceAutoContinuePrompt(options) {
     }
     const resolved = await resolveRtwsDiligenceConfig();
     if (resolved.kind === 'disabled') {
-        return { kind: 'disabled', nextRemainingBudget: options.remainingBudget };
+        const normalizedRemaining = typeof options.remainingBudget === 'number' && Number.isFinite(options.remainingBudget)
+            ? Math.max(0, Math.floor(options.remainingBudget))
+            : 0;
+        return { kind: 'disabled', nextRemainingBudget: normalizedRemaining };
     }
     const maxInjectCount = typeof options.diligencePushMax === 'number' && Number.isFinite(options.diligencePushMax)
         ? Math.floor(options.diligencePushMax)
@@ -142,10 +145,16 @@ async function maybePrepareDiligenceAutoContinuePrompt(options) {
         ? Math.max(0, Math.floor(options.remainingBudget))
         : 0;
     const bypassBudget = options.ignoreBudgetExhaustion === true;
-    if (maxInjectCount < 1) {
-        if (!bypassBudget) {
-            return { kind: 'disabled', nextRemainingBudget: 0 };
+    // `diligencePushMax` is only the per-member default used when a dialog instance is created or
+    // reset. Runtime business decisions must be based on this dialog's persisted remaining budget so
+    // operator-added budget (for example 51/0) keeps working even when the team default is zero.
+    if (normalizedRemaining < 1 && !bypassBudget) {
+        if (maxInjectCount > 0) {
+            return { kind: 'budget_exhausted', maxInjectCount, nextRemainingBudget: 0 };
         }
+        return { kind: 'disabled', nextRemainingBudget: 0 };
+    }
+    if (normalizedRemaining < 1) {
         const prompt = {
             content: (0, driver_messages_1.formatDiligenceAutoContinuePrompt)((0, work_language_1.getWorkLanguage)(), resolved.diligenceText),
             msgId: (0, id_1.generateShortId)(),
@@ -159,7 +168,7 @@ async function maybePrepareDiligenceAutoContinuePrompt(options) {
             nextRemainingBudget: 0,
         };
     }
-    const currentRemaining = Math.min(normalizedRemaining, maxInjectCount);
+    const currentRemaining = normalizedRemaining;
     if (currentRemaining < 1 && !bypassBudget) {
         return { kind: 'budget_exhausted', maxInjectCount, nextRemainingBudget: 0 };
     }
@@ -266,6 +275,13 @@ function readErrorCode(error) {
     }
     return undefined;
 }
+function readErrorStringField(error, field) {
+    if (!isPlainObject(error)) {
+        return undefined;
+    }
+    const value = error[field];
+    return typeof value === 'string' && value.trim().length > 0 ? value : undefined;
+}
 function isRetriableLlmErrorCode(code) {
     if (!code)
         return false;
@@ -717,24 +733,30 @@ async function runLlmRequestWithRetry(params) {
             const cause = readErrorCause(err);
             const causeCode = readErrorCode(cause);
             const causeMessage = cause === undefined || cause === null ? undefined : (0, log_1.extractErrorDetails)(cause).message;
+            const debugCaptureError = readErrorStringField(err, 'debugCaptureError');
+            const debugPath = readErrorStringField(err, 'debugPath');
+            const requestPayloadPath = readErrorStringField(err, 'requestPayloadPath');
             const attemptNo = attempt + 1;
             const retryStrategy = failure.kind === 'retriable' ? (failure.retryStrategy ?? 'conservative') : undefined;
             const retryMode = resolveRetryModeFromHandling(handledFailure.handling);
             log_1.log.warn('LLM request attempt failed', err, {
                 provider: params.provider,
-                dialogId: params.dlg.id.valueOf(),
-                rootId: params.dlg.id.rootId,
-                selfId: params.dlg.id.selfId,
+                failureKind: failure.kind,
+                status: failure.status,
+                code: failure.code,
+                debugPath,
+                requestPayloadPath,
+                debugCaptureError,
                 retryStrategy,
                 retryMode,
                 attemptNumber: attemptNo,
+                dialogId: params.dlg.id.valueOf(),
+                rootId: params.dlg.id.rootId,
+                selfId: params.dlg.id.selfId,
                 aggressiveRetryCount,
                 aggressiveRetryMaxRetries: params.aggressiveRetryMaxRetries,
-                failureKind: failure.kind,
                 quirkHandling: handledFailure.handling.kind,
                 quirkSource: handledFailure.handling.sourceQuirk,
-                status: failure.status,
-                code: failure.code,
                 errorCode,
                 causeCode,
                 causeMessage,
@@ -751,6 +773,9 @@ async function runLlmRequestWithRetry(params) {
                     detail: {
                         dialogId: params.dlg.id.valueOf(),
                         provider: params.provider,
+                        debugPath,
+                        requestPayloadPath,
+                        debugCaptureError,
                         errorText: detail,
                     },
                 });

package/dist/llm/kernel-driver/tellask-special.js

@@ -2276,8 +2276,8 @@ async function processTellaskFunctionRound(args) {
     const resolvedTellask = resolveTellaskFunctionCalls(funcCallsForResolution, {
         allowedSpecials: args.allowedSpecials,
     });
-    const validByCallId = new Map(resolvedTellask.validCalls.map((handled) => [handled.originalCall.id, handled]));
-    const invalidByCallId = new Map(resolvedTellask.invalidCalls.map((issue) => [issue.originalCall.id, issue]));
+    const validByOriginalCall = new Map(resolvedTellask.validCalls.map((handled) => [handled.originalCall, handled]));
+    const invalidByOriginalCall = new Map(resolvedTellask.invalidCalls.map((issue) => [issue.originalCall, issue]));
     const orderedSpecialDispositions = [];
     for (const originalCall of args.funcCalls) {
         if (!isTellaskCallFunctionName(originalCall.name) ||
@@ -2308,12 +2308,12 @@ async function processTellaskFunctionRound(args) {
             });
             continue;
         }
-        const handled = validByCallId.get(originalCall.id);
+        const handled = validByOriginalCall.get(originalCall);
         if (handled) {
             orderedSpecialDispositions.push({ kind: 'valid', handled });
             continue;
         }
-        const issue = invalidByCallId.get(originalCall.id);
+        const issue = invalidByOriginalCall.get(originalCall);
         if (issue) {
             orderedSpecialDispositions.push({ kind: 'invalid', callName: originalCall.name, issue });
             continue;
@@ -2323,7 +2323,7 @@ async function processTellaskFunctionRound(args) {
     const orderedValidCalls = orderedSpecialDispositions.flatMap((entry) => entry.kind === 'valid' ? [entry.handled] : []);
     const orderedInvalidCalls = orderedSpecialDispositions.flatMap((entry) => entry.kind === 'invalid' ? [entry.issue] : []);
     const specialCallById = new Map(orderedValidCalls.map(({ call }) => [call.callId, call]));
-    const originalCallById = new Map(args.funcCalls.map((call) => [call.id, call]));
+    const originalCallBySpecialCall = new Map(orderedValidCalls.map(({ call, originalCall }) => [call, originalCall]));
     const tellaskCallMessages = [];
     const issueResults = [];
     for (const disposition of orderedSpecialDispositions) {
@@ -2398,7 +2398,7 @@ async function processTellaskFunctionRound(args) {
             if (issueResults.some((result) => result.id === call.callId)) {
                 continue;
             }
-            const originalCall = originalCallById.get(call.callId);
+            const originalCall = originalCallBySpecialCall.get(call);
             if (!originalCall) {
                 throw new Error(`kernel-driver tellask special call invariant violation: missing original call for '${call.callId}'`);
             }
@@ -2431,11 +2431,14 @@ async function processTellaskFunctionRound(args) {
             }
             const originatingCall = specialCallById.get(callId);
             if (originatingCall) {
-                const originalCall = originalCallById.get(callId);
+                const originalCall = originalCallBySpecialCall.get(originatingCall);
+                if (!originalCall) {
+                    throw new Error(`kernel-driver tellask result invariant violation: missing original call for '${callId}'`);
+                }
                 const result = {
                     type: 'func_result_msg',
                     role: 'tool',
-                    genseq: originalCall?.genseq ?? 1,
+                    genseq: originalCall.genseq,
                     id: callId,
                     name: originatingCall.callName,
                     content: output.content,
@@ -2451,7 +2454,7 @@ async function processTellaskFunctionRound(args) {
         if (tellaskFuncResultByCallId.has(call.callId)) {
             continue;
         }
-        const originalCall = originalCallById.get(call.callId);
+        const originalCall = originalCallBySpecialCall.get(call);
         if (!originalCall) {
             throw new Error(`kernel-driver tellask call invariant violation: missing original call for '${call.callId}'`);
         }