@botbotgo/agent-harness 0.0.453 → 0.0.455

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.453";
+export declare const AGENT_HARNESS_VERSION = "0.0.455";
 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.453";
+export const AGENT_HARNESS_VERSION = "0.0.455";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-05-04";

package/dist/runtime/adapter/middleware-assembly.js

@@ -1,4 +1,4 @@
-import { AIMessage, HumanMessage, ToolMessage } from "@langchain/core/messages";
+import { AIMessage, HumanMessage } from "@langchain/core/messages";
 import { createMemoryMiddleware, createFilesystemMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSubAgentMiddleware, createSummarizationMiddleware, StateBackend, } from "deepagents";
 import { createAgent, humanInTheLoopMiddleware, todoListMiddleware } from "langchain";
 import { createBuiltinMiddlewareTools } from "./tool/builtin-middleware-tools.js";
@@ -9,7 +9,7 @@ import { resolveDeclaredMiddleware } from "./tool/declared-middleware.js";
 import { UPSTREAM_SESSION_CONFIG_KEY } from "./upstream-configurable-keys.js";
 import { bindingHasLangChainSubagentSupport, bindingHasMiddlewareKind, getBindingBuiltinToolsConfig, getBindingExecutionKind, getBindingGeneralPurposeAgent, getBindingDeepAgentSubagents, getBindingInterruptCompatibilityRules, getBindingMiddlewareConfigs, getBindingMemorySources, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSkills, getBindingSubagents, getBindingTaskDescription, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
 import { materializeDeepAgentSkillSourcePaths } from "./compat/deepagent-compat.js";
-import { DEFAULT_SUBAGENT_PROMPT, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, } from "../prompts/runtime-prompts.js";
+import { DEFAULT_SUBAGENT_PROMPT } from "../prompts/runtime-prompts.js";
 import { createContextHygieneMiddleware } from "./middleware/context-hygiene.js";
 const INVALID_TOOL_MESSAGE_BLOCK_TYPES = new Set(["tool_use", "thinking", "redacted_thinking"]);
 const DEFAULT_BUILTIN_TASK_TIMEOUT_MS = 180_000;
@@ -58,364 +58,6 @@ function extractDeepAgentTaskContent(result) {
     }
     return undefined;
 }
