@botbotgo/agent-harness 0.0.400 → 0.0.402

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

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { createAsyncSubAgentMiddleware, createFilesystemMiddleware, createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSummarizationMiddleware, createSubAgentMiddleware, FilesystemBackend, StateBackend, } from "deepagents";
-import { createAgent, humanInTheLoopMiddleware, todoListMiddleware } from "langchain";
+import { AIMessage, createAgent, createMiddleware, humanInTheLoopMiddleware, todoListMiddleware, ToolMessage } from "langchain";
 import { sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./parsing/output-parsing.js";
 import { salvageJsonToolCalls } from "./parsing/output-tool-args.js";
 import { extractMessageText } from "../utils/message-content.js";
@@ -27,7 +27,7 @@ export { computeRemainingTimeoutMs, isRetryableProviderError, resolveBindingTime
 import { getBindingAdapterKind, getBindingBuiltinToolsConfig, getBindingDeepAgentSubagents, getBindingExecutionParams, getBindingExecutionKind, getBindingFilesystemConfig, getBindingMemorySources, getBindingPrimaryModel, getBindingSkills, getBindingSubagents, getBindingToolCount, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
 class DelegatedExecutionNoToolEvidenceError extends Error {
     constructor(agentId) {
-        super(`Delegated agent ${agentId} completed without tool execution evidence.`);
+        super(`Delegated agent ${agentId} lacked non-planning tool evidence.`);
         this.name = "DelegatedExecutionNoToolEvidenceError";
     }
 }
@@ -38,11 +38,245 @@ function hasDelegatedExecutionToolEvidence(result) {
     return executedToolResults.some((toolResult) => (toolResult.isError !== true
         && !isPlanToolName(toolResult.toolName)));
 }
+function buildDelegatedPlanEvidenceBlocker(agentId) {
+    return [
+        "Status: blocked",
+        "Summary:",
+        `- Delegated agent ${agentId} ended before producing the required TODO plan evidence.`,
+        "",
+        "Blockers:",
+        "- The delegated run did not expose a valid planning trace, so the framework cannot treat the task as complete.",
+        "",
+        "Next Actions:",
+        "- Retry with the same request or inspect the delegated agent configuration and model/tool-call behavior.",
+    ].join("\n");
+}
+function buildDelegatedExecutionEvidenceBlocker(agentId) {
+    return [
+        "Status: blocked",
+        "Summary:",
+        `- Delegated agent ${agentId} did not return any non-planning tool evidence after retry.`,
+        "",
+        "Blockers:",
+        "- The TODO board alone is not execution evidence.",
+        "- The framework cannot mark the delegated task complete without a non-planning tool result or an explicit blocker from that tool path.",
+        "",
+        "Next Actions:",
+        "- Retry the request or inspect the delegated agent's model/tool-call behavior.",
+    ].join("\n");
+}
+function normalizePlanToolName(toolName) {
+    return typeof toolName === "string" ? toolName.trim().toLowerCase().replace(/[\s-]+/gu, "_") : "";
+}
 function isPlanToolName(toolName) {
-    return toolName === "write_todos"
-        || toolName === "read_todos"
-        || toolName === "tool_call_write_todos"
-        || toolName === "tool_call_read_todos";
+    const normalized = normalizePlanToolName(toolName);
+    return normalized === "write_todos"
+        || normalized === "read_todos"
+        || normalized === "tool_call_write_todos"
+        || normalized === "tool_call_read_todos";
+}
+function readConfiguredToolName(value) {
+    if (typeof value !== "object" || value === null) {
+        return "";
+    }
+    const typed = value;
+    return typeof typed.name === "string" ? typed.name.trim() : "";
+}
+function createBootstrapTodoPlan(toolNames) {
+    const evidenceToolName = toolNames.find((toolName) => !isPlanToolName(toolName));
+    const contents = evidenceToolName
+        ? [
+            `Run ${evidenceToolName} for the requested evidence`,
+            `Inspect the ${evidenceToolName} result and extract concrete findings`,
+            "Update TODO status from the observed evidence",
+            "Return the final answer grounded in tool output",
+        ]
+        : [
+            "Identify the concrete evidence needed for this request",
+            "Collect and inspect the available evidence",
+            "Update TODO status from the observed evidence",
+            "Return the final answer grounded in evidence",
+        ];
+    return contents.map((content, index) => ({
+        content,
+        status: index === 0 ? "in_progress" : "pending",
+    }));
+}
+function readMessageContentText(message) {
+    if (typeof message !== "object" || message === null) {
+        return "";
+    }
+    const content = message.content;
+    if (typeof content === "string") {
+        return content.trim();
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    return content
+        .map((part) => typeof part === "object" && part !== null && typeof part.text === "string"
+        ? part.text
+        : "")
+        .join("")
+        .trim();
+}
+function parseToolCallArgs(value) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return value;
+    }
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function readMessageToolCalls(message) {
+    if (typeof message !== "object" || message === null) {
+        return [];
+    }
+    const typed = message;
+    const raw = Array.isArray(typed.tool_calls) ? typed.tool_calls
+        : Array.isArray(typed.kwargs?.tool_calls) ? typed.kwargs.tool_calls
+            : Array.isArray(typed.additional_kwargs?.tool_calls) ? typed.additional_kwargs.tool_calls
+                : Array.isArray(typed.kwargs?.additional_kwargs?.tool_calls) ? typed.kwargs.additional_kwargs.tool_calls
+                    : Array.isArray(typed.lc_kwargs?.tool_calls) ? typed.lc_kwargs.tool_calls
+                        : Array.isArray(typed.lc_kwargs?.additional_kwargs?.tool_calls) ? typed.lc_kwargs.additional_kwargs.tool_calls
+                            : [];
+    return raw
+        .map((toolCall) => {
+        if (typeof toolCall !== "object" || toolCall === null) {
+            return null;
+        }
+        const call = toolCall;
+        const name = typeof call.name === "string"
+            ? call.name
+            : typeof call.function?.name === "string"
+                ? call.function.name
+                : undefined;
+        const args = parseToolCallArgs(call.args ?? call.function?.arguments);
+        return {
+            ...(typeof call.id === "string" ? { id: call.id } : {}),
+            ...(name ? { name } : {}),
+            args,
+        };
+    })
+        .filter((toolCall) => toolCall !== null);
+}
+function todoToolCallIsTerminal(toolCall) {
+    const todos = toolCall.args?.todos;
+    if (!Array.isArray(todos) || todos.length === 0) {
+        return false;
+    }
+    return todos.every((todo) => {
+        if (typeof todo !== "object" || todo === null || typeof todo.status !== "string") {
+            return false;
+        }
+        const status = todo.status.trim().toLowerCase();
+        return status !== "pending" && status !== "in_progress";
+    });
+}
+function createTodoPlanGuardMiddleware(options = {}) {
+    return createMiddleware({
+        name: "harnessTodoPlanGuard",
+        wrapToolCall: ((request, handler) => {
+            const toolName = typeof request.toolCall?.name === "string"
+                ? request.toolCall.name
+                : typeof request.tool?.name === "string"
+                    ? request.tool.name
+                    : "";
+            const messages = Array.isArray(request.state?.messages) ? request.state.messages : [];
+            const hasNonPlanToolResult = messages.some((message) => {
+                if (typeof message !== "object" || message === null) {
+                    return false;
+                }
+                const typed = message;
+                const messageType = typeof typed.type === "string"
+                    ? typed.type
+                    : typeof typed._getType === "function"
+                        ? String(typed._getType())
+                        : "";
+                if (messageType !== "tool" && typeof typed.tool_call_id !== "string") {
+                    return false;
+                }
+                const resultToolName = typeof typed.name === "string" ? typed.name : "";
+                return resultToolName.length > 0 && !isPlanToolName(resultToolName);
+            });
+            if (options.requiresPlan === true
+                && !hasNonPlanToolResult
+                && isPlanToolName(toolName)
+                && normalizePlanToolName(toolName).includes("write_todos")
+                && todoToolCallIsTerminal({ args: parseToolCallArgs(request.toolCall?.args) })) {
+                return new ToolMessage({
+                    content: "Error: write_todos cannot mark every todo as terminal before any non-planning evidence tool returns. Keep one todo in_progress and the remaining todos pending until evidence tools return.",
+                    tool_call_id: typeof request.toolCall?.id === "string" ? request.toolCall.id : `write-todos-tool-guard-${Math.random().toString(36).slice(2, 10)}`,
+                    status: "error",
+                });
+            }
+            return handler(request);
+        }),
+        afterModel: (state) => {
+            if (!Array.isArray(state.messages) || state.messages.length === 0) {
+                return;
+            }
+            const hasNonPlanToolResult = state.messages.some((message) => {
+                if (typeof message !== "object" || message === null) {
+                    return false;
+                }
+                const typed = message;
+                const messageType = typeof typed.type === "string"
+                    ? typed.type
+                    : typeof typed._getType === "function"
+                        ? String(typed._getType())
+                        : "";
+                if (messageType !== "tool" && typeof typed.tool_call_id !== "string") {
+                    return false;
+                }
+                const toolName = typeof typed.name === "string" ? typed.name : "";
+                return toolName.length > 0 && !isPlanToolName(toolName);
+            });
+            if (hasNonPlanToolResult) {
+                return;
+            }
+            const lastAiMessage = [...state.messages].reverse().find((message) => readMessageToolCalls(message).length > 0);
+            const lastToolCalls = readMessageToolCalls(lastAiMessage);
+            if (!lastAiMessage && options.requiresPlan === true) {
+                const latestMessage = state.messages.at(-1);
+                const hasVisibleContent = readMessageContentText(latestMessage).length > 0;
+                if (!hasVisibleContent) {
+                    return {
+                        messages: [new AIMessage({
+                                content: "",
+                                tool_calls: [{
+                                        id: `write-todos-bootstrap-${Math.random().toString(36).slice(2, 10)}`,
+                                        name: "write_todos",
+                                        args: { todos: createBootstrapTodoPlan(options.toolNames ?? []) },
+                                        type: "tool_call",
+                                    }],
+                            })],
+                    };
+                }
+            }
+            const writeTodosCalls = lastToolCalls.filter((toolCall) => isPlanToolName(toolCall.name));
+            const prematureCompletedCalls = writeTodosCalls.filter(todoToolCallIsTerminal);
+            if (prematureCompletedCalls.length === 0) {
+                return;
+            }
+            return {
+                messages: prematureCompletedCalls.map((toolCall, index) => new ToolMessage({
+                    content: "Error: write_todos cannot mark every todo as terminal before any non-planning evidence tool returns. Keep one todo in_progress and the remaining todos pending until evidence tools return.",
+                    tool_call_id: toolCall.id ?? `write-todos-plan-guard-${index}`,
+                    status: "error",
+                })),
+            };
+        },
+    });
 }
 function shouldUseConfigurableDeepAgentAssembly(binding) {
     return getBindingExecutionKind(binding) === "deepagent";
@@ -160,25 +394,21 @@ function parseCompactRouterSelection(value, subagentNames) {
 }
 function inferCompactRouterSelectionFromRequest(requestText, subagents) {
     const normalized = requestText.toLowerCase();
+    const requestTokens = extractRouterMatchTokens(normalized);
     const score = (subagent) => {
         const name = subagent.name.toLowerCase();
         const description = (subagent.description ?? "").toLowerCase();
+        const descriptionTokens = extractRouterMatchTokens(`${name} ${description}`);
         let value = 0;
         if (normalized.includes(name))
             value += 4;
-        const keywordGroups = {
-            k8s: ["k8s", "kubernetes", "kubectl", "cluster", "pod", "node", "节点", "集群", "调度"],
-            software: ["code", "repo", "implementation", "debug", "代码", "仓库", "实现", "配置"],
-            ops: ["ci", "cd", "github actions", "disk", "storage", "deploy", "磁盘", "存储", "运维"],
-            qa: ["test", "coverage", "regression", "验证", "测试", "回归"],
-            release: ["release", "publish", "version", "tag", "发版", "发布", "版本"],
-            research: ["research", "web", "latest", "调查资料", "外部", "搜索"],
-            secretary: ["summary", "transcript", "youtube", "brief", "摘要", "讲稿", "转写"],
-        };
-        const keywords = keywordGroups[name] ?? [];
-        for (const keyword of keywords) {
-            if (normalized.includes(keyword))
-                value += description.includes(keyword) || name.includes(keyword) ? 3 : 1;
+        for (const token of requestTokens) {
+            if (token === name) {
+                value += 4;
+            }
+            else if (descriptionTokens.has(token)) {
+                value += token.length > 2 ? 2 : 1;
+            }
         }
         return value;
     };
@@ -191,6 +421,16 @@ function inferCompactRouterSelectionFromRequest(requestText, subagents) {
     }
     return ranked[0].name;
 }
+function extractRouterMatchTokens(value) {
+    const tokens = new Set();
+    for (const match of value.matchAll(/[\p{L}\p{N}_-]+/gu)) {
+        const token = match[0].toLowerCase();
+        if (token.length >= 2) {
+            tokens.add(token);
+        }
+    }
+    return tokens;
+}
 function isDelegationOnlyDeepAgentBinding(binding) {
     return isDeepAgentBinding(binding)
         && getBindingSubagents(binding).length > 0
@@ -454,12 +694,47 @@ export class AgentRuntimeAdapter {
             invokeBuiltinTaskTool: assembly.invokeBuiltinTaskTool,
         });
     }
-    materializeProviderAliasBuiltinTools(builtinTools) {
+    materializeProviderAliasBuiltinTools(builtinTools, modelExposed) {
+        if (modelExposed === false) {
+            return [];
+        }
+        const allowedToolNames = Array.isArray(modelExposed) ? new Set(modelExposed) : undefined;
         const aliasableTools = ["write_todos", "read_todos", "task"]
+            .filter((name) => !allowedToolNames || allowedToolNames.has(name))
             .map((name) => builtinTools.get(name))
             .filter((tool) => tool !== undefined);
         return appendProviderToolCallAliasTools(aliasableTools).slice(aliasableTools.length);
     }
+    shouldExposeBuiltinToolsToModel(binding, primaryTools) {
+        const modelExposed = getBindingBuiltinToolsConfig(binding)?.modelExposed;
+        if (binding.harnessRuntime.executionContract?.requiresPlan === true) {
+            return true;
+        }
+        if (modelExposed === false) {
+            return false;
+        }
+        if (Array.isArray(modelExposed)) {
+            return modelExposed.length > 0;
+        }
+        return (primaryTools.length > 0
+            || getBindingSubagents(binding).length > 0
+            || getBindingDeepAgentSubagents(binding).length > 0);
+    }
+    resolveEffectiveModelExposedBuiltins(binding) {
+        const configured = getBindingBuiltinToolsConfig(binding)?.modelExposed;
+        const requiredNames = new Set();
+        if (binding.harnessRuntime.executionContract?.requiresPlan === true) {
+            requiredNames.add("write_todos");
+            requiredNames.add("read_todos");
+        }
+        if (configured === false) {
+            return requiredNames.size > 0 ? [...requiredNames] : false;
+        }
+        if (Array.isArray(configured)) {
+            return [...new Set([...configured, ...requiredNames])];
+        }
+        return configured;
+    }
     async materializeAutomaticSummarizationMiddleware(binding) {
         const assembly = this.createAssemblyResolvers(binding);
         return materializeAutomaticSummarizationMiddlewareHelper({
@@ -578,12 +853,18 @@ export class AgentRuntimeAdapter {
                 sessionId: options.sessionId ?? options.legacySessionId,
             }),
         });
-        const builtinMiddlewareTools = materializeModelExposedBuiltinMiddlewareTools({
-            builtinTools: builtinExecutableTools,
-            explicitToolNames: primaryTools.map((tool) => tool.name),
-            modelExposed: getBindingBuiltinToolsConfig(binding)?.modelExposed,
-        });
-        const providerAliasBuiltinTools = this.materializeProviderAliasBuiltinTools(builtinExecutableTools);
+        const modelExposedBuiltins = this.resolveEffectiveModelExposedBuiltins(binding);
+        const shouldExposeBuiltinTools = this.shouldExposeBuiltinToolsToModel(binding, primaryTools);
+        const builtinMiddlewareTools = shouldExposeBuiltinTools
+            ? materializeModelExposedBuiltinMiddlewareTools({
+                builtinTools: builtinExecutableTools,
+                explicitToolNames: primaryTools.map((tool) => tool.name),
+                modelExposed: modelExposedBuiltins,
+            })
+            : [];
+        const providerAliasBuiltinTools = shouldExposeBuiltinTools
+            ? this.materializeProviderAliasBuiltinTools(builtinExecutableTools, modelExposedBuiltins)
+            : [];
         const resolvedMiddleware = await this.resolveMiddleware(binding, interruptOn, { sessionId: options.sessionId ?? options.legacySessionId });
         const resolvedCheckpointer = resolveRunnableCheckpointer(this.options, binding);
         const resolvedStore = this.options.storeResolver?.(binding);
@@ -630,12 +911,18 @@ export class AgentRuntimeAdapter {
                 sessionId: options.sessionId ?? options.legacySessionId,
             }),
         });
-        const builtinMiddlewareTools = materializeModelExposedBuiltinMiddlewareTools({
-            builtinTools: builtinExecutableTools,
-            explicitToolNames: primaryTools.map((tool) => tool.name),
-            modelExposed: getBindingBuiltinToolsConfig(binding)?.modelExposed,
-        });
-        const providerAliasBuiltinTools = this.materializeProviderAliasBuiltinTools(builtinExecutableTools);
+        const modelExposedBuiltins = this.resolveEffectiveModelExposedBuiltins(binding);
+        const shouldExposeBuiltinTools = this.shouldExposeBuiltinToolsToModel(binding, primaryTools);
+        const builtinMiddlewareTools = shouldExposeBuiltinTools
+            ? materializeModelExposedBuiltinMiddlewareTools({
+                builtinTools: builtinExecutableTools,
+                explicitToolNames: primaryTools.map((tool) => tool.name),
+                modelExposed: modelExposedBuiltins,
+            })
+            : [];
+        const providerAliasBuiltinTools = shouldExposeBuiltinTools
+            ? this.materializeProviderAliasBuiltinTools(builtinExecutableTools, modelExposedBuiltins)
+            : [];
         const modelTools = [
             ...appendProviderToolCallAliasTools([...resolvedTools, ...builtinMiddlewareTools]),
             ...providerAliasBuiltinTools,
@@ -679,8 +966,14 @@ export class AgentRuntimeAdapter {
         const inlineSubagents = input.resolvedSubagents.filter((subagent) => !("graphId" in subagent));
         const asyncSubagents = input.resolvedSubagents.filter((subagent) => "graphId" in subagent);
         const subagents = inlineSubagents;
+        const requiresPlan = binding.harnessRuntime.executionContract?.requiresPlan === true;
+        const resolvedToolNames = input.resolvedTools.map(readConfiguredToolName).filter((name) => name.length > 0);
         const middleware = [
             ...(builtinTools.todos === false ? [] : [todoListMiddleware()]),
+            ...(builtinTools.todos === false ? [] : [createTodoPlanGuardMiddleware({
+                    requiresPlan,
+                    toolNames: resolvedToolNames,
+                })]),
             ...(input.resolvedSkills.length > 0 ? [createSkillsMiddleware({
                     backend,
                     sources: resolveDeepAgentSkillSourceRootPaths({
@@ -1074,7 +1367,7 @@ export class AgentRuntimeAdapter {
         }
         if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
             && !hasDelegatedPlanEvidence(delegatedResult)) {
-            const output = "runtime_error=Delegated agent ended before producing required plan evidence.";
+            const output = buildDelegatedPlanEvidenceBlocker(selectedBinding.agent.id);
             return {
                 toolOutput: output,
                 delegatedSubagentType: subagentType,
@@ -1087,7 +1380,7 @@ export class AgentRuntimeAdapter {
             };
         }
         if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
-            const output = `runtime_error=Delegated agent ${selectedBinding.agent.id} completed without tool execution evidence.`;
+            const output = buildDelegatedExecutionEvidenceBlocker(selectedBinding.agent.id);
             return {
                 toolOutput: output,
                 delegatedSubagentType: subagentType,
@@ -1397,7 +1690,7 @@ export class AgentRuntimeAdapter {
         }
         if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
             && !hasDelegatedPlanEvidence(delegatedResult)) {
-            const output = "runtime_error=Delegated agent ended before producing required plan evidence.";
+            const output = buildDelegatedPlanEvidenceBlocker(selectedBinding.agent.id);
             delegatedResult = {
                 ...delegatedResult,
                 state: "failed",
@@ -1406,7 +1699,7 @@ export class AgentRuntimeAdapter {
             };
         }
         if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
-            const output = `runtime_error=Delegated agent ${selectedBinding.agent.id} completed without tool execution evidence.`;
+            const output = buildDelegatedExecutionEvidenceBlocker(selectedBinding.agent.id);
             delegatedResult = {
                 ...delegatedResult,
                 state: "failed",

package/dist/runtime/harness/bindings.js

@@ -2,6 +2,7 @@ import { resolveBindingTimeout, resolveProviderRetryPolicy, resolveStreamIdleTim
 import { toolRequiresRuntimeApproval } from "../adapter/tool/tool-hitl.js";
 import { getBindingPrimaryTools } from "../support/compiled-binding.js";
 import { compiledToolHasInputSchema } from "./tool-schema.js";
+import { projectBindingToolGatewayPolicy } from "./tool-gateway/index.js";
 export function getWorkspaceBinding(workspace, agentId) {
     return workspace.bindings.get(agentId);
 }
@@ -36,6 +37,7 @@ export function projectBindingToolExecutionPolicy(binding) {
     const retryableToolCount = projectedTools.filter((tool) => tool.retryable).length;
     return {
         agentId: binding.agent.id,
+        gateway: projectBindingToolGatewayPolicy(binding),
         invokeTimeoutMs: resolveBindingTimeout(binding),
         streamIdleTimeoutMs: resolveStreamIdleTimeout(binding) ?? 60_000,
         providerRetries: resolveProviderRetryPolicy(binding),

package/dist/runtime/harness/tool-gateway/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./policy.js";
+export * from "./validation.js";

package/dist/runtime/harness/tool-gateway/index.js

@@ -0,0 +1,2 @@
+export * from "./policy.js";
+export * from "./validation.js";

package/dist/runtime/harness/tool-gateway/policy.d.ts

@@ -0,0 +1,2 @@
+import type { CompiledAgentBinding, RuntimeToolExecutionPolicy } from "../../../contracts/types.js";
+export declare function projectBindingToolGatewayPolicy(binding: CompiledAgentBinding): RuntimeToolExecutionPolicy["gateway"];

package/dist/runtime/harness/tool-gateway/policy.js

@@ -0,0 +1,45 @@
+import { toolRequiresRuntimeApproval } from "../../adapter/tool/tool-hitl.js";
+import { getBindingPrimaryTools } from "../../support/compiled-binding.js";
+import { compiledToolHasInputSchema } from "../tool-schema.js";
+export function projectBindingToolGatewayPolicy(binding) {
+    const tools = getBindingPrimaryTools(binding).map((tool) => {
+        const hasInputSchema = compiledToolHasInputSchema(tool);
+        const requiresApproval = toolRequiresRuntimeApproval(tool);
+        return {
+            toolId: tool.id,
+            name: tool.name,
+            retryable: tool.retryable === true,
+            hasInputSchema,
+            requiresApproval,
+            gatewayMode: requiresApproval ? "approval-gated" : hasInputSchema ? "schema-first" : "best-effort",
+            modelRole: "propose",
+            runtimeRole: requiresApproval
+                ? "request-approval"
+                : hasInputSchema
+                    ? "validate-and-execute"
+                    : "execute-with-runtime-checks",
+        };
+    });
+    const schemaBoundToolCount = tools.filter((tool) => tool.hasInputSchema).length;
+    const approvalRequiredToolCount = tools.filter((tool) => tool.requiresApproval).length;
+    return {
+        layer: "tool-gateway",
+        toolScope: {
+            source: "agent-binding",
+            exposedToolCount: tools.length,
+            schemaBoundToolCount,
+            approvalRequiredToolCount,
+        },
+        validation: {
+            strategy: "schema-first",
+            runtimeValidationRequired: tools.some((tool) => !tool.hasInputSchema || tool.requiresApproval),
+            strictProviderSchemaPreferred: tools.length > 0,
+        },
+        correction: {
+            invalidArguments: "structured-error-retry",
+            maxModelRetries: 2,
+            highRiskInvalidArguments: "approval-or-deny",
+        },
+        tools,
+    };
+}

package/dist/runtime/harness/tool-gateway/validation.d.ts

@@ -0,0 +1,33 @@
+export type ToolGatewayValidationIssue = {
+    path: string;
+    message: string;
+    expected?: string;
+    received?: string;
+};
+export type ToolGatewayValidationResult = {
+    ok: true;
+    input: unknown;
+} | {
+    ok: false;
+    error: ToolGatewayInvalidArgumentsResult;
+};
+export type ToolGatewayInvalidArgumentsResult = {
+    isError: true;
+    code: "INVALID_ARGUMENTS";
+    toolName: string;
+    message: string;
+    retryable: boolean;
+    requiresApproval: boolean;
+    validationErrors: ToolGatewayValidationIssue[];
+};
+export declare function createInvalidToolArgumentsResult(input: {
+    toolName: string;
+    requiresApproval: boolean;
+    issues: ToolGatewayValidationIssue[];
+}): ToolGatewayInvalidArgumentsResult;
+export declare function validateToolGatewayInput(input: {
+    toolName: string;
+    schema: unknown;
+    args: unknown;
+    requiresApproval?: boolean;
+}): ToolGatewayValidationResult;