@botbotgo/agent-harness 0.0.452 → 0.0.454

package/dist/package-version.d.ts

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

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

@@ -799,15 +799,12 @@ export async function resolveBuiltinMiddlewareTools(input) {
     if (builtinTools.filesystem === false) {
         for (const name of [
             "ls",
-            "list_files",
             "read_file",
             "write_file",
             "edit_file",
             "glob",
             "grep",
-            "search_files",
             "execute",
-            "run_command",
         ]) {
             tools.delete(name);
         }

package/dist/runtime/adapter/tool/builtin-middleware-tools.d.ts

@@ -201,9 +201,6 @@ export declare const BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS: readonly [{
 }, {
     readonly name: "ls";
     readonly description: "List files in a directory.";
-}, {
-    readonly name: "list_files";
-    readonly description: "List files in a directory.";
 }, {
     readonly name: "read_file";
     readonly description: "Read a file from the workspace filesystem.";
@@ -219,15 +216,9 @@ export declare const BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS: readonly [{
 }, {
     readonly name: "grep";
     readonly description: "Search for text across workspace files.";
-}, {
-    readonly name: "search_files";
-    readonly description: "Search for text across workspace files.";
 }, {
     readonly name: "execute";
     readonly description: "Run a shell command in the workspace sandbox.";
-}, {
-    readonly name: "run_command";
-    readonly description: "Run a shell command in the workspace sandbox.";
 }, {
     readonly name: "fetch_url";
     readonly description: "Fetch a URL and return the response body.";

package/dist/runtime/adapter/tool/builtin-middleware-tools.js

@@ -35,15 +35,12 @@ export const BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS = [
     { name: "write_todos", description: "Create and update the runtime todo board for multi-step work." },
     { name: "read_todos", description: "Read the current runtime todo board." },
     { name: "ls", description: "List files in a directory." },
-    { name: "list_files", description: "List files in a directory." },
     { name: "read_file", description: "Read a file from the workspace filesystem." },
     { name: "write_file", description: "Write a file in the workspace filesystem." },
     { name: "edit_file", description: "Replace exact text inside a workspace file." },
     { name: "glob", description: "Find files matching a glob pattern." },
     { name: "grep", description: "Search for text across workspace files." },
-    { name: "search_files", description: "Search for text across workspace files." },
     { name: "execute", description: "Run a shell command in the workspace sandbox." },
-    { name: "run_command", description: "Run a shell command in the workspace sandbox." },
     { name: "fetch_url", description: "Fetch a URL and return the response body." },
     { name: "http_request", description: "Send a structured HTTP request." },
     { name: "send_message", description: "Send a message through the configured backend." },
@@ -70,15 +67,12 @@ export function filterBuiltinMiddlewareToolDescriptors(options) {
         if (options?.filesystem === false
             && [
                 "ls",
-                "list_files",
                 "read_file",
                 "write_file",
                 "edit_file",
                 "glob",
                 "grep",
-                "search_files",
                 "execute",
-                "run_command",
             ].includes(descriptor.name)) {
             return false;
         }
@@ -330,12 +324,6 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             return finalizeOutput("ls", truncateLines(infos.map((info) => info.is_dir ? `${info.path} (directory)` : `${info.path}${info.size ? ` (${info.size} bytes)` : ""}`)), toolConfig);
         },
     });
-    tools.set("list_files", {
-        name: "list_files",
-        description: "List files in a directory.",
-        schema: z.object({ path: z.string().optional().default("/") }).passthrough(),
-        invoke: async (input, toolConfig) => tools.get("ls").invoke(input, toolConfig),
-    });
     tools.set("read_file", {
         name: "read_file",
         description: "Read a file from the workspace filesystem.",
@@ -438,26 +426,6 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             return truncateLines(lines);
         },
     });
-    tools.set("search_files", {
-        name: "search_files",
-        description: "Search for text across workspace files.",
-        schema: z.object({
-            query: z.string(),
-            path: z.string().optional().default("/"),
-            glob: z.string().nullable().optional(),
-            search_type: z.enum(["content", "path"]).optional().default("content"),
-        }).passthrough(),
-        invoke: async (input) => {
-            const typed = isRecord(input) ? input : {};
-            const query = typeof typed.query === "string" ? typed.query : "";
-            const searchPath = normalizeWorkspacePathOrThrow(pathScopedBackend, typeof typed.path === "string" ? typed.path : "/");
-            const globPattern = typeof typed.glob === "string" ? typed.glob : null;
-            const searchType = typed.search_type === "path" ? "path" : "content";
-            return searchType === "path"
-                ? tools.get("glob").invoke({ pattern: query, path: searchPath })
-                : tools.get("grep").invoke({ pattern: query, path: searchPath, glob: globPattern });
-        },
-    });
     tools.set("execute", {
         name: "execute",
         description: "Run a shell command in the workspace sandbox.",
@@ -478,12 +446,6 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             return finalizeOutput("execute", parts.join(""), toolConfig);
         },
     });
-    tools.set("run_command", {
-        name: "run_command",
-        description: "Run a shell command in the workspace sandbox.",
-        schema: z.object({ command: z.string() }).passthrough(),
-        invoke: async (input, toolConfig) => tools.get("execute").invoke(input, toolConfig),
-    });
     tools.set("fetch_url", {
         name: "fetch_url",
         description: "Fetch a URL and return the response body.",

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/dist/runtime/agent-runtime-assembly.js

@@ -6,11 +6,6 @@ import { readSkillMetadata } from "./skills/skill-metadata.js";
 import { getBindingBackendConfig, getBindingExecutionKind, getBindingExecutionParams, getBindingInterruptCompatibilityRules, getBindingMemorySources, getBindingMiddlewareConfigs, getBindingPrimaryTools, getBindingSkills, getBindingStoreConfig, } from "./support/compiled-binding.js";
 export const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
 export const DEFAULT_DEEPAGENT_RECURSION_LIMIT = 100;
-const BUILTIN_MIDDLEWARE_ALIAS_TOOL_NAMES = new Set([
-    "list_files",
-    "search_files",
-    "run_command",
-]);
 const MODEL_EXPOSED_BUILTIN_MIDDLEWARE_TOOL_NAMES = new Set([
     "fetch_url",
     "http_request",
@@ -29,7 +24,6 @@ export function materializeModelExposedBuiltinMiddlewareTools(input) {
     const tools = [];
     for (const [toolName, tool] of input.builtinTools.entries()) {
         if (explicitToolNames.has(toolName)
-            || BUILTIN_MIDDLEWARE_ALIAS_TOOL_NAMES.has(toolName)
             || !MODEL_EXPOSED_BUILTIN_MIDDLEWARE_TOOL_NAMES.has(toolName)
             || (allowedToolNames && !allowedToolNames.has(toolName))) {
             continue;

package/dist/scaffold/init-project.js

@@ -511,7 +511,7 @@ description: Inspect the current workspace before making claims or edits.
 
 # Workspace Inspection
 
-1. Start with lightweight discovery such as \`list_files\` or \`search_files\`.
+1. Start with lightweight discovery such as \`ls\`, \`glob\`, or \`grep\`.
 2. Read only the files needed to establish the relevant facts.
 3. Ground each conclusion in inspected workspace evidence instead of guesses.
 4. If the workspace does not contain the needed evidence, say that plainly before proposing a next step.

package/package.json

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