-function readMessageType(message) {
-    if (typeof message !== "object" || message === null) {
-        return "";
-    }
-    if (typeof message._getType === "function") {
-        const typeName = message._getType();
-        return typeof typeName === "string" ? typeName : "";
-    }
-    const typed = message;
-    if (typeof typed.type === "string") {
-        return typed.type;
-    }
-    const kwargs = typeof typed.kwargs === "object" && typed.kwargs !== null
-        ? typed.kwargs
-        : undefined;
-    if (typeof kwargs?.type === "string") {
-        return kwargs.type;
-    }
-    const lcKwargs = typeof typed.lc_kwargs === "object" && typed.lc_kwargs !== null
-        ? typed.lc_kwargs
-        : undefined;
-    return typeof lcKwargs?.type === "string" ? lcKwargs.type : "";
-}
-function readMessageName(message) {
-    if (typeof message !== "object" || message === null) {
-        return "";
-    }
-    const typed = message;
-    if (typeof typed.name === "string") {
-        return typed.name;
-    }
-    const kwargs = typeof typed.kwargs === "object" && typed.kwargs !== null
-        ? typed.kwargs
-        : undefined;
-    if (typeof kwargs?.name === "string") {
-        return kwargs.name;
-    }
-    const lcKwargs = typeof typed.lc_kwargs === "object" && typed.lc_kwargs !== null
-        ? typed.lc_kwargs
-        : undefined;
-    return typeof lcKwargs?.name === "string" ? lcKwargs.name : "";
-}
-function readMessages(result) {
-    if (typeof result !== "object" || result === null) {
-        return [];
-    }
-    const messages = result.messages;
-    return Array.isArray(messages) ? messages : [];
-}
-function readToolNames(tools) {
-    if (!Array.isArray(tools)) {
-        return new Set();
-    }
-    return new Set(tools
-        .map((tool) => {
-        if (typeof tool !== "object" || tool === null) {
-            return "";
-        }
-        const name = tool.name;
-        return typeof name === "string" ? name : "";
-    })
-        .filter((name) => name.length > 0));
-}
-function readResolvedEvidenceTools(tools) {
-    if (!Array.isArray(tools)) {
-        return [];
-    }
-    return tools
-        .map((tool) => {
-        if (typeof tool !== "object" || tool === null) {
-            return undefined;
-        }
-        const typed = tool;
-        if (typeof typed.name !== "string" || typed.name.trim().length === 0) {
-            return undefined;
-        }
-        const handler = [typed.invoke, typed.call, typed.func]
-            .find((candidate) => typeof candidate === "function");
-        return {
-            name: typed.name,
-            ...(typeof typed.description === "string" ? { description: typed.description } : {}),
-            schema: typed.schema,
-            ...(handler ? { invoke: (input, config) => handler.call(tool, input, config) } : {}),
-        };
-    })
-        .filter((tool) => tool !== undefined);
-}
-function hasSubagentExecutionToolEvidence(result, resolvedTools, configuredTools) {
-    const requiredToolNames = new Set([
-        ...readToolNames(configuredTools),
-        ...readToolNames(resolvedTools),
-    ]);
-    if (requiredToolNames.size === 0) {
-        return true;
-    }
-    for (const message of readMessages(result)) {
-        const typeName = readMessageType(message);
-        if (typeName !== "tool" && typeName !== "ToolMessage") {
-            continue;
-        }
-        const name = readMessageName(message);
-        if (name === "write_todos" || name === "read_todos") {
-            continue;
-        }
-        if (requiredToolNames.has(name)) {
-            return true;
-        }
-    }
-    return false;
-}
-function stringifyTaskState(value) {
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return String(value ?? "");
-    }
-}
-function extractUrls(value) {
-    return [...new Set((value.match(/https?:\/\/[^\s<>"')\]}]+/giu) ?? [])
-            .map((url) => url.replace(/[.,;:!?]+$/u, "")))];
-}
-function readSchemaObjectShape(schema) {
-    if (!isRecord(schema)) {
-        return undefined;
-    }
-    if (isRecord(schema.properties)) {
-        return schema.properties;
-    }
-    const candidates = [
-        schema._def?.shape,
-        schema._zod?.def?.shape,
-        schema.def?.shape,
-    ];
-    for (const candidate of candidates) {
-        const shape = typeof candidate === "function" ? candidate() : candidate;
-        if (isRecord(shape)) {
-            return shape;
-        }
-    }
-    return undefined;
-}
-function buildUrlSourceArgs(urls) {
-    return urls.map((url) => ({ type: "url", url, timeoutMs: 30000 }));
-}
-function buildEvidenceToolArgs(tool, taskText, evidenceText = taskText) {
-    const urls = extractUrls(evidenceText);
-    if (urls.length === 0) {
-        return {};
-    }
-    const shape = readSchemaObjectShape(tool.schema);
-    if (!shape) {
-        return {};
-    }
-    const args = {};
-    if ("sources" in shape) {
-        args.sources = buildUrlSourceArgs(urls);
-    }
-    if ("url" in shape) {
-        args.url = urls[0];
-    }
-    if ("urls" in shape) {
-        args.urls = urls;
-    }
-    if ("question" in shape) {
-        args.question = taskText.trim() || evidenceText.trim();
-    }
-    return args;
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function textExplicitlyNamesTool(text, toolName) {
-    const name = toolName.trim();
-    if (!name) {
-        return false;
-    }
-    const pattern = new RegExp(`(?:^|[^\\p{L}\\p{N}_-])${escapeRegExp(name)}(?:$|[^\\p{L}\\p{N}_-])`, "iu");
-    return pattern.test(text);
-}
-function resolveCommittedEvidenceTools(input) {
-    const availableTools = readResolvedEvidenceTools(input.resolvedTools)
-        .filter((tool) => tool.name !== "write_todos" && tool.name !== "read_todos" && typeof tool.invoke === "function");
-    if (availableTools.length === 0) {
-        return [];
-    }
-    const stateText = `${input.taskText}\n${stringifyTaskState(readMessages(input.result))}`;
-    const selected = [];
-    for (const tool of availableTools) {
-        if (!textExplicitlyNamesTool(stateText, tool.name)) {
-            continue;
-        }
-        selected.push({
-            tool,
-            args: buildEvidenceToolArgs(tool, input.taskText, stateText),
-        });
-    }
-    if (selected.length > 0) {
-        return selected.slice(0, 3);
-    }
-    return [];
-}
-async function appendCommittedEvidenceToolResults(input) {
-    const toolCalls = resolveCommittedEvidenceTools({
-        result: input.result,
-        taskText: input.taskText,
-        resolvedTools: input.resolvedTools,
-    });
-    if (process.env.AGENT_HARNESS_PROMPTED_JSON_DEBUG === "1") {
-        console.error(JSON.stringify({
-            type: "builtin-task-committed-evidence",
-            selectedTools: toolCalls.map((item) => item.tool.name),
-            availableTools: readResolvedEvidenceTools(input.resolvedTools).map((tool) => ({
-                name: tool.name,
-                hasInvoke: typeof tool.invoke === "function",
-            })),
-        }));
-    }
-    if (toolCalls.length === 0) {
-        return input.result;
-    }
-    const messages = [...readMessages(input.result)];
-    for (const [index, item] of toolCalls.entries()) {
-        const toolCallId = `committed-evidence-${item.tool.name}-${index + 1}`;
-        messages.push(new AIMessage({
-            content: "",
-            tool_calls: [{
-                    id: toolCallId,
-                    name: item.tool.name,
-                    args: item.args,
-                    type: "tool_call",
-                }],
-        }));
-        try {
-            const output = await item.tool.invoke(item.args, input.invokeConfig);
-            messages.push(new ToolMessage({
-                name: item.tool.name,
-                tool_call_id: toolCallId,
-                content: stringifyVisibleTaskContent(output) || stringifyTaskState(output),
-            }));
-        }
-        catch (error) {
-            messages.push(new ToolMessage({
-                name: item.tool.name,
-                tool_call_id: toolCallId,
-                content: error instanceof Error ? error.message : String(error),
-            }));
-        }
-    }
-    return {
-        ...(typeof input.result === "object" && input.result !== null ? input.result : {}),
-        messages,
-    };
-}
-function hasFinalAssistantAfterExecutionTool(result) {
-    const messages = readMessages(result);
-    const lastMessage = messages.at(-1);
-    const lastTypeName = readMessageType(lastMessage);
-    if (lastTypeName === "tool" || lastTypeName === "ToolMessage") {
-        return false;
-    }
-    let sawExecutionTool = false;
-    for (const message of messages) {
-        const typeName = readMessageType(message);
-        if (typeName === "tool" || typeName === "ToolMessage") {
-            const name = readMessageName(message);
-            if (name !== "write_todos" && name !== "read_todos") {
-                sawExecutionTool = true;
-            }
-            continue;
-        }
-        if (!sawExecutionTool) {
-            continue;
-        }
-        if (typeName === "ai" || typeName === "AIMessage" || typeName === "assistant") {
-            const content = typeof message === "object" && message !== null && "content" in message
-                ? message.content
-                : undefined;
-            if (typeof content === "string" && content.trim().length > 0) {
-                return true;
-            }
-            if (Array.isArray(content) && content.length > 0) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-const FINALIZE_AFTER_TOOL_EVIDENCE_INSTRUCTION = [
-    "You have already gathered the required non-planning tool evidence.",
-    "Now produce the final answer for the delegated task.",
-    "Do not return raw command stdout as the final answer.",
-    "Do not stop at a tool result.",
-    "Update TODO statuses if needed, then return the configured response format with concise findings, blockers, next actions, and report.",
-].join("\n");
-function stringifyVisibleTaskContent(value) {
-    if (typeof value === "string") {
-        return value;
-    }
-    if (Array.isArray(value)) {
-        return value
-            .map((block) => {
-            if (typeof block === "string") {
-                return block;
-            }
-            if (isRecord(block) && typeof block.text === "string") {
-                return block.text;
-            }
-            return "";
-        })
-            .filter(Boolean)
-            .join("\n");
-    }
-    return "";
-}
-function looksLikeRawToolOutput(value) {
-    const normalized = value.trim();
-    return /^(?:stdout|stderr)\s*:/iu.test(normalized)
-        || /(?:^|\n)\s*(?:stdout|stderr)\s*:/iu.test(normalized)
-        || /(?:^|\n)\s*exitCode\s*:\s*-?\d+\s*$/iu.test(normalized);
-}
-function collectNonPlanningToolNames(result) {
-    const names = [];
-    for (const message of readMessages(result)) {
-        const typeName = readMessageType(message);
-        if (typeName !== "tool" && typeName !== "ToolMessage") {
-            continue;
-        }
-        const name = readMessageName(message);
-        if (!name || name === "write_todos" || name === "read_todos") {
-            continue;
-        }
-        if (!names.includes(name)) {
-            names.push(name);
-        }
-    }
-    return names;
-}
-function formatDelegatedRawToolEvidenceReport(input) {
-    const toolNames = collectNonPlanningToolNames(input.result);
-    const excerpt = input.output.trim().slice(0, 4000);
-    return JSON.stringify({
-        status: "completed",
-        routing: [`task delegated to ${input.subagentName}`],
-        plan: ["Delegate to specialist", "Collect required tool evidence", "Return synthesized result"],
-        execution: [
-            `task invoked ${input.subagentName}`,
-            `tool evidence: ${toolNames.length > 0 ? toolNames.join(", ") : "non-planning tool"}`,
-        ],
-        todoTrace: ["specialist TODO plan was created and completed"],
-        stepResults: [`${input.subagentName} completed delegated tool evidence collection`],
-        summary: ["Delegated specialist completed the required evidence tool path."],
-        findings: ["The delegated agent ended on raw tool output, so the runtime wrapped that evidence in a structured completion report."],
-        blockers: ["none"],
-        nextActions: ["Use the captured evidence for final parent synthesis."],
-        report: excerpt,
-    });
-}
 export function extractSubagentRequestText(state) {
     if (!isRecord(state)) {
         return "";
@@ -693,27 +335,7 @@ export async function invokeBuiltinTaskTool(input) {
             new HumanMessage({ content }),
         ],
     }, invokeConfig), taskTimeoutMs, selectedSubagent.name);
-    let result = await invokeSubagent(description);
-    if (!hasSubagentExecutionToolEvidence(result, resolvedSubagentTools, selectedCompiledSubagent?.tools)) {
-        result = await invokeSubagent([description, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"));
-        if (!hasSubagentExecutionToolEvidence(result, resolvedSubagentTools, selectedCompiledSubagent?.tools)) {
-            result = await appendCommittedEvidenceToolResults({
-                result,
-                taskText: description,
-                resolvedTools: resolvedSubagentTools,
-                invokeConfig,
-            });
-        }
-        if (!hasSubagentExecutionToolEvidence(result, resolvedSubagentTools, selectedCompiledSubagent?.tools)) {
-            throw new Error(`Delegated agent ${selectedSubagent.name} completed without tool execution evidence: lacked non-planning tool evidence.`);
-        }
-    }
-    if (!hasFinalAssistantAfterExecutionTool(result)
-        || looksLikeRawToolOutput(stringifyVisibleTaskContent(extractDeepAgentTaskContent(result)))
-        || looksLikeRawToolOutput(extractVisibleOutput(result))
-        || looksLikeRawToolOutput(extractToolFallbackContext(result))) {
-        result = await invokeSubagent(FINALIZE_AFTER_TOOL_EVIDENCE_INSTRUCTION, readMessages(result));
-    }
+    const result = await invokeSubagent(description);
     const structuredResponse = typeof result === "object" && result !== null && "structuredResponse" in result
         ? result.structuredResponse
         : undefined;
@@ -721,14 +343,6 @@ export async function invokeBuiltinTaskTool(input) {
         return JSON.stringify(structuredResponse);
     }
     const taskContent = extractDeepAgentTaskContent(result);
-    const taskContentText = stringifyVisibleTaskContent(taskContent);
-    if (looksLikeRawToolOutput(taskContentText)) {
-        return formatDelegatedRawToolEvidenceReport({
-            subagentName: selectedSubagent.name,
-            output: taskContentText,
-            result,
-        });
-    }
     if (Array.isArray(taskContent)) {
         const filtered = taskContent.filter((block) => {
             const blockType = typeof block === "object" && block !== null && "type" in block
@@ -744,24 +358,10 @@ export async function invokeBuiltinTaskTool(input) {
         return taskContent;
     }
     const visibleOutput = extractVisibleOutput(result);
-    if (looksLikeRawToolOutput(visibleOutput)) {
-        return formatDelegatedRawToolEvidenceReport({
-            subagentName: selectedSubagent.name,
-            output: visibleOutput,
-            result,
-        });
-    }
     if (visibleOutput) {
         return visibleOutput;
     }
     const fallbackOutput = extractToolFallbackContext(result);
-    if (looksLikeRawToolOutput(fallbackOutput)) {
-        return formatDelegatedRawToolEvidenceReport({
-            subagentName: selectedSubagent.name,
-            output: fallbackOutput,
-            result,
-        });
-    }
     return fallbackOutput || "Task completed";
 }
 export async function resolveBuiltinMiddlewareTools(input) {

package/dist/runtime/agent-runtime-adapter.js

@@ -38,60 +38,8 @@ function hasDelegatedExecutionToolEvidence(result) {
     return executedToolResults.some((toolResult) => (toolResult.isError !== true
         && !isPlanToolName(toolResult.toolName)));
 }
-function normalizeEvidenceToolName(toolName) {
-    return typeof toolName === "string" ? toolName.trim().toLowerCase() : "";
-}
-function collectSuccessfulDelegatedExecutionToolNames(result) {
-    const executedToolResults = Array.isArray(result.metadata?.executedToolResults)
-        ? result.metadata.executedToolResults
-        : [];
-    return new Set(executedToolResults
-        .filter((toolResult) => toolResult.isError !== true && !isPlanToolName(toolResult.toolName))
-        .map((toolResult) => normalizeEvidenceToolName(toolResult.toolName))
-        .filter((toolName) => toolName.length > 0));
-}
-function textExplicitlyNamesConfiguredTool(text, toolName) {
-    const name = toolName.trim();
-    if (!name) {
-        return false;
-    }
-    const pattern = new RegExp(`(?:^|[^\\p{L}\\p{N}_-])${escapeRegExp(name)}(?:$|[^\\p{L}\\p{N}_-])`, "iu");
-    return pattern.test(text);
-}
-function resolveExplicitRequestedExecutionToolNames(binding, requestText) {
-    const text = requestText.trim();
-    if (!text) {
-        return [];
-    }
-    return getBindingPrimaryTools(binding)
-        .map((tool) => tool.name)
-        .filter((toolName) => typeof toolName === "string" && toolName.trim().length > 0)
-        .filter((toolName) => !isPlanToolName(toolName))
-        .filter((toolName) => textExplicitlyNamesConfiguredTool(text, toolName));
-}
-function listMissingDelegatedExecutionToolEvidence(result, requiredToolNames = []) {
-    if (requiredToolNames.length === 0) {
-        return hasDelegatedExecutionToolEvidence(result) ? [] : ["configured non-planning tools"];
-    }
-    const observed = collectSuccessfulDelegatedExecutionToolNames(result);
-    return requiredToolNames.filter((toolName) => !observed.has(normalizeEvidenceToolName(toolName)));
-}
-function hasRequiredDelegatedExecutionToolEvidence(result, requiredToolNames = []) {
-    return hasDelegatedExecutionToolEvidence(result)
-        && listMissingDelegatedExecutionToolEvidence(result, requiredToolNames).length === 0;
-}
-function buildExplicitExecutionToolRetryInstruction(missingToolNames) {
-    const tools = missingToolNames
-        .filter((toolName) => toolName !== "configured non-planning tools")
-        .join(", ");
-    if (!tools) {
-        return "";
-    }
-    return [
-        `The request explicitly named configured evidence tool(s): ${tools}.`,
-        "Before the final answer, call every listed non-planning tool that has not already produced a successful tool result.",
-        "Do not substitute a different evidence tool for an explicitly named configured tool unless that tool invocation itself fails and the blocker is reported.",
-    ].join("\n");
+function hasRequiredDelegatedExecutionToolEvidence(result) {
+    return hasDelegatedExecutionToolEvidence(result);
 }
 function buildDelegatedPlanEvidenceBlocker(agentId) {
     return JSON.stringify({
@@ -329,9 +277,6 @@ function buildDelegatedOwnedTaskInstruction(input) {
         "Close every TODO as completed or failed before final output.",
     ].filter(Boolean).join("\n");
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-}
 function isDelegationOnlyDeepAgentBinding(binding) {
     return isDeepAgentBinding(binding)
         && getBindingSubagents(binding).length > 0
@@ -752,15 +697,12 @@ export class AgentRuntimeAdapter {
                             const runDelegatedRequest = (text, requestSuffix = "") => this.invoke(targetBinding, text, childSessionId, `${childRequestId}${requestSuffix}`, undefined, [], invokeOptions);
                             let result = await runDelegatedRequest(requestText);
                             const targetRequiresExecutionToolEvidence = getBindingPrimaryTools(targetBinding).length > 0;
-                            const requiredExecutionToolNames = resolveExplicitRequestedExecutionToolNames(targetBinding, requestText);
-                            if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(result, requiredExecutionToolNames)) {
-                                const missingToolNames = listMissingDelegatedExecutionToolEvidence(result, requiredExecutionToolNames);
+                            if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(result)) {
                                 result = await runDelegatedRequest([
                                     requestText,
                                     EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION,
-                                    buildExplicitExecutionToolRetryInstruction(missingToolNames),
                                 ].filter(Boolean).join("\n\n"), ":tool-evidence-retry");
-                                if (!hasRequiredDelegatedExecutionToolEvidence(result, requiredExecutionToolNames)) {
+                                if (!hasRequiredDelegatedExecutionToolEvidence(result)) {
                                     throw new DelegatedExecutionNoToolEvidenceError(targetBinding.agent.id);
                                 }
                             }
@@ -1304,7 +1246,6 @@ export class AgentRuntimeAdapter {
             }
         }
         const targetRequiresExecutionToolEvidence = getBindingPrimaryTools(selectedBinding).length > 0;
-        const requiredExecutionToolNames = resolveExplicitRequestedExecutionToolNames(selectedBinding, requestText);
         if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
             && !hasDelegatedPlanEvidence(delegatedResult)) {
             try {
@@ -1324,13 +1265,11 @@ export class AgentRuntimeAdapter {
                 };
             }
         }
-        if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(delegatedResult, requiredExecutionToolNames)) {
-            const missingToolNames = listMissingDelegatedExecutionToolEvidence(delegatedResult, requiredExecutionToolNames);
+        if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(delegatedResult)) {
             try {
                 delegatedResult = await runDelegatedRequest([
                     requestText,
                     EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION,
-                    buildExplicitExecutionToolRetryInstruction(missingToolNames),
                 ].filter(Boolean).join("\n\n"), ":tool-evidence-retry", selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
                     ? {
                         suppressInitialRequiredPlanInstruction: true,
@@ -1366,10 +1305,8 @@ export class AgentRuntimeAdapter {
                 },
             };
         }
-        if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(delegatedResult, requiredExecutionToolNames)) {
-            const output = buildDelegatedExecutionEvidenceBlocker(selectedBinding.agent.id, requiredExecutionToolNames.length > 0
-                ? requiredExecutionToolNames
-                : getBindingPrimaryTools(selectedBinding).map((tool) => tool.name));
+        if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(delegatedResult)) {
+            const output = buildDelegatedExecutionEvidenceBlocker(selectedBinding.agent.id, getBindingPrimaryTools(selectedBinding).map((tool) => tool.name));
             return {
                 toolOutput: output,
                 delegatedSubagentType: subagentType,
@@ -1764,16 +1701,11 @@ export class AgentRuntimeAdapter {
                     delegatedResult = mergeDelegatedResultToolEvidence(yield* runPlannedDelegation(planned.subagentType, [delegatedText, DELEGATED_PLAN_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-retry"), previousDelegatedResult);
                 }
                 const targetRequiresExecutionToolEvidence = selectedBinding ? getBindingPrimaryTools(selectedBinding).length > 0 : false;
-                const requiredExecutionToolNames = selectedBinding
-                    ? resolveExplicitRequestedExecutionToolNames(selectedBinding, planned.description)
-                    : [];
-                if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(delegatedResult, requiredExecutionToolNames)) {
-                    const missingToolNames = listMissingDelegatedExecutionToolEvidence(delegatedResult, requiredExecutionToolNames);
+                if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(delegatedResult)) {
                     const previousDelegatedResult = delegatedResult;
                     delegatedResult = mergeDelegatedResultToolEvidence(yield* runPlannedDelegation(planned.subagentType, [
                         delegatedText,
                         EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION,
-                        buildExplicitExecutionToolRetryInstruction(missingToolNames),
                     ].filter(Boolean).join("\n\n"), ":tool-evidence-retry"), previousDelegatedResult);
                 }
                 if (selectedBinding?.harnessRuntime.executionContract?.requiresPlan === true && !hasDelegatedPlanEvidence(delegatedResult)) {
@@ -1785,10 +1717,8 @@ export class AgentRuntimeAdapter {
                         finalMessageText: output,
                     };
                 }
-                if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(delegatedResult, requiredExecutionToolNames)) {
-                    const output = buildDelegatedExecutionEvidenceBlocker(selectedBinding.agent.id, requiredExecutionToolNames.length > 0
-                        ? requiredExecutionToolNames
-                        : getBindingPrimaryTools(selectedBinding).map((tool) => tool.name));
+                if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(delegatedResult)) {
+                    const output = buildDelegatedExecutionEvidenceBlocker(selectedBinding.agent.id, getBindingPrimaryTools(selectedBinding).map((tool) => tool.name));
                     delegatedResult = {
                         ...delegatedResult,
                         state: "failed",
@@ -1981,19 +1911,16 @@ export class AgentRuntimeAdapter {
         });
         let delegatedResult = yield* runDelegatedStreamAttempt(delegatedText);
         const targetRequiresExecutionToolEvidence = getBindingPrimaryTools(selectedBinding).length > 0;
-        const requiredExecutionToolNames = resolveExplicitRequestedExecutionToolNames(selectedBinding, requestText);
         if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
             && !hasDelegatedPlanEvidence(delegatedResult)) {
             const previousDelegatedResult = delegatedResult;
             delegatedResult = mergeDelegatedResultToolEvidence(yield* runDelegatedStreamAttempt([delegatedText, DELEGATED_PLAN_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-retry"), previousDelegatedResult);
         }
-        if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(delegatedResult, requiredExecutionToolNames)) {
-            const missingToolNames = listMissingDelegatedExecutionToolEvidence(delegatedResult, requiredExecutionToolNames);
+        if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(delegatedResult)) {
             const previousDelegatedResult = delegatedResult;
             delegatedResult = mergeDelegatedResultToolEvidence(yield* runDelegatedStreamAttempt([
                 delegatedText,
                 EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION,
-                buildExplicitExecutionToolRetryInstruction(missingToolNames),
             ].filter(Boolean).join("\n\n"), ":tool-evidence-retry"), previousDelegatedResult);
         }
         if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
@@ -2006,10 +1933,8 @@ export class AgentRuntimeAdapter {
                 finalMessageText: output,
             };
         }
-        if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(delegatedResult, requiredExecutionToolNames)) {
-            const output = buildDelegatedExecutionEvidenceBlocker(selectedBinding.agent.id, requiredExecutionToolNames.length > 0
-                ? requiredExecutionToolNames
-                : getBindingPrimaryTools(selectedBinding).map((tool) => tool.name));
+        if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(delegatedResult)) {
+            const output = buildDelegatedExecutionEvidenceBlocker(selectedBinding.agent.id, getBindingPrimaryTools(selectedBinding).map((tool) => tool.name));
             delegatedResult = {
                 ...delegatedResult,
                 state: "failed",

package/package.json

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