@botbotgo/agent-harness 0.0.400 → 0.0.401

package/dist/runtime/adapter/model/model-providers.js

@@ -211,6 +211,48 @@ function hasPriorToolResultForToolName(input, toolName) {
     }
     return false;
 }
+function hasAnyPriorToolResult(input) {
+    if (Array.isArray(input)) {
+        return input.some((message) => mapMessageRole(message) === "TOOL");
+    }
+    if (typeof input === "object" && input !== null && Array.isArray(input.messages)) {
+        return hasAnyPriorToolResult(input.messages);
+    }
+    return false;
+}
+function hasPriorNonPlanningToolCall(input) {
+    if (Array.isArray(input)) {
+        return input.some((message) => readToolCalls(message).some((toolCall) => {
+            if (typeof toolCall !== "object" || toolCall === null) {
+                return false;
+            }
+            const name = typeof toolCall.name === "string"
+                ? toolCall.name
+                : "";
+            return name.length > 0 && !isTodoPlanningToolName(name);
+        }));
+    }
+    if (typeof input === "object" && input !== null && Array.isArray(input.messages)) {
+        return hasPriorNonPlanningToolCall(input.messages);
+    }
+    return false;
+}
+function readLatestToolResultContent(input) {
+    if (Array.isArray(input)) {
+        for (let index = input.length - 1; index >= 0; index -= 1) {
+            const message = input[index];
+            if (mapMessageRole(message) === "TOOL") {
+                const content = readPromptContent(message);
+                return content || null;
+            }
+        }
+        return null;
+    }
+    if (typeof input === "object" && input !== null && Array.isArray(input.messages)) {
+        return readLatestToolResultContent(input.messages);
+    }
+    return null;
+}
 function readBoundToolName(tool) {
     return typeof tool === "object" && tool !== null && typeof tool.name === "string"
         ? tool.name.trim()
@@ -357,47 +399,6 @@ function stringifyNodeLlamaCppInput(input) {
     }
     return readPromptContent(input);
 }
