@botbotgo/agent-harness 0.0.419 → 0.0.421

package/dist/runtime/adapter/local-tool-invocation.js

@@ -13,11 +13,75 @@ const TOOL_FOLLOW_UP_INSTRUCTION = "One or more tool results are already availab
 const DEFAULT_MAX_TOOL_ITERATIONS = 10_000;
 const MAX_REPEATED_RECOVERY_WITHOUT_PROGRESS = 2;
 const MAX_REPEATED_PLAN_ONLY_AFTER_PLAN = 2;
-function createBootstrapTodoPlan(primaryTools) {
+function stringifyRequestForToolSelection(request) {
+    if (typeof request === "string") {
+        return request;
+    }
+    if (typeof request !== "object" || request === null) {
+        return "";
+    }
+    try {
+        return JSON.stringify(request);
+    }
+    catch {
+        return "";
+    }
+}
+function extractSelectionTokens(value) {
+    const tokens = new Set();
+    for (const match of value.matchAll(/[\p{L}\p{N}_-]+/gu)) {
+        const token = match[0].toLowerCase();
+        if (token.length >= 2) {
+            tokens.add(token);
+        }
+    }
+    for (const match of value.matchAll(/[\p{Script=Han}]{2,}/gu)) {
+        const sequence = match[0];
+        for (let size = 2; size <= Math.min(4, sequence.length); size += 1) {
+            for (let index = 0; index <= sequence.length - size; index += 1) {
+                tokens.add(sequence.slice(index, index + size).toLowerCase());
+            }
+        }
+    }
+    return tokens;
+}
+function prioritizeBootstrapEvidenceTools(primaryTools, request) {
+    const requestText = stringifyRequestForToolSelection(request);
+    const requestTokens = extractSelectionTokens(requestText);
+    const isFinanceRequest = /\b(?:stock|ticker|finance|market|valuation|quote)\b|股票|股价|行情|估值|财报/iu.test(requestText);
     const evidenceTools = primaryTools
-        .map((tool) => typeof tool.name === "string" ? tool.name.trim() : "")
-        .filter((name) => name.length > 0 && !isPlanToolName(name))
-        .slice(0, 3);
+        .map((tool) => {
+        const name = typeof tool.name === "string" ? tool.name.trim() : "";
+        const description = typeof tool.description === "string" ? tool.description : "";
+        const toolTokens = extractSelectionTokens(`${name} ${description}`);
+        let score = 0;
+        for (const token of requestTokens) {
+            if (toolTokens.has(token)) {
+                score += token.length > 3 ? 2 : 1;
+            }
+        }
+        if (requestText.toLowerCase().includes(name.toLowerCase())) {
+            score += 6;
+        }
+        return { name, score };
+    })
+        .filter((tool) => tool.name.length > 0 && !isPlanToolName(tool.name))
+        .sort((left, right) => {
+        if (right.score !== left.score) {
+            return right.score - left.score;
+        }
+        if (!isFinanceRequest) {
+            return 0;
+        }
+        const leftFinance = left.name.includes("finance") ? 0 : 1;
+        const rightFinance = right.name.includes("finance") ? 0 : 1;
+        return leftFinance - rightFinance;
+    })
+        .map((tool) => tool.name);
+    return evidenceTools.slice(0, 4);
+}
+function createBootstrapTodoPlan(primaryTools, request) {
+    const evidenceTools = prioritizeBootstrapEvidenceTools(primaryTools, request);
     if (evidenceTools.length === 0) {
         return [
             {
@@ -48,7 +112,7 @@ function createBootstrapTodoPlan(primaryTools) {
         },
     ];
 }
-function buildBootstrapPlanToolResult(primaryTools) {
+function buildBootstrapPlanToolResult(primaryTools, request) {
     return {
         messages: [new AIMessage({
                 content: "",
@@ -56,13 +120,26 @@ function buildBootstrapPlanToolResult(primaryTools) {
                         id: `write-todos-bootstrap-${Math.random().toString(36).slice(2, 10)}`,
                         name: "write_todos",
                         args: {
-                            todos: createBootstrapTodoPlan(primaryTools),
+                            todos: createBootstrapTodoPlan(primaryTools, request),
                         },
                         type: "tool_call",
                     }],
             })],
     };
 }
+function buildExternalPlanEvidenceToolResult(tools) {
+    return {
+        messages: [{
+                content: "",
+                tool_calls: tools.map((tool, index) => ({
+                    id: tool.id ?? `external-plan-evidence-${index + 1}-${Math.random().toString(36).slice(2, 10)}`,
+                    name: tool.name,
+                    args: tool.args ?? {},
+                    type: "tool_call",
+                })),
+            }],
+    };
+}
 function readPlanStateSummary(output) {
     if (typeof output !== "object" || output === null) {
         return null;
@@ -183,6 +260,76 @@ function terminalToolErrorRecoveryInstruction(terminalText) {
 function requiresPlanEvidence(binding) {
     return binding.harnessRuntime.executionContract?.requiresPlan === true;
 }
+function resolveCommittedTodoEvidenceTool(executedToolResults, primaryTools) {
+    const availableTools = primaryTools
+        .filter((tool) => typeof tool.name === "string" && tool.name.length > 0 && !isPlanToolName(tool.name));
+    if (availableTools.length === 0) {
+        return null;
+    }
+    for (let index = executedToolResults.length - 1; index >= 0; index -= 1) {
+        const result = executedToolResults[index];
+        if (!result || result.isError === true || !isPlanToolName(result.toolName)) {
+            continue;
+        }
+        const output = result.output;
+        const summary = typeof output === "object" && output !== null
+            ? output.summary
+            : undefined;
+        const items = typeof summary === "object" && summary !== null && Array.isArray(summary.items)
+            ? summary.items
+            : [];
+        const activeItems = items.filter((item) => item.status === "in_progress");
+        const candidateItems = activeItems.length > 0
+            ? activeItems
+            : items.filter((item) => item.status === "pending").slice(0, 1);
+        for (const item of candidateItems) {
+            const content = [
+                item.content,
+                item.description,
+                item.title,
+                item.name,
+                item.text,
+            ].filter((value) => typeof value === "string").join(" ").toLowerCase();
+            const matched = availableTools.map((tool) => tool.name).filter((toolName) => content.includes(toolName.toLowerCase()));
+            if (matched.length === 1) {
+                return {
+                    name: matched[0],
+                    args: {},
+                    id: `todo-committed-evidence-${index}`,
+                };
+            }
+            const requestTokens = extractSelectionTokens(content);
+            const scored = availableTools
+                .map((tool) => {
+                const toolTokens = extractSelectionTokens(`${tool.name} ${tool.description ?? ""}`);
+                let score = 0;
+                for (const token of requestTokens) {
+                    if (toolTokens.has(token)) {
+                        score += token.length > 3 ? 2 : 1;
+                    }
+                }
+                return { name: tool.name, score };
+            })
+                .filter((item) => item.score > 0)
+                .sort((left, right) => right.score - left.score);
+            if (scored[0] && (!scored[1] || scored[0].score > scored[1].score)) {
+                return {
+                    name: scored[0].name,
+                    args: {},
+                    id: `todo-committed-evidence-${index}`,
+                };
+            }
+            if (matched.length === 1) {
+                return {
+                    name: matched[0],
+                    args: {},
+                    id: `todo-committed-evidence-${index}`,
+                };
+            }
+        }
+    }
+    return null;
+}
 function extractLatestUserInput(request) {
     const typedRequest = request;
     const messages = Array.isArray(typedRequest.messages) ? typedRequest.messages : [];
@@ -241,7 +388,7 @@ function summarizeResultMessages(result) {
         };
     });
 }
-export async function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, toolRuntimeContext, externalPlanEvidence, }) {
+export async function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, toolRuntimeContext, externalPlanEvidence, externalPlanEvidenceTool, externalPlanEvidenceTools, }) {
     const executedToolResults = [];
     let activeRequest = request;
     let currentMessages = Array.isArray(activeRequest.messages) ? [...activeRequest.messages] : [];
@@ -262,9 +409,39 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
     }
     for (let iteration = 0; iteration < maxToolIterations; iteration += 1) {
         const isFinalIteration = iteration + 1 === maxToolIterations;
-        result = pendingResult ?? await callRuntimeWithToolParseRecovery(activeRequest);
+        const externalPlanEvidenceToolCalls = externalPlanEvidenceTools && externalPlanEvidenceTools.length > 0
+            ? externalPlanEvidenceTools
+            : externalPlanEvidenceTool
+                ? [externalPlanEvidenceTool]
+                : [];
+        const shouldRunExternalPlanEvidenceTool = pendingResult === undefined
+            && requiresPlanEvidence(binding)
+            && externalPlanEvidence === true
+            && externalPlanEvidenceToolCalls.length > 0
+            && !hasNonTodoToolEvidence(executedToolResults);
+        const usedExternalPlanEvidenceToolThisIteration = shouldRunExternalPlanEvidenceTool;
+        result = pendingResult
+            ?? (shouldRunExternalPlanEvidenceTool
+                ? buildExternalPlanEvidenceToolResult(externalPlanEvidenceToolCalls)
+                : await callRuntimeWithToolParseRecovery(activeRequest));
         pendingResult = undefined;
-        const toolCalls = extractToolCallsFromResult(result);
+        let toolCalls = extractToolCallsFromResult(result);
+        const committedTodoEvidenceTool = requiresPlanEvidence(binding)
+            && hasPlanStateEvidence(executedToolResults, externalPlanEvidence)
+            && !hasNonTodoToolEvidence(executedToolResults)
+            && (externalPlanEvidenceTool !== undefined || !hasIncompleteExecutedPlan(executedToolResults, externalPlanEvidence))
+            && (toolCalls.length === 0 || toolCalls.every((toolCall) => isPlanToolName(toolCall.name)))
+            ? externalPlanEvidenceTool
+                ? {
+                    name: externalPlanEvidenceTool.name,
+                    args: externalPlanEvidenceTool.args ?? {},
+                    id: externalPlanEvidenceTool.id ?? "external-plan-evidence-tool",
+                }
+                : resolveCommittedTodoEvidenceTool(executedToolResults, primaryTools)
+            : null;
+        if (committedTodoEvidenceTool) {
+            toolCalls = [committedTodoEvidenceTool];
+        }
         if (toolCalls.length === 0) {
             const terminalText = sanitizeVisibleText(extractVisibleOutput(result) || "");
             const hasIncompletePlanState = hasIncompleteExecutedPlan(executedToolResults, externalPlanEvidence);
@@ -296,7 +473,7 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
             if (requiresPlanEvidence(binding)
                 && !hasPlanStateEvidence(executedToolResults, externalPlanEvidence)
                 && builtinExecutableTools.has("write_todos")) {
-                pendingResult = buildBootstrapPlanToolResult(primaryTools);
+                pendingResult = buildBootstrapPlanToolResult(primaryTools, activeRequest);
                 continue;
             }
             if (recoveryInstruction) {
@@ -388,7 +565,8 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
         }
         repeatedRecoveryWithoutProgress = 0;
         repeatedPlanOnlyAfterPlan = 0;
-        const canReplayToolCalls = canReplayToolCallsLocally(binding, toolCalls, primaryTools, toolNameMapping, executableTools, builtinExecutableTools);
+        const canReplayToolCalls = usedExternalPlanEvidenceToolThisIteration
+            || canReplayToolCallsLocally(binding, toolCalls, primaryTools, toolNameMapping, executableTools, builtinExecutableTools);
         debugLocalToolReplay({
             toolCalls,
             result,
@@ -475,6 +653,67 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
                 content: stringifyToolOutput(safeToolResult),
             }));
         }
+        const committedEvidenceTool = requiresPlanEvidence(binding)
+            && !hadNonTodoEvidenceBeforeToolReplay
+            && !hasNonTodoToolEvidence(executedToolResults)
+            && !hasIncompleteExecutedPlan(executedToolResults, externalPlanEvidence)
+            ? resolveCommittedTodoEvidenceTool(executedToolResults, primaryTools)
+            : null;
+        if (committedEvidenceTool) {
+            const resolvedToolName = resolveModelFacingToolName(committedEvidenceTool.name, toolNameMapping, primaryTools);
+            const executable = executableTools.get(committedEvidenceTool.name) ?? executableTools.get(resolvedToolName);
+            if (executable) {
+                const compiledTool = toolCatalog.get(committedEvidenceTool.name) ?? toolCatalog.get(resolvedToolName);
+                const normalizedArgs = normalizeToolArgsForSchema(committedEvidenceTool.args, executable.schema, undefined, {
+                    latestUserInput,
+                });
+                const gateway = validateToolGatewayInput({
+                    toolName: executable.name,
+                    schema: executable.schema,
+                    args: normalizedArgs,
+                    requiresApproval: compiledTool ? toolRequiresRuntimeApproval(compiledTool) : false,
+                });
+                if (gateway.ok) {
+                    const toolResult = toolRuntimeContext
+                        ? await executable.invoke(gateway.input, { toolRuntimeContext })
+                        : await executable.invoke(gateway.input);
+                    const memoryCandidates = compiledTool ? extractMemoryCandidatesFromToolOutput(compiledTool, toolResult) : [];
+                    const safeToolResult = await maybePersistLargeToolOutput({
+                        toolName: executable.name,
+                        output: toolResult,
+                        toolRuntimeContext,
+                    });
+                    executedToolResults.push({
+                        toolName: executable.name,
+                        output: safeToolResult,
+                        ...(memoryCandidates.length > 0 ? { memoryCandidates } : {}),
+                    });
+                    nextMessages.push(new ToolMessage({
+                        name: executable.name,
+                        tool_call_id: committedEvidenceTool.id,
+                        content: stringifyToolOutput(safeToolResult),
+                    }));
+                }
+                else {
+                    executedToolResults.push({
+                        toolName: executable.name,
+                        output: gateway.error,
+                        isError: true,
+                    });
+                    nextMessages.push(new ToolMessage({
+                        name: executable.name,
+                        tool_call_id: committedEvidenceTool.id,
+                        content: stringifyToolOutput(gateway.error),
+                    }));
+                }
+            }
+        }
+        if (usedExternalPlanEvidenceToolThisIteration && hasNonTodoToolEvidence(executedToolResults)) {
+            return {
+                result: buildDeterministicFinalFromToolEvidence(executedToolResults),
+                executedToolResults,
+            };
+        }
         if (requiresPlanEvidence(binding)
             && toolCalls.length > 0
             && toolCalls.every((toolCall) => isPlanToolName(toolCall.name))