@botbotgo/agent-harness 0.0.400 → 0.0.402

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 };
+}

package/dist/runtime/parsing/output-recovery.js

@@ -118,10 +118,7 @@ export function resolveMissingPlanRecoveryInstruction(params) {
     if (params.requiresPlan !== true || hasPlanEvidence) {
         return null;
     }
-    if (params.hasToolResultEvidence === true) {
-        return WRITE_TODOS_REQUIRED_PLAN_INSTRUCTION;
-    }
-    return null;
+    return WRITE_TODOS_REQUIRED_PLAN_INSTRUCTION;
 }
 export function resolveExecutionWithoutToolEvidenceInstruction(request, result) {
     const assistantText = readTextContent(result).trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.400",
+  "version": "0.0.402",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",
@@ -47,21 +47,21 @@
     }
   },
   "dependencies": {
-    "@langchain/anthropic": "^1.3.27",
-    "@langchain/core": "^1.1.41",
-    "@langchain/google": "^0.1.10",
+    "@langchain/anthropic": "^1.3.28",
+    "@langchain/core": "^1.1.43",
+    "@langchain/google": "^0.1.11",
     "@langchain/langgraph": "^1.2.9",
-    "@langchain/ollama": "^1.2.6",
-    "@langchain/openai": "^1.4.4",
-    "@libsql/client": "^0.17.0",
-    "@llamaindex/ollama": "^0.1.23",
-    "@modelcontextprotocol/sdk": "^1.12.0",
+    "@langchain/ollama": "^1.2.7",
+    "@langchain/openai": "^1.4.5",
+    "@libsql/client": "^0.17.3",
+    "@llamaindex/ollama": "^0.1.24",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "@qdrant/js-client-rest": "1.17.0",
     "deepagents": "^1.9.0",
-    "langchain": "^1.3.4",
+    "langchain": "^1.3.5",
     "llamaindex": "^0.12.1",
     "mustache": "^4.2.0",
-    "yaml": "^2.8.1",
+    "yaml": "^2.8.3",
     "zod": "^3.25.76"
   },
   "scripts": {
@@ -88,10 +88,10 @@
   },
   "devDependencies": {
     "@langchain/community": "^1.1.27",
-    "@types/node": "^25.5.2",
+    "@types/node": "^25.6.0",
     "typescript": "^6.0.2",
-    "vite": "^7.3.2",
-    "vitest": "^4.1.4"
+    "vite": "^8.0.10",
+    "vitest": "^4.1.5"
   },
   "overrides": {
     "axios": "^1.15.0",
@@ -102,7 +102,7 @@
     "uuid": "^14.0.0",
     "undici": "^6.24.0",
     "@qdrant/js-client-rest": "1.17.0",
-    "vite": "^7.3.2",
+    "vite": "^8.0.10",
     "openai": "6.33.0",
     "protobufjs": "^7.5.5"
   }