@botbotgo/agent-harness 0.0.455 → 0.0.456

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.455";
+export declare const AGENT_HARNESS_VERSION = "0.0.456";
 export declare const AGENT_HARNESS_RELEASE_DATE = "2026-05-04";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.455";
+export const AGENT_HARNESS_VERSION = "0.0.456";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-05-04";

package/dist/runtime/adapter/flow/stream-runtime.js

@@ -43,6 +43,12 @@ function buildRunEvidenceAfterPlanInstruction(primaryTools) {
         `Available non-planning tool names: ${toolNames.join(", ")}.`,
     ].join("\n");
 }
+function resolveConfiguredPlanEvidenceTool(primaryTools) {
+    const toolName = primaryTools
+        .map(readPrimaryToolName)
+        .find((name) => name.length > 0 && !isPlanToolName(name));
+    return toolName ? [{ name: toolName, args: {}, id: "stream-configured-plan-evidence-tool-1" }] : [];
+}
 const INITIAL_REQUIRED_PLAN_INSTRUCTION = [
     "This agent has a required visible planning contract.",
     "Your first action for this request must be write_todos with concrete task steps and statuses.",
@@ -129,135 +135,6 @@ function hasIncompletePlanOutput(value) {
     }
     return null;
 }
-function extractInProgressTodoContents(value) {
-    if (typeof value !== "object" || value === null) {
-        return [];
-    }
-    const typed = value;
-    const arrays = [typed.todos, typed.items];
-    const contents = [];
-    for (const candidate of arrays) {
-        if (!Array.isArray(candidate)) {
-            continue;
-        }
-        for (const todo of candidate) {
-            if (typeof todo !== "object" || todo === null) {
-                continue;
-            }
-            const item = todo;
-            if (item.status !== "in_progress") {
-                continue;
-            }
-            const content = [item.content, item.description, item.title, item.name, item.text]
-                .find((value) => typeof value === "string" && value.trim().length > 0);
-            if (content) {
-                contents.push(content.trim());
-            }
-        }
-    }
-    for (const nested of [typed.summary, typed.update, typed.data, typed.output]) {
-        contents.push(...extractInProgressTodoContents(nested));
-    }
-    return [...new Set(contents)];
-}
-function extractTodoContentsForEvidenceResolution(value) {
-    const inProgress = extractTodoContentsByStatus(value, "in_progress");
-    if (inProgress.length > 0) {
-        return inProgress;
-    }
-    return extractTodoContentsByStatus(value, "pending");
-}
-function extractTodoContentsByStatus(value, status) {
-    if (Array.isArray(value)) {
-        return value.flatMap((item) => extractTodoContentsByStatus(item, status));
-    }
-    if (typeof value !== "object" || value === null) {
-        return [];
-    }
-    const typed = value;
-    const arrays = [typed.todos, typed.items];
-    const contents = [];
-    for (const array of arrays) {
-        if (!Array.isArray(array)) {
-            continue;
-        }
-        for (const item of array) {
-            if (typeof item !== "object" || item === null) {
-                continue;
-            }
-            const typedItem = item;
-            if (typedItem.status !== status) {
-                continue;
-            }
-            const content = [
-                typedItem.content,
-                typedItem.description,
-                typedItem.title,
-                typedItem.name,
-                typedItem.text,
-            ].find((value) => typeof value === "string" && value.trim().length > 0);
-            if (content) {
-                contents.push(content.trim());
-            }
-        }
-    }
-    for (const nested of [typed.summary, typed.update, typed.data, typed.output]) {
-        contents.push(...extractTodoContentsByStatus(nested, status));
-    }
-    return [...new Set(contents)];
-}
-function buildRunCommittedTodoEvidenceInstruction(primaryTools, planToolOutput) {
-    const todoContents = extractInProgressTodoContents(planToolOutput);
-    const todoText = todoContents.length > 0
-        ? todoContents.map((content, index) => `${index + 1}. ${content}`).join("\n")
-        : "(no in-progress todo content was readable)";
-    return [
-        buildRunEvidenceAfterPlanInstruction(primaryTools),
-        "",
-        "The completed write_todos result contains these in-progress evidence commitments:",
-        todoText,
-        "",
-        "Your next action must execute the non-planning tool named by the in-progress TODO. If every TODO is pending, execute the non-planning tool named by the first pending TODO. Do not call write_todos or read_todos again before that evidence tool returns.",
-    ].join("\n");
-}
-function resolveCommittedPlanEvidenceTool(primaryTools, planToolOutput) {
-    return resolveCommittedPlanEvidenceTools(primaryTools, planToolOutput)[0];
-}
-function resolveCommittedPlanEvidenceTools(primaryTools, planToolOutput) {
-    const availableToolNames = primaryTools
-        .map(readPrimaryToolName)
-        .filter((name) => name.length > 0 && !isPlanToolName(name));
-    const todoContents = extractTodoContentsForEvidenceResolution(planToolOutput);
-    if (todoContents.length === 0) {
-        return [];
-    }
-    const resolved = [];
-    const seen = new Set();
-    for (const content of todoContents) {
-        const todoText = content.toLowerCase();
-        const selectedNames = availableToolNames.filter((name) => hasExplicitToolNameReference(todoText, name));
-        for (const selectedName of selectedNames) {
-            if (seen.has(selectedName)) {
-                continue;
-            }
-            seen.add(selectedName);
-            resolved.push({
-                name: selectedName,
-                args: {},
-                id: `stream-committed-plan-evidence-tool-${resolved.length + 1}`,
-            });
-        }
-    }
-    return resolved;
-}
-function hasExplicitToolNameReference(todoText, toolName) {
-    const normalizedToolName = toolName.trim().toLowerCase();
-    if (!normalizedToolName) {
-        return false;
-    }
-    const escapedName = normalizedToolName.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-    return new RegExp(`(?:^|[^\\p{L}\\p{N}_-])${escapedName}(?:$|[^\\p{L}\\p{N}_-])`, "iu").test(todoText);
-}
 function normalizePlanToolName(toolName) {
     return typeof toolName === "string" ? toolName.trim().toLowerCase().replace(/[\s-]+/gu, "_") : "";
 }
