@botbotgo/agent-harness 0.0.400 → 0.0.401

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
@@ -679,8 +919,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 +1320,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 +1333,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 +1643,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 +1652,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;

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

@@ -0,0 +1,176 @@
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readJsonSchemaType(schema) {
+    if (!isRecord(schema)) {
+        return [];
+    }
+    const type = schema.type;
+    if (typeof type === "string") {
+        return [type];
+    }
+    return Array.isArray(type) ? type.filter((entry) => typeof entry === "string") : [];
+}
+function typeMatches(value, allowedTypes) {
+    if (allowedTypes.length === 0) {
+        return true;
+    }
+    if (value === null) {
+        return allowedTypes.includes("null");
+    }
+    return allowedTypes.some((type) => {
+        if (type === "integer") {
+            return Number.isInteger(value);
+        }
+        if (type === "array") {
+            return Array.isArray(value);
+        }
+        if (type === "object") {
+            return isRecord(value);
+        }
+        return typeof value === type;
+    });
+}
+function toPath(path) {
+    if (path.length === 0) {
+        return "$";
+    }
+    let rendered = "$";
+    for (const part of path) {
+        rendered = typeof part === "number" ? `${rendered}[${part}]` : `${rendered}.${part}`;
+    }
+    return rendered;
+}
+function zodIssues(error) {
+    const issues = isRecord(error) && Array.isArray(error.issues) ? error.issues : [];
+    return issues
+        .map((issue) => {
+        if (!isRecord(issue)) {
+            return null;
+        }
+        const path = Array.isArray(issue.path) ? issue.path.filter((part) => typeof part === "string" || typeof part === "number") : [];
+        const message = typeof issue.message === "string" ? issue.message : "Invalid value";
+        return {
+            path: toPath(path),
+            message,
+            ...(typeof issue.expected === "string" ? { expected: issue.expected } : {}),
+            ...(typeof issue.received === "string" ? { received: issue.received } : {}),
+        };
+    })
+        .filter((issue) => issue !== null);
+}
+function validateJsonSchemaObject(schema, input) {
+    const issues = [];
+    const rootTypes = readJsonSchemaType(schema);
+    if (!typeMatches(input, rootTypes.length > 0 ? rootTypes : ["object"])) {
+        return [{
+                path: "$",
+                message: "Tool input must match the declared schema root type.",
+                expected: rootTypes.join("|") || "object",
+                received: Array.isArray(input) ? "array" : input === null ? "null" : typeof input,
+            }];
+    }
+    if (!isRecord(input)) {
+        return issues;
+    }
+    const properties = isRecord(schema.properties) ? schema.properties : {};
+    const required = Array.isArray(schema.required)
+        ? schema.required.filter((entry) => typeof entry === "string")
+        : [];
+    for (const key of required) {
+        if (!(key in input)) {
+            issues.push({
+                path: `$.${key}`,
+                message: "Required tool argument is missing.",
+            });
+        }
+    }
+    for (const [key, value] of Object.entries(input)) {
+        const fieldSchema = properties[key];
+        if (!fieldSchema) {
+            if (schema.additionalProperties === false) {
+                issues.push({
+                    path: `$.${key}`,
+                    message: "Unexpected tool argument.",
+                });
+            }
+            continue;
+        }
+        const fieldTypes = readJsonSchemaType(fieldSchema);
+        if (!typeMatches(value, fieldTypes)) {
+            issues.push({
+                path: `$.${key}`,
+                message: "Tool argument has the wrong type.",
+                ...(fieldTypes.length > 0 ? { expected: fieldTypes.join("|") } : {}),
+                received: Array.isArray(value) ? "array" : value === null ? "null" : typeof value,
+            });
+        }
+        if (isRecord(fieldSchema) && Array.isArray(fieldSchema.enum) && !fieldSchema.enum.includes(value)) {
+            issues.push({
+                path: `$.${key}`,
+                message: "Tool argument must be one of the declared enum values.",
+            });
+        }
+    }
+    return issues;
+}
+export function createInvalidToolArgumentsResult(input) {
+    return {
+        isError: true,
+        code: "INVALID_ARGUMENTS",
+        toolName: input.toolName,
+        message: `Tool ${input.toolName} received invalid arguments. Correct the arguments to match the declared schema before retrying.`,
+        retryable: !input.requiresApproval,
+        requiresApproval: input.requiresApproval,
+        validationErrors: input.issues.length > 0
+            ? input.issues
+            : [{ path: "$", message: "Tool input failed schema validation." }],
+    };
+}
+export function validateToolGatewayInput(input) {
+    const schema = input.schema;
+    const requiresApproval = input.requiresApproval === true;
+    if (schema && typeof schema.safeParse === "function") {
+        const parsed = schema.safeParse(input.args);
+        if (parsed.success) {
+            return { ok: true, input: parsed.data };
+        }
+        return {
+            ok: false,
+            error: createInvalidToolArgumentsResult({
+                toolName: input.toolName,
+                requiresApproval,
+                issues: zodIssues(parsed.error),
+            }),
+        };
+    }
+    if (schema && typeof schema.parse === "function") {
+        try {
+            return { ok: true, input: schema.parse(input.args) };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                error: createInvalidToolArgumentsResult({
+                    toolName: input.toolName,
+                    requiresApproval,
+                    issues: zodIssues(error),
+                }),
+            };
+        }
+    }
+    if (isRecord(input.schema) && (input.schema.type === "object" || isRecord(input.schema.properties))) {
+        const issues = validateJsonSchemaObject(input.schema, input.args);
+        if (issues.length > 0) {
+            return {
+                ok: false,
+                error: createInvalidToolArgumentsResult({
+                    toolName: input.toolName,
+                    requiresApproval,
+                    issues,
+                }),
+            };
+        }
+    }
+    return { ok: true, input: input.args };
+}