fix: improve tool input validation logic to return specific error message (#578)

* fix: improve tool input validation logic to return specific error message

* fix: refactor

Author: jguoamz

runtimes/runtimes/agent.test.ts

@@ -34,6 +34,32 @@ describe('Agent Tools', () => {
     } as const
     const SOME_TOOL_HANDLER = async (_: { test: string }) => true
 
+    const TOOL_SPEC_WITH_ARRAY_TYPE = {
+        name: 'fsReplace',
+        description: 'test',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                diffs: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            oldStr: {
+                                type: 'string',
+                            },
+                            newStr: {
+                                type: 'string',
+                            },
+                        },
+                    },
+                },
+            },
+            required: ['diffs'],
+        },
+    } as const
+    const DIFFS_TOOL_HANDLER = async (_: { diffs: [] }) => true
+
     beforeEach(() => {
         AGENT = newAgent()
     })
@@ -59,11 +85,30 @@ describe('Agent Tools', () => {
         }, Error)
     })
 
-    it('should throw if the tool input does not validate', async () => {
+    it('should throw specific message if the tool input does not validate', async () => {
+        AGENT.addTool(TOOL_SPEC_WITH_ARRAY_TYPE, DIFFS_TOOL_HANDLER)
+        await assert.rejects(
+            async () => {
+                await AGENT.runTool(TOOL_SPEC_WITH_ARRAY_TYPE.name, {
+                    diffs: '[{"oldStr": "toReplace"}, {"newStr": "newContet"}]',
+                })
+            },
+            (error: Error) => {
+                assert.ok(error.message === 'fsReplace tool input validation failed: /diffs: must be array')
+                return true
+            }
+        )
+
         AGENT.addTool(SOME_TOOL_SPEC, SOME_TOOL_HANDLER)
-        assert.rejects(async () => {
-            await AGENT.runTool(SOME_TOOL_SPEC.name, { test: 1 })
-        }, Error)
+        await assert.rejects(
+            async () => {
+                await AGENT.runTool(SOME_TOOL_SPEC.name, { test: 1 })
+            },
+            (error: Error) => {
+                assert.ok(error.message === 'test tool input validation failed: /test: must be string')
+                return true
+            }
+        )
     })
 
     it('should execute the named tool if multiple are available', async () => {

runtimes/runtimes/agent.ts

@@ -1,4 +1,4 @@
-import Ajv from 'ajv'
+import Ajv, { ErrorObject, ValidateFunction } from 'ajv'
 import {
     Agent,
     BedrockTools,
@@ -14,7 +14,7 @@ type Tool<T, R> = {
     name: string
     description: string
     inputSchema: ObjectSchema
-    validate: (input: T, token?: CancellationToken) => boolean
+    validate: (input: T, token?: CancellationToken) => boolean | ValidateFunction<unknown>['errors']
     invoke: (input: T, token?: CancellationToken, updates?: WritableStream) => Promise<R>
 }
 
@@ -30,7 +30,8 @@ export const newAgent = (): Agent => {
             const validator = ajv.compile(spec.inputSchema)
             const tool = {
                 validate: (input: InferSchema<S['inputSchema']>) => {
-                    return validator(input)
+                    const isValid = validator(input)
+                    return validator.errors ?? isValid
                 },
                 invoke: handler,
                 name: spec.name,
@@ -47,8 +48,14 @@ export const newAgent = (): Agent => {
                 throw new Error(`Tool ${toolName} not found`)
             }
 
-            if (!tool.validate(input, token)) {
-                throw new Error(`Input for tool ${toolName} is invalid`)
+            const validateResult = tool.validate(input, token)
+            if (validateResult !== true) {
+                const errorDetails =
+                    ((validateResult as ValidateFunction['errors']) || [])
+                        .map((err: ErrorObject) => `${err.instancePath || 'root'}: ${err.message}`)
+                        .join('\n') || `\nReceived: ${input}`
+
+                throw new Error(`${toolName} tool input validation failed: ${errorDetails}`)
             }
 
             return tool.invoke(input, token, updates)