@@ -827,9 +704,8 @@ export async function* streamRuntimeExecution(options) {
                             && hadPriorPlanToolResult
                             && projectedChunks.some((chunk) => chunk.kind === "tool-result" && isPlanToolName(chunk.toolName));
                         if (repeatedPlanToolResultBeforeEvidence) {
-                            const planToolResult = projectedChunks.find((chunk) => chunk.kind === "tool-result" && isPlanToolName(chunk.toolName) && chunk.isError !== true);
-                            earlyStreamExternalPlanEvidenceTools = resolveCommittedPlanEvidenceTools(options.primaryTools, planToolResult?.kind === "tool-result" ? planToolResult.output : undefined);
-                            earlyStreamRecoveryInstruction = buildRunCommittedTodoEvidenceInstruction(options.primaryTools, planToolResult?.kind === "tool-result" ? planToolResult.output : undefined);
+                            earlyStreamExternalPlanEvidenceTools = resolveConfiguredPlanEvidenceTool(options.primaryTools);
+                            earlyStreamRecoveryInstruction = buildRunEvidenceAfterPlanInstruction(options.primaryTools);
                             earlyStreamRecoverySuppressInitialPlan = true;
                             break;
                         }
@@ -874,9 +750,8 @@ export async function* streamRuntimeExecution(options) {
                             && (hadPriorPlanToolResult
                                 || projectedChunks.some((chunk) => isCompletedPlanToolResultChunk(chunk)))
                             && !sawSuccessfulNonTodoToolResult) {
-                            const planToolResult = projectedChunks.find((chunk) => chunk.kind === "tool-result" && isPlanToolName(chunk.toolName) && chunk.isError !== true);
-                            earlyStreamExternalPlanEvidenceTools = resolveCommittedPlanEvidenceTools(options.primaryTools, planToolResult?.kind === "tool-result" ? planToolResult.output : undefined);
-                            earlyStreamRecoveryInstruction = buildRunCommittedTodoEvidenceInstruction(options.primaryTools, planToolResult?.kind === "tool-result" ? planToolResult.output : undefined);
+                            earlyStreamExternalPlanEvidenceTools = resolveConfiguredPlanEvidenceTool(options.primaryTools);
+                            earlyStreamRecoveryInstruction = buildRunEvidenceAfterPlanInstruction(options.primaryTools);
                             earlyStreamRecoverySuppressInitialPlan = true;
                             break;
                         }

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

@@ -196,58 +196,6 @@ function terminalToolErrorRecoveryInstruction(terminalText) {
 function requiresPlanEvidence(binding) {
     return binding.harnessRuntime.executionContract?.requiresPlan === true;
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function textExplicitlyNamesTool(text, toolName) {
-    const trimmedToolName = toolName.trim();
-    if (trimmedToolName.length === 0) {
-        return false;
-    }
-    return new RegExp(`(?:^|[^\\p{L}\\p{N}_-])${escapeRegExp(trimmedToolName)}(?:$|[^\\p{L}\\p{N}_-])`, "iu").test(text);
-}
-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(" ");
-            const matched = availableTools.map((tool) => tool.name).filter((toolName) => textExplicitlyNamesTool(content, toolName));
-            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 : [];
@@ -344,7 +292,7 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
                 : await callRuntimeWithToolParseRecovery(activeRequest));
         pendingResult = undefined;
         let toolCalls = extractToolCallsFromResult(result);
-        const committedTodoEvidenceTool = requiresPlanEvidence(binding)
+        const structuredExternalPlanEvidenceTool = requiresPlanEvidence(binding)
             && hasPlanStateEvidence(executedToolResults, externalPlanEvidence)
             && !hasNonTodoToolEvidence(executedToolResults)
             && (externalPlanEvidenceTool !== undefined || !hasIncompleteExecutedPlan(executedToolResults, externalPlanEvidence))
@@ -355,10 +303,10 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
                     args: externalPlanEvidenceTool.args ?? {},
                     id: externalPlanEvidenceTool.id ?? "external-plan-evidence-tool",
                 }
-                : resolveCommittedTodoEvidenceTool(executedToolResults, primaryTools)
+                : null
             : null;
-        if (committedTodoEvidenceTool) {
-            toolCalls = [committedTodoEvidenceTool];
+        if (structuredExternalPlanEvidenceTool) {
+            toolCalls = [structuredExternalPlanEvidenceTool];
         }
         if (toolCalls.length === 0) {
             const terminalText = sanitizeVisibleText(extractVisibleOutput(result) || "");
@@ -514,7 +462,6 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
             role: "system",
             content: TOOL_FOLLOW_UP_INSTRUCTION,
         });
-        const hadNonTodoEvidenceBeforeToolReplay = hasNonTodoToolEvidence(executedToolResults);
         for (let toolIndex = 0; toolIndex < toolCalls.length; toolIndex += 1) {
             const toolCall = toolCalls[toolIndex];
             const resolvedToolName = resolveModelFacingToolName(toolCall.name, toolNameMapping, primaryTools);
@@ -571,61 +518,6 @@ 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),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.455",
+  "version": "0.0.456",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",