-function readLatestUserPromptContent(input) {
-    const messages = typeof input === "object"
-        && input !== null
-        && Array.isArray(input.messages)
-        ? input.messages
-        : Array.isArray(input)
-            ? input
-            : null;
-    if (!messages) {
-        return readPromptContent(input);
-    }
-    for (let index = messages.length - 1; index >= 0; index -= 1) {
-        if (mapMessageRole(messages[index]) !== "USER") {
-            continue;
-        }
-        const content = readPromptContent(messages[index]);
-        if (content) {
-            return content;
-        }
-    }
-    return stringifyNodeLlamaCppInput(input);
-}
-function inferStockRequest(input) {
-    const prompt = readLatestUserPromptContent(input);
-    const directSymbol = prompt.match(/\b[A-Z]{1,5}(?:\.[A-Z])?\b/u)?.[0];
-    const lower = prompt.toLowerCase();
-    const enterpriseHcmName = ["work", "day"].join("");
-    const symbol = directSymbol
-        ?? (/\bapple\b/u.test(lower) || /苹果/u.test(prompt) ? "AAPL" : undefined)
-        ?? (new RegExp(`\\b${enterpriseHcmName}\\b`, "u").test(lower) ? "WDAY" : undefined);
-    const company = symbol === "AAPL"
-        ? "Apple Inc."
-        : symbol === "WDAY"
-            ? `${enterpriseHcmName[0].toUpperCase()}${enterpriseHcmName.slice(1)} Inc.`
-            : undefined;
-    return {
-        ...(symbol ? { symbol } : {}),
-        ...(company ? { company } : {}),
-        query: symbol ? `${company ?? symbol} ${symbol} stock briefing` : prompt || "public company stock briefing",
-    };
-}
 function extractToolCallPayload(text) {
     const trimmed = text.trim();
     if (!trimmed) {
@@ -580,34 +581,19 @@ function isLowSignalPlanningLine(value) {
 function normalizeDomainToolName(name) {
     return name.startsWith("tool_call_") ? name.slice("tool_call_".length) : name;
 }
-function selectFallbackEvidenceToolName(input, tools) {
-    const prompt = stringifyNodeLlamaCppInput(input).toLowerCase();
+function selectFallbackEvidenceToolName(tools, rawText = "") {
+    const normalizedRawText = rawText.toLowerCase();
     const available = tools
         .map((tool) => normalizeDomainToolName(readBoundToolName(tool)))
         .filter((name) => name && !isTodoPlanningToolName(name) && !isTodoPlanningToolName(`tool_call_${name}`));
-    const hasTool = (name) => available.includes(name);
-    const rules = [
-        [/\b(k8s|kubernetes|kubectl|pod|pods|node|nodes|cluster)\b|集群|节点|调度/u, ["k8s_cluster_investigate", "k8s_cluster_triage", "kubectl_command"]],
-        [/\b(disk|cache|storage|workspace)\b|磁盘|缓存|占用/u, ["disk_space_investigate"]],
-        [/\b(agent config|agent configuration|repository structure|repo structure|code evidence|specialist)\b|agent\s*配置|配置结构|新增\s*specialist|代码层证据|改哪些文件/u, ["git_command", "codex_repo_analysis"]],
-        [/\b(stock|ticker|finance|market brief|aapl|wday)\b|股票|公开股票简报|金融|市场简报/u, ["finance_stock_report", "finance_quote_snapshot"]],
-        [/\b(test|qa|coverage|regression|playwright)\b|测试|覆盖率|回归|验证/u, ["git_command", "codex_repo_analysis", "playwright_capture"]],
-        [/\b(release|readiness|branch|tag|github actions|ci)\b|发版|分支|流水线|可发版/u, ["git_command", "gh_actions_command"]],
-        [/\b(youtube|transcript|brief|briefing|summary)\b|摘要|简报|讲稿/u, ["youtube_video_summary", "llamaindex_source_analysis", "finance_stock_report"]],
-    ];
-    for (const [pattern, toolNames] of rules) {
-        if (!pattern.test(prompt)) {
-            continue;
-        }
-        const matched = toolNames.find((name) => hasTool(name));
-        if (matched) {
-            return matched;
-        }
+    if (available.length === 0) {
+        return null;
     }
-    return available[0] ?? null;
+    const mentioned = available.find((name) => normalizedRawText.includes(name.toLowerCase()));
+    return mentioned ?? available[0] ?? null;
 }
-function buildToolAwareFallbackTodoContents(input, tools) {
-    const evidenceToolName = selectFallbackEvidenceToolName(input, tools);
+function buildToolAwareFallbackTodoContents(tools, rawText = "") {
+    const evidenceToolName = selectFallbackEvidenceToolName(tools, rawText);
     if (!evidenceToolName) {
         return [
             "Identify the concrete evidence tool required for this request",
@@ -635,7 +621,7 @@ function buildFallbackPlanningToolCall(input, planningTools, allTools, rawText)
     const hasUsefulModelPlan = modelPlannedItems.length >= 2 && !modelPlannedItems.every(isGenericFallbackTodoContent);
     const fallbackItems = hasUsefulModelPlan
         ? modelPlannedItems
-        : buildToolAwareFallbackTodoContents(input, allTools);
+        : buildToolAwareFallbackTodoContents(allTools, rawText);
     const todos = fallbackItems.map((content, index) => ({
         content,
         status: index === 0 ? "in_progress" : "pending",
@@ -650,60 +636,45 @@ function buildFallbackPlanningToolCall(input, planningTools, allTools, rawText)
             }],
     });
 }
-function buildFallbackEvidenceToolArgs(toolName, input) {
-    const prompt = stringifyNodeLlamaCppInput(input);
-    const lower = prompt.toLowerCase();
-    if (toolName === "git_command") {
-        if (/\b(agent config|agent configuration|specialist)\b|agent\s*配置|配置结构|新增\s*specialist|代码层证据|改哪些文件/u.test(lower)) {
-            return {
-                args: ["ls-files", "config/agents", "config/agent-context.md", "config/runtime", "config/models.yaml"],
-                cwd: ".",
-                timeoutMs: 10000,
-            };
-        }
-        return { args: ["status", "--short"], cwd: ".", timeoutMs: 10000 };
-    }
-    if (toolName === "disk_space_investigate") {
-        return { targetPath: ".", cwd: ".", timeoutMs: 10000 };
-    }
-    if (toolName === "finance_stock_report") {
-        return {
-            ...inferStockRequest(input),
-            market: "us",
-            count: 5,
-        };
-    }
-    if (toolName === "codex_repo_analysis") {
-        return {
-            repoPath: ".",
-            question: "Analyze the repository structure and provide concrete file-level evidence for the requested code/configuration question.",
-            timeoutMs: 30000,
-            skipGitRepoCheck: true,
-        };
-    }
-    if (toolName === "k8s_cluster_investigate") {
-        return { timeoutMs: 30000 };
-    }
-    if (toolName === "k8s_cluster_triage") {
-        return { timeoutMs: 30000 };
+function buildFallbackEvidenceToolArgs(tool) {
+    const schema = normalizeModelFacingToolSchema(tool);
+    if (typeof schema.properties !== "object" || schema.properties === null || Array.isArray(schema.properties)) {
+        return {};
     }
-    if (toolName === "gh_actions_command") {
-        return { args: ["list", "--limit", "5"], cwd: ".", timeoutMs: 30000 };
+    const required = Array.isArray(schema.required)
+        ? schema.required.filter((name) => typeof name === "string")
+        : [];
+    const values = {};
+    for (const [key, value] of Object.entries(schema.properties)) {
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+            continue;
+        }
+        const property = value;
+        if ("default" in property) {
+            values[key] = property.default;
+            continue;
+        }
+        if ("const" in property) {
+            values[key] = property.const;
+            continue;
+        }
+        if (required.includes(key) && Array.isArray(property.enum) && property.enum.length > 0) {
+            values[key] = property.enum[0];
+        }
     }
-    return {};
+    return values;
 }
-function buildFallbackEvidenceToolCall(input, tools) {
+function buildFallbackEvidenceToolCall(input, tools, rawText = "") {
     if (!hasPriorToolResultForToolName(input, "write_todos") && !hasPriorToolResultForToolName(input, "tool_call_write_todos")) {
         return null;
     }
-    const evidenceToolName = selectFallbackEvidenceToolName(input, tools);
+    const evidenceToolName = selectFallbackEvidenceToolName(tools, rawText);
     if (!evidenceToolName) {
         return null;
     }
-    const boundToolName = tools
-        .map((tool) => readBoundToolName(tool))
-        .find((name) => normalizeDomainToolName(name) === evidenceToolName);
-    if (!boundToolName || hasPriorToolResultForToolName(input, boundToolName) || hasPriorToolResultForToolName(input, evidenceToolName)) {
+    const boundTool = tools.find((tool) => normalizeDomainToolName(readBoundToolName(tool)) === evidenceToolName);
+    const boundToolName = readBoundToolName(boundTool);
+    if (!boundTool || !boundToolName || hasPriorToolResultForToolName(input, boundToolName) || hasPriorToolResultForToolName(input, evidenceToolName)) {
         return null;
     }
     return new AIMessage({
@@ -711,7 +682,7 @@ function buildFallbackEvidenceToolCall(input, tools) {
         tool_calls: [{
                 id: `fallback-evidence-${Math.random().toString(36).slice(2, 10)}`,
                 name: boundToolName,
-                args: buildFallbackEvidenceToolArgs(evidenceToolName, input),
+                args: buildFallbackEvidenceToolArgs(boundTool),
                 type: "tool_call",
             }],
     });
@@ -725,7 +696,7 @@ function buildFallbackTodoCompletionToolCall(input, tools) {
     if (!planningToolName) {
         return null;
     }
-    const evidenceToolName = selectFallbackEvidenceToolName(input, tools);
+    const evidenceToolName = selectFallbackEvidenceToolName(tools, prompt);
     if (!evidenceToolName) {
         return null;
     }
@@ -735,7 +706,7 @@ function buildFallbackTodoCompletionToolCall(input, tools) {
     if (!hasEvidenceResult) {
         return null;
     }
-    const todos = buildToolAwareFallbackTodoContents(input, tools).map((content) => ({
+    const todos = buildToolAwareFallbackTodoContents(tools, prompt).map((content) => ({
         content,
         status: "completed",
     }));
@@ -749,6 +720,33 @@ function buildFallbackTodoCompletionToolCall(input, tools) {
             }],
     });
 }
+function parsedToolCallCompletesTodoPlan(toolCall) {
+    if (!isTodoPlanningToolName(toolCall.name)) {
+        return false;
+    }
+    const todos = toolCall.args.todos;
+    if (!Array.isArray(todos) || todos.length === 0) {
+        return false;
+    }
+    return todos.every((todo) => typeof todo === "object"
+        && todo !== null
+        && todo.status === "completed");
+}
+function normalizeInitialTodoPlanToolCall(toolCall) {
+    if (!parsedToolCallCompletesTodoPlan(toolCall)) {
+        return toolCall;
+    }
+    const todos = toolCall.args.todos.map((todo, index) => typeof todo === "object" && todo !== null && !Array.isArray(todo)
+        ? { ...todo, status: index === 0 ? "in_progress" : "pending" }
+        : todo);
+    return {
+        name: toolCall.name,
+        args: {
+            ...toolCall.args,
+            todos,
+        },
+    };
+}
 function formatBoundToolInstruction(tool) {
     if (typeof tool !== "object" || tool === null) {
         return null;
@@ -805,6 +803,15 @@ function createPromptedJsonToolBindableModel(model, boundTools = [], options = {
                 return async (input, config) => {
                     const effectiveBoundTools = selectPlanningToolsForTurn(input, boundTools);
                     const forcePlanningToolCall = shouldLimitToolsToPlanning(input);
+                    if (options.settleCompletedToolResults === true
+                        && !forcePlanningToolCall
+                        && effectiveBoundTools.length > 0
+                        && hasAnyPriorToolResult(input)
+                        && hasPriorNonPlanningToolCall(input)) {
+                        return new AIMessage({
+                            content: readLatestToolResultContent(input) ?? "",
+                        });
+                    }
                     const rawResult = await target.invoke(effectiveBoundTools.length > 0
                         ? withPromptedJsonToolPrompt(input, effectiveBoundTools, { ...options, forcePlanningToolCall })
                         : input, config);
@@ -825,22 +832,32 @@ function createPromptedJsonToolBindableModel(model, boundTools = [], options = {
                             if (fallbackCompletionToolCall) {
                                 return fallbackCompletionToolCall;
                             }
-                            const fallbackToolCall = buildFallbackEvidenceToolCall(input, effectiveBoundTools);
+                            const fallbackToolCall = buildFallbackEvidenceToolCall(input, effectiveBoundTools, text);
                             if (fallbackToolCall) {
                                 return fallbackToolCall;
                             }
                         }
                         return rawResult;
                     }
-                    if (hasPriorToolResultForToolName(input, parsedToolCall.name)) {
+                    const effectiveParsedToolCall = forcePlanningToolCall
+                        ? normalizeInitialTodoPlanToolCall(parsedToolCall)
+                        : parsedToolCall;
+                    if (parsedToolCallCompletesTodoPlan(effectiveParsedToolCall)
+                        && !hasPriorNonPlanningToolResult(input, effectiveBoundTools)) {
+                        const fallbackToolCall = buildFallbackEvidenceToolCall(input, effectiveBoundTools, text);
+                        if (fallbackToolCall) {
+                            return fallbackToolCall;
+                        }
+                    }
+                    if (hasPriorToolResultForToolName(input, effectiveParsedToolCall.name) || hasAnyPriorToolResult(input)) {
                         return rawResult;
                     }
                     return new AIMessage({
                         content: "",
                         tool_calls: [{
                                 id: `tool-${Math.random().toString(36).slice(2, 10)}`,
-                                name: parsedToolCall.name,
-                                args: parsedToolCall.args,
+                                name: effectiveParsedToolCall.name,
+                                args: effectiveParsedToolCall.args,
                                 type: "tool_call",
                             }],
                     });
@@ -916,7 +933,10 @@ export async function createResolvedModel(model, modelResolver) {
         const { toolCallingMode, ...init } = model.init ?? {};
         const resolved = new ChatOllama({ model: model.model, ...init });
         if (toolCallingMode === "prompted-json") {
-            return createPromptedJsonToolBindableModel(resolved, [], { suppressThinking: init.think === false });
+            return createPromptedJsonToolBindableModel(resolved, [], {
+                settleCompletedToolResults: true,
+                suppressThinking: init.think === false,
+            });
         }
         return createProviderToolMessageCompatModel(resolved);
     }
@@ -927,7 +947,10 @@ export async function createResolvedModel(model, modelResolver) {
             ...normalizeOpenAICompatibleInit(init),
         });
         if (toolCallingMode === "prompted-json") {
-            return createPromptedJsonToolBindableModel(resolved);
+            return createPromptedJsonToolBindableModel(resolved, [], {
+                settleCompletedToolResults: true,
+                suppressThinking: true,
+            });
         }
         return createProviderToolMessageCompatModel(resolved);
     }

package/dist/runtime/adapter/stream-event-projection.js

@@ -36,13 +36,16 @@ function shouldSuppressVisibleToolCallText(value) {
     if (/^(?:model_request|tool_call|call_tool)\b/iu.test(trimmed)) {
         return true;
     }
+    if (/^(?:name|tool_call_id)\s*=/iu.test(trimmed)) {
+        return true;
+    }
     if (/^(?:we\s+need\s+to|so\s+next\s+step\b)/iu.test(trimmed)) {
         return true;
     }
     if (/\b(?:must|need|needs|should|will)\s+(?:now\s+)?(?:call|use|run|produce)\s+[A-Za-z_][A-Za-z0-9_]*\b/iu.test(trimmed)) {
         return true;
     }
-    if (/^\{\s*"(?:name|arguments|todos|symbol|query|market|count)"\s*:/iu.test(trimmed)) {
+    if (/^\{\s*"(?:name|arguments|args|argv|todos|symbol|query|market|count|stdout|stderr|exitCode)"\s*:/iu.test(trimmed)) {
         return true;
     }
     try {
@@ -55,7 +58,12 @@ function shouldSuppressVisibleToolCallText(value) {
                 || "market" in parsed
                 || "count" in parsed
                 || "arguments" in parsed
-                || "name" in parsed)) {
+                || "args" in parsed
+                || "argv" in parsed
+                || "name" in parsed
+                || "stdout" in parsed
+                || "stderr" in parsed
+                || "exitCode" in parsed)) {
             return true;
         }
     }
@@ -71,6 +79,63 @@ function shouldSuppressVisibleToolCallText(value) {
     }
     return salvageFunctionLikeToolCall(prefixedToolCallMatch[1]) !== null;
 }
+function stripVisibleToolCallResidue(value) {
+    const lines = value.split(/\r?\n/);
+    let changed = false;
+    const kept = lines.filter((line) => {
+        if (shouldSuppressVisibleToolCallText(line)) {
+            changed = true;
+            return false;
+        }
+        return true;
+    });
+    if (changed) {
+        return kept.join("\n").trim();
+    }
+    const trimmedStart = value.trimStart();
+    if (!trimmedStart.startsWith("{")) {
+        return value;
+    }
+    const parsedPrefix = extractLeadingJsonObject(trimmedStart);
+    if (!parsedPrefix || !shouldSuppressVisibleToolCallText(parsedPrefix.json)) {
+        return value;
+    }
+    return parsedPrefix.rest.trimStart();
+}
+function extractLeadingJsonObject(value) {
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = inString;
+            continue;
+        }
+        if (char === "\"") {
+            inString = !inString;
+            continue;
+        }
+        if (inString) {
+            continue;
+        }
+        if (char === "{") {
+            depth += 1;
+            continue;
+        }
+        if (char === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                return { json: value.slice(0, index + 1), rest: value.slice(index + 1) };
+            }
+        }
+    }
+    return null;
+}
 function readSummaryCounts(summary) {
     if (typeof summary !== "object" || summary === null) {
         return null;
@@ -375,7 +440,7 @@ export function projectRuntimeStreamEvent(params) {
     const allowVisibleContent = isRootVisibleEvent && state.openTaskDelegations === 0;
     const allowStreamedVisibleContent = allowVisibleContent && !state.emittedToolResult && !state.emittedToolError;
     if (allowVisibleStreamDeltas && allowStreamedVisibleContent) {
-        const visibleStreamOutput = extractVisibleStreamOutput(event);
+        const visibleStreamOutput = stripVisibleToolCallResidue(extractVisibleStreamOutput(event));
         if (visibleStreamOutput && !shouldSuppressVisibleToolCallText(visibleStreamOutput)) {
             const nextOutput = computeIncrementalOutput(state.emittedOutput, visibleStreamOutput);
             state.emittedOutput = nextOutput.accumulated;
@@ -385,7 +450,7 @@ export function projectRuntimeStreamEvent(params) {
         }
     }
     if (includeStateStreamOutput && allowVisibleContent) {
-        const stateStreamOutput = extractStateStreamOutput(event);
+        const stateStreamOutput = stripVisibleToolCallResidue(extractStateStreamOutput(event));
         if (stateStreamOutput && !shouldSuppressVisibleToolCallText(stateStreamOutput)) {
             const nextOutput = computeIncrementalOutput(state.emittedOutput, stateStreamOutput);
             state.emittedOutput = nextOutput.accumulated;
@@ -456,7 +521,7 @@ export function projectRuntimeStreamEvent(params) {
             state.lastCompletedTaskDelegationFindings = "";
         }
     }
-    const output = allowVisibleContent ? extractTerminalStreamOutput(event) : "";
+    const output = allowVisibleContent ? stripVisibleToolCallResidue(extractTerminalStreamOutput(event)) : "";
     if (!allowVisibleContent) {
         const delegatedTerminalOutput = extractTerminalStreamOutput(event);
         if (delegatedTerminalOutput) {

package/dist/runtime/adapter/tool/tool-hitl.js

@@ -1,5 +1,6 @@
 import { interrupt } from "@langchain/langgraph";
 import path from "node:path";
+import { validateToolGatewayInput } from "../../harness/tool-gateway/index.js";
 const DEDUPED_REMOTE_TOOL_NAMES = new Set(["builtin.fetch_url", "builtin.web_search"]);
 const PATH_LIKE_INPUT_KEYS = new Set(["path", "root", "dir", "directory", "cwd"]);
 const ROOT_SCOPING_INPUT_KEYS = new Set(["root", "dir", "directory", "cwd"]);
@@ -169,8 +170,17 @@ export function wrapToolForHumanInTheLoop(resolvedTool, compiledTool, binding, i
     }
     const target = resolvedTool;
     const runWithApproval = async (input, config, invokeOriginal) => {
+        const gateway = validateToolGatewayInput({
+            toolName: compiledTool.name,
+            schema: target.schema,
+            args: input,
+            requiresApproval: true,
+        });
+        if (!gateway.ok) {
+            return gateway.error;
+        }
         if (decisionMode === "auto-approve") {
-            return invokeOriginal(input, config);
+            return invokeOriginal(gateway.input, config);
         }
         if (decisionMode === "auto-reject" || decisionMode === "deny-and-continue") {
             return "Tool execution denied by runtime policy.";
@@ -179,11 +189,11 @@ export function wrapToolForHumanInTheLoop(resolvedTool, compiledTool, binding, i
             toolName: compiledTool.name,
             toolId: compiledTool.id,
             allowedDecisions: compiledTool.hitl?.allow ?? ["approve", "edit", "reject"],
-            inputPreview: toInputPreview(input),
+            inputPreview: toInputPreview(gateway.input),
             decisionMode,
             ...(toolApprovalReason(compiledTool) ? { approvalReason: toolApprovalReason(compiledTool) } : {}),
         });
-        const approvedInput = resolveApprovedInput(input, resumed);
+        const approvedInput = resolveApprovedInput(gateway.input, resumed);
         if (approvedInput === Symbol.for("agent-harness.hitl.reject")) {
             return "Tool execution rejected by human reviewer.";
         }
@@ -295,13 +305,46 @@ export function wrapToolForExecution(resolvedTool, compiledTool, binding, interr
             get(obj, prop, receiver) {
                 const value = Reflect.get(obj, prop, receiver);
                 if (prop === "invoke" && typeof value === "function") {
-                    return (input, config) => obj.invoke(guardWorkspaceBoundToolInput(input, compiledTool, binding), config);
+                    return (input, config) => {
+                        const gateway = validateToolGatewayInput({
+                            toolName: compiledTool.name,
+                            schema: obj.schema,
+                            args: input,
+                            requiresApproval: resolveToolApprovalDecisionMode(compiledTool, binding) !== "none",
+                        });
+                        if (!gateway.ok) {
+                            return gateway.error;
+                        }
+                        return obj.invoke(guardWorkspaceBoundToolInput(gateway.input, compiledTool, binding), config);
+                    };
                 }
                 if (prop === "call" && typeof value === "function") {
-                    return (input, config) => obj.call(guardWorkspaceBoundToolInput(input, compiledTool, binding), config);
+                    return (input, config) => {
+                        const gateway = validateToolGatewayInput({
+                            toolName: compiledTool.name,
+                            schema: obj.schema,
+                            args: input,
+                            requiresApproval: resolveToolApprovalDecisionMode(compiledTool, binding) !== "none",
+                        });
+                        if (!gateway.ok) {
+                            return gateway.error;
+                        }
+                        return obj.call(guardWorkspaceBoundToolInput(gateway.input, compiledTool, binding), config);
+                    };
                 }
                 if (prop === "func" && typeof value === "function") {
-                    return (input, config) => obj.func(guardWorkspaceBoundToolInput(input, compiledTool, binding), config);
+                    return (input, config) => {
+                        const gateway = validateToolGatewayInput({
+                            toolName: compiledTool.name,
+                            schema: obj.schema,
+                            args: input,
+                            requiresApproval: resolveToolApprovalDecisionMode(compiledTool, binding) !== "none",
+                        });
+                        if (!gateway.ok) {
+                            return gateway.error;
+                        }
+                        return obj.func(guardWorkspaceBoundToolInput(gateway.input, compiledTool, binding), config);
+                    };
                 }
                 return value;
             },