@decocms/bindings 1.4.3 → 1.4.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/bindings",
-  "version": "1.4.3",
+  "version": "1.4.5",
   "type": "module",
   "scripts": {
     "check": "tsc --noEmit",

package/src/core/client/proxy.ts

@@ -20,25 +20,6 @@ type Tool = {
 
 const toolsMap = new Map<string, Promise<Array<Tool>>>();
 
-// Memoize JSON-schema → Zod conversion by schema content. Zod v4 schemas carry
-// their methods per-instance, so a freshly-converted schema is ~18 Function/
-// AsyncFunction nodes; `mapTool` runs on EVERY `asCallableTools()`/`asTool()`
-// call, so without this an MCP server's whole tool set was re-minted into a new
-// Zod graph per call and retained by whatever held the result — a dominant
-// heap-leak vector server-side (runtime/workflows/sandbox hit this path). The
-// conversion is pure and Zod schemas are immutable after build, so sharing one
-// instance per distinct schema is safe. Distinct schema contents are bounded by
-// the tool catalogue, so no eviction is needed (mirrors sharedJsonSchemaValidator).
-const zodSchemaCache = new Map<string, unknown>();
-const cachedConvertJsonSchemaToZod = (schema: any) => {
-  const key = JSON.stringify(schema);
-  const hit = zodSchemaCache.get(key);
-  if (hit !== undefined) return hit;
-  const zod = convertJsonSchemaToZod(schema);
-  zodSchemaCache.set(key, zod);
-  return zod;
-};
-
 const mapTool = (
   tool: Tool,
   callToolFn: (input: any, toolName?: string) => Promise<any>,
@@ -47,10 +28,10 @@ const mapTool = (
     ...tool,
     id: tool.name,
     inputSchema: tool.inputSchema
-      ? cachedConvertJsonSchemaToZod(tool.inputSchema)
+      ? convertJsonSchemaToZod(tool.inputSchema)
       : undefined,
     outputSchema: tool.outputSchema
-      ? cachedConvertJsonSchemaToZod(tool.outputSchema)
+      ? convertJsonSchemaToZod(tool.outputSchema)
       : undefined,
     execute: (input: any) => {
       return callToolFn(input.context, tool.name);

package/test/index.test.ts

@@ -1,943 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { z } from "zod";
-import {
-  createBindingChecker,
-  type Binder,
-  type ToolBinder,
-} from "../src/index";
-
-// Skipping tests for now
-describe.skip("@decocms/bindings", () => {
-  describe("ToolBinder type", () => {
-    it("should define a valid tool binder", () => {
-      const toolBinder: ToolBinder = {
-        name: "TEST_TOOL",
-        inputSchema: z.object({ id: z.string() }),
-        outputSchema: z.object({ success: z.boolean() }),
-      };
-
-      expect(toolBinder.name).toBe("TEST_TOOL");
-      expect(toolBinder.inputSchema).toBeDefined();
-      expect(toolBinder.outputSchema).toBeDefined();
-    });
-
-    it("should support optional tools", () => {
-      const optionalTool: ToolBinder = {
-        name: "OPTIONAL_TOOL",
-        inputSchema: z.object({}),
-        opt: true,
-      };
-
-      expect(optionalTool.opt).toBe(true);
-    });
-
-    it("should support RegExp names", () => {
-      const regexTool: ToolBinder<RegExp> = {
-        name: /^TEST_\w+$/ as RegExp,
-        inputSchema: z.object({}),
-      };
-
-      expect(regexTool.name).toBeInstanceOf(RegExp);
-    });
-  });
-
-  describe("Binder type", () => {
-    it("should define a valid binding with multiple tools", () => {
-      const binding = [
-        {
-          name: "TOOL_ONE" as const,
-          inputSchema: z.object({ data: z.string() }),
-          outputSchema: z.object({ result: z.boolean() }),
-        },
-        {
-          name: "TOOL_TWO" as const,
-          inputSchema: z.object({ id: z.number() }),
-          outputSchema: z.object({ value: z.string() }),
-        },
-      ] as const satisfies Binder;
-
-      expect(binding).toHaveLength(2);
-      expect(binding[0].name).toBe("TOOL_ONE");
-      expect(binding[1].name).toBe("TOOL_TWO");
-    });
-  });
-
-  describe("createBindingChecker", () => {
-    const SAMPLE_BINDING = [
-      {
-        name: "REQUIRED_TOOL" as const,
-        inputSchema: z.object({ id: z.string() }),
-        outputSchema: z.object({ success: z.boolean() }),
-      },
-      {
-        name: "ANOTHER_REQUIRED" as const,
-        inputSchema: z.object({ value: z.number() }),
-        outputSchema: z.object({ result: z.string() }),
-      },
-      {
-        name: "OPTIONAL_TOOL" as const,
-        inputSchema: z.object({}),
-        opt: true,
-      },
-    ] as const satisfies Binder;
-
-    it("should create a binding checker", () => {
-      const checker = createBindingChecker(SAMPLE_BINDING);
-
-      expect(checker).toBeDefined();
-      expect(checker.isImplementedBy).toBeInstanceOf(Function);
-    });
-
-    it("should return true when all required tools are present with compatible schemas", () => {
-      const checker = createBindingChecker(SAMPLE_BINDING);
-
-      const tools = [
-        {
-          name: "REQUIRED_TOOL",
-          inputSchema: z.object({ id: z.string() }),
-          outputSchema: z.object({ success: z.boolean() }),
-        },
-        {
-          name: "ANOTHER_REQUIRED",
-          inputSchema: z.object({ value: z.number() }),
-          outputSchema: z.object({ result: z.string() }),
-        },
-        {
-          name: "OPTIONAL_TOOL",
-          inputSchema: z.object({}),
-        },
-      ];
-
-      expect(checker.isImplementedBy(tools)).toBe(true);
-    });
-
-    it("should return true when optional tools are missing", () => {
-      const checker = createBindingChecker(SAMPLE_BINDING);
-
-      const tools = [
-        {
-          name: "REQUIRED_TOOL",
-          inputSchema: z.object({ id: z.string() }),
-          outputSchema: z.object({ success: z.boolean() }),
-        },
-        {
-          name: "ANOTHER_REQUIRED",
-          inputSchema: z.object({ value: z.number() }),
-          outputSchema: z.object({ result: z.string() }),
-        },
-        // OPTIONAL_TOOL is missing, but that's OK
-      ];
-
-      expect(checker.isImplementedBy(tools)).toBe(true);
-    });
-
-    it("should return false when required tools are missing", () => {
-      const checker = createBindingChecker(SAMPLE_BINDING);
-
-      const tools = [
-        {
-          name: "REQUIRED_TOOL",
-          inputSchema: z.object({ id: z.string() }),
-          outputSchema: z.object({ success: z.boolean() }),
-        },
-        // ANOTHER_REQUIRED is missing
-      ];
-
-      expect(checker.isImplementedBy(tools)).toBe(false);
-    });
-
-    it("should work with extra tools present", () => {
-      const checker = createBindingChecker(SAMPLE_BINDING);
-
-      const tools = [
-        {
-          name: "REQUIRED_TOOL",
-          inputSchema: z.object({ id: z.string() }),
-          outputSchema: z.object({ success: z.boolean() }),
-        },
-        {
-          name: "ANOTHER_REQUIRED",
-          inputSchema: z.object({ value: z.number() }),
-          outputSchema: z.object({ result: z.string() }),
-        },
-        {
-          name: "EXTRA_TOOL_1",
-          inputSchema: z.object({}),
-        },
-        {
-          name: "EXTRA_TOOL_2",
-          inputSchema: z.object({}),
-        },
-      ];
-
-      expect(checker.isImplementedBy(tools)).toBe(true);
-    });
-
-    it("should return false when tool input schema is incompatible (wrong type)", () => {
-      const checker = createBindingChecker(SAMPLE_BINDING);
-
-      const tools = [
-        {
-          name: "REQUIRED_TOOL",
-          // Tool expects number but binder requires string
-          inputSchema: z.object({ id: z.number() }),
-          outputSchema: z.object({ success: z.boolean() }),
-        },
-        {
-          name: "ANOTHER_REQUIRED",
-          inputSchema: z.object({ value: z.number() }),
-          outputSchema: z.object({ result: z.string() }),
-        },
-      ];
-
-      expect(checker.isImplementedBy(tools)).toBe(false);
-    });
-
-    it("should return false when tool input schema is missing required fields", () => {
-      const checker = createBindingChecker(SAMPLE_BINDING);
-
-      const tools = [
-        {
-          name: "REQUIRED_TOOL",
-          // Tool missing required 'id' field
-          inputSchema: z.object({}),
-          outputSchema: z.object({ success: z.boolean() }),
-        },
-        {
-          name: "ANOTHER_REQUIRED",
-          inputSchema: z.object({ value: z.number() }),
-          outputSchema: z.object({ result: z.string() }),
-        },
-      ];
-
-      // json-schema-diff should detect missing required properties
-      const result = checker.isImplementedBy(tools);
-      // Note: json-schema-diff may or may not detect missing required fields
-      // depending on how it handles the schema conversion
-      expect(typeof result).toBe("boolean");
-    });
-
-    it("should return false when tool input schema has required field as optional", () => {
-      const checker = createBindingChecker(SAMPLE_BINDING);
-
-      const tools = [
-        {
-          name: "REQUIRED_TOOL",
-          // Binder requires 'id' but tool makes it optional
-          inputSchema: z.object({ id: z.string().optional() }),
-          outputSchema: z.object({ success: z.boolean() }),
-        },
-        {
-          name: "ANOTHER_REQUIRED",
-          inputSchema: z.object({ value: z.number() }),
-          outputSchema: z.object({ result: z.string() }),
-        },
-      ];
-
-      // json-schema-diff should detect that required field became optional
-      const result = checker.isImplementedBy(tools);
-      // Note: json-schema-diff may not always detect required->optional changes
-      expect(typeof result).toBe("boolean");
-    });
-
-    it("should return false when tool output schema is incompatible (wrong type)", () => {
-      const checker = createBindingChecker(SAMPLE_BINDING);
-
-      const tools = [
-        {
-          name: "REQUIRED_TOOL",
-          inputSchema: z.object({ id: z.string() }),
-          // Tool outputs string but binder expects boolean
-          outputSchema: z.object({ success: z.string() }),
-        },
-        {
-          name: "ANOTHER_REQUIRED",
-          inputSchema: z.object({ value: z.number() }),
-          outputSchema: z.object({ result: z.string() }),
-        },
-      ];
-
-      expect(checker.isImplementedBy(tools)).toBe(false);
-    });
-
-    it("should return false when tool output schema is missing required fields", () => {
-      const checker = createBindingChecker(SAMPLE_BINDING);
-
-      const tools = [
-        {
-          name: "REQUIRED_TOOL",
-          inputSchema: z.object({ id: z.string() }),
-          // Tool missing required 'success' field
-          outputSchema: z.object({}),
-        },
-        {
-          name: "ANOTHER_REQUIRED",
-          inputSchema: z.object({ value: z.number() }),
-          outputSchema: z.object({ result: z.string() }),
-        },
-      ];
-
-      // json-schema-diff should detect missing required output properties
-      const result = checker.isImplementedBy(tools);
-      // Note: json-schema-diff may or may not detect missing required fields
-      expect(typeof result).toBe("boolean");
-    });
-
-    it("should return false when tool has no input schema but binder requires one", () => {
-      const checker = createBindingChecker(SAMPLE_BINDING);
-
-      const tools = [
-        {
-          name: "REQUIRED_TOOL",
-          // Tool has no input schema
-          outputSchema: z.object({ success: z.boolean() }),
-        },
-        {
-          name: "ANOTHER_REQUIRED",
-          inputSchema: z.object({ value: z.number() }),
-          outputSchema: z.object({ result: z.string() }),
-        },
-      ];
-
-      expect(checker.isImplementedBy(tools)).toBe(false);
-    });
-
-    it("should return false when tool has no output schema but binder requires one", () => {
-      const checker = createBindingChecker(SAMPLE_BINDING);
-
-      const tools = [
-        {
-          name: "REQUIRED_TOOL",
-          inputSchema: z.object({ id: z.string() }),
-          // Tool has no output schema
-        },
-        {
-          name: "ANOTHER_REQUIRED",
-          inputSchema: z.object({ value: z.number() }),
-          outputSchema: z.object({ result: z.string() }),
-        },
-      ];
-
-      expect(checker.isImplementedBy(tools)).toBe(false);
-    });
-
-    it("should allow tool to accept additional input fields", () => {
-      const checker = createBindingChecker(SAMPLE_BINDING);
-
-      const tools = [
-        {
-          name: "REQUIRED_TOOL",
-          // Tool accepts id (required) + optional extra field
-          inputSchema: z.object({
-            id: z.string(),
-            extra: z.string().optional(),
-          }),
-          outputSchema: z.object({ success: z.boolean() }),
-        },
-        {
-          name: "ANOTHER_REQUIRED",
-          inputSchema: z.object({ value: z.number() }),
-          outputSchema: z.object({ result: z.string() }),
-        },
-      ];
-
-      // Tools should be able to accept additional fields (more permissive)
-      // Note: json-schema-diff might be strict about additionalProperties
-      const result = checker.isImplementedBy(tools);
-      // The result depends on json-schema-diff's handling of additionalProperties
-      expect(typeof result).toBe("boolean");
-    });
-
-    it("should allow tool to provide additional output fields", () => {
-      const checker = createBindingChecker(SAMPLE_BINDING);
-
-      const tools = [
-        {
-          name: "REQUIRED_TOOL",
-          inputSchema: z.object({ id: z.string() }),
-          // Tool provides success (required) + extra field
-          outputSchema: z.object({
-            success: z.boolean(),
-            timestamp: z.number(),
-          }),
-        },
-        {
-          name: "ANOTHER_REQUIRED",
-          inputSchema: z.object({ value: z.number() }),
-          outputSchema: z.object({ result: z.string() }),
-        },
-      ];
-
-      // Tools should be able to provide additional output fields (more permissive)
-      // Note: json-schema-diff might be strict about additionalProperties
-      const result = checker.isImplementedBy(tools);
-      // The result depends on json-schema-diff's handling of additionalProperties
-      expect(typeof result).toBe("boolean");
-    });
-  });
-
-  describe("Complex schema validation", () => {
-    const COMPLEX_BINDING = [
-      {
-        name: "COMPLEX_TOOL" as const,
-        inputSchema: z.object({
-          user: z.object({
-            id: z.string(),
-            email: z.string().email(),
-            profile: z.object({
-              name: z.string(),
-              age: z.number().optional(),
-            }),
-          }),
-          tags: z.array(z.string()),
-          metadata: z.record(z.string(), z.any()),
-        }),
-        outputSchema: z.object({
-          result: z.object({
-            id: z.string(),
-            status: z.enum(["success", "error"]),
-            data: z.array(z.object({ value: z.number() })),
-          }),
-          timestamp: z.string().datetime(),
-        }),
-      },
-    ] as const satisfies Binder;
-
-    it("should pass when tool accepts all nested required fields", () => {
-      const checker = createBindingChecker(COMPLEX_BINDING);
-
-      const tools = [
-        {
-          name: "COMPLEX_TOOL",
-          inputSchema: z.object({
-            user: z.object({
-              id: z.string(),
-              email: z.string().email(),
-              profile: z.object({
-                name: z.string(),
-                age: z.number().optional(),
-              }),
-            }),
-            tags: z.array(z.string()),
-            metadata: z.record(z.string(), z.any()),
-          }),
-          outputSchema: z.object({
-            result: z.object({
-              id: z.string(),
-              status: z.enum(["success", "error"]),
-              data: z.array(z.object({ value: z.number() })),
-            }),
-            timestamp: z.string().datetime(),
-          }),
-        },
-      ];
-
-      expect(checker.isImplementedBy(tools)).toBe(true);
-    });
-
-    it("should pass when tool accepts additional nested fields", () => {
-      const checker = createBindingChecker(COMPLEX_BINDING);
-
-      const tools = [
-        {
-          name: "COMPLEX_TOOL",
-          inputSchema: z.object({
-            user: z.object({
-              id: z.string(),
-              email: z.string().email(),
-              profile: z.object({
-                name: z.string(),
-                age: z.number().optional(),
-                avatar: z.string().optional(), // Extra field
-              }),
-              role: z.string().optional(), // Extra field
-            }),
-            tags: z.array(z.string()),
-            metadata: z.record(z.string(), z.any()),
-            extra: z.string().optional(), // Extra top-level field
-          }),
-          outputSchema: z.object({
-            result: z.object({
-              id: z.string(),
-              status: z.enum(["success", "error"]),
-              data: z.array(z.object({ value: z.number() })),
-            }),
-            timestamp: z.string().datetime(),
-            extra: z.number().optional(), // Extra output field
-          }),
-        },
-      ];
-
-      // Tools should be able to accept/provide additional fields
-      // Note: json-schema-diff might be strict about additionalProperties
-      const result = checker.isImplementedBy(tools);
-      // The result depends on json-schema-diff's handling of additionalProperties
-      expect(typeof result).toBe("boolean");
-    });
-
-    it("should fail when tool is missing nested required fields", () => {
-      const checker = createBindingChecker(COMPLEX_BINDING);
-
-      const tools = [
-        {
-          name: "COMPLEX_TOOL",
-          inputSchema: z.object({
-            user: z.object({
-              id: z.string(),
-              // Missing required 'email' field
-              profile: z.object({
-                name: z.string(),
-                age: z.number().optional(),
-              }),
-            }),
-            tags: z.array(z.string()),
-            metadata: z.record(z.string(), z.any()),
-          }),
-          outputSchema: z.object({
-            result: z.object({
-              id: z.string(),
-              status: z.enum(["success", "error"]),
-              data: z.array(z.object({ value: z.number() })),
-            }),
-            timestamp: z.string().datetime(),
-          }),
-        },
-      ];
-
-      expect(checker.isImplementedBy(tools)).toBe(false);
-    });
-
-    it("should fail when tool has wrong nested field type", () => {
-      const checker = createBindingChecker(COMPLEX_BINDING);
-
-      const tools = [
-        {
-          name: "COMPLEX_TOOL",
-          inputSchema: z.object({
-            user: z.object({
-              id: z.string(),
-              email: z.string().email(),
-              profile: z.object({
-                name: z.number(), // Wrong type: should be string
-                age: z.number().optional(),
-              }),
-            }),
-            tags: z.array(z.string()),
-            metadata: z.record(z.string(), z.any()),
-          }),
-          outputSchema: z.object({
-            result: z.object({
-              id: z.string(),
-              status: z.enum(["success", "error"]),
-              data: z.array(z.object({ value: z.number() })),
-            }),
-            timestamp: z.string().datetime(),
-          }),
-        },
-      ];
-
-      expect(checker.isImplementedBy(tools)).toBe(false);
-    });
-
-    it("should fail when tool output is missing nested required fields", () => {
-      const checker = createBindingChecker(COMPLEX_BINDING);
-
-      const tools = [
-        {
-          name: "COMPLEX_TOOL",
-          inputSchema: z.object({
-            user: z.object({
-              id: z.string(),
-              email: z.string().email(),
-              profile: z.object({
-                name: z.string(),
-                age: z.number().optional(),
-              }),
-            }),
-            tags: z.array(z.string()),
-            metadata: z.record(z.string(), z.any()),
-          }),
-          outputSchema: z.object({
-            result: z.object({
-              id: z.string(),
-              status: z.enum(["success", "error"]),
-              // Missing required 'data' field
-            }),
-            timestamp: z.string().datetime(),
-          }),
-        },
-      ];
-
-      expect(checker.isImplementedBy(tools)).toBe(false);
-    });
-
-    it("should fail when tool output has wrong nested field type", () => {
-      const checker = createBindingChecker(COMPLEX_BINDING);
-
-      const tools = [
-        {
-          name: "COMPLEX_TOOL",
-          inputSchema: z.object({
-            user: z.object({
-              id: z.string(),
-              email: z.string().email(),
-              profile: z.object({
-                name: z.string(),
-                age: z.number().optional(),
-              }),
-            }),
-            tags: z.array(z.string()),
-            metadata: z.record(z.string(), z.any()),
-          }),
-          outputSchema: z.object({
-            result: z.object({
-              id: z.string(),
-              status: z.string(), // Wrong type: should be enum
-              data: z.array(z.object({ value: z.number() })),
-            }),
-            timestamp: z.string().datetime(),
-          }),
-        },
-      ];
-
-      // json-schema-diff should detect type mismatch (enum vs string)
-      const result = checker.isImplementedBy(tools);
-      // Note: json-schema-diff may or may not detect enum vs string differences
-      expect(typeof result).toBe("boolean");
-    });
-
-    it("should fail when tool has wrong array element type", () => {
-      const checker = createBindingChecker(COMPLEX_BINDING);
-
-      const tools = [
-        {
-          name: "COMPLEX_TOOL",
-          inputSchema: z.object({
-            user: z.object({
-              id: z.string(),
-              email: z.string().email(),
-              profile: z.object({
-                name: z.string(),
-                age: z.number().optional(),
-              }),
-            }),
-            tags: z.array(z.number()), // Wrong type: should be string[]
-            metadata: z.record(z.string(), z.any()),
-          }),
-          outputSchema: z.object({
-            result: z.object({
-              id: z.string(),
-              status: z.enum(["success", "error"]),
-              data: z.array(z.object({ value: z.number() })),
-            }),
-            timestamp: z.string().datetime(),
-          }),
-        },
-      ];
-
-      expect(checker.isImplementedBy(tools)).toBe(false);
-    });
-  });
-
-  describe("Edge cases for schema validation", () => {
-    it("should pass when binder has no input schema", () => {
-      const BINDING_NO_INPUT = [
-        {
-          name: "NO_INPUT_TOOL" as const,
-          inputSchema: z.any(),
-          outputSchema: z.object({ result: z.string() }),
-        },
-      ] as const satisfies Binder;
-
-      const checker = createBindingChecker(BINDING_NO_INPUT);
-
-      const tools = [
-        {
-          name: "NO_INPUT_TOOL",
-          inputSchema: z.object({ anything: z.any() }),
-          outputSchema: z.object({ result: z.string() }),
-        },
-      ];
-
-      // When binder has z.any(), tool should be able to accept anything
-      // Note: json-schema-diff might handle z.any() differently
-      const result = checker.isImplementedBy(tools);
-      expect(typeof result).toBe("boolean");
-    });
-
-    it("should pass when binder has no output schema", () => {
-      const BINDING_NO_OUTPUT = [
-        {
-          name: "NO_OUTPUT_TOOL" as const,
-          inputSchema: z.object({ id: z.string() }),
-        },
-      ] as const satisfies Binder;
-
-      const checker = createBindingChecker(BINDING_NO_OUTPUT);
-
-      const tools = [
-        {
-          name: "NO_OUTPUT_TOOL",
-          inputSchema: z.object({ id: z.string() }),
-          outputSchema: z.object({ anything: z.any() }),
-        },
-      ];
-
-      expect(checker.isImplementedBy(tools)).toBe(true);
-    });
-
-    it("should pass when tool input schema accepts union types that include binder type", () => {
-      const BINDING = [
-        {
-          name: "UNION_TOOL" as const,
-          inputSchema: z.object({ value: z.string() }),
-          outputSchema: z.object({ result: z.boolean() }),
-        },
-      ] as const satisfies Binder;
-
-      const checker = createBindingChecker(BINDING);
-
-      // Tool accepts string | number, which includes string (binder requirement)
-      const tools = [
-        {
-          name: "UNION_TOOL",
-          inputSchema: z.object({ value: z.union([z.string(), z.number()]) }),
-          outputSchema: z.object({ result: z.boolean() }),
-        },
-      ];
-
-      // Note: This might fail with json-schema-diff if it's strict about unions
-      // But the intent is that tool should accept what binder requires
-      const result = checker.isImplementedBy(tools);
-      // The result depends on how json-schema-diff handles unions
-      expect(typeof result).toBe("boolean");
-    });
-
-    it("should handle optional vs required fields correctly", () => {
-      const BINDING = [
-        {
-          name: "OPTIONAL_FIELD_TOOL" as const,
-          inputSchema: z.object({
-            required: z.string(),
-            optional: z.string().optional(),
-          }),
-          outputSchema: z.object({
-            result: z.string(),
-            extra: z.number().optional(),
-          }),
-        },
-      ] as const satisfies Binder;
-
-      const checker = createBindingChecker(BINDING);
-
-      // Tool that omits optional field - should pass
-      const tools1 = [
-        {
-          name: "OPTIONAL_FIELD_TOOL",
-          inputSchema: z.object({
-            required: z.string(),
-            // Missing optional field is OK
-          }),
-          outputSchema: z.object({
-            result: z.string(),
-            extra: z.number().optional(),
-          }),
-        },
-      ];
-
-      // Tool missing optional field should pass
-      const result1 = checker.isImplementedBy(tools1);
-      expect(typeof result1).toBe("boolean");
-
-      // Tool that requires optional field should also pass (it accepts what binder requires)
-      const tools2 = [
-        {
-          name: "OPTIONAL_FIELD_TOOL",
-          inputSchema: z.object({
-            required: z.string(),
-            optional: z.string(), // Required in tool, optional in binder - should pass
-          }),
-          outputSchema: z.object({
-            result: z.string(),
-            extra: z.number().optional(),
-          }),
-        },
-      ];
-
-      // Note: json-schema-diff might handle optional->required differently
-      const result2 = checker.isImplementedBy(tools2);
-      expect(typeof result2).toBe("boolean");
-    });
-
-    it("should handle record/object schemas correctly", () => {
-      const BINDING = [
-        {
-          name: "RECORD_TOOL" as const,
-          inputSchema: z.object({
-            metadata: z.record(z.string(), z.string()),
-          }),
-          outputSchema: z.object({
-            data: z.record(z.string(), z.any()),
-          }),
-        },
-      ] as const satisfies Binder;
-
-      const checker = createBindingChecker(BINDING);
-
-      // Tool with compatible record schema
-      const tools = [
-        {
-          name: "RECORD_TOOL",
-          inputSchema: z.object({
-            metadata: z.record(z.string(), z.any()), // Accepts string values (more permissive)
-          }),
-          outputSchema: z.object({
-            data: z.record(z.string(), z.any()),
-          }),
-        },
-      ];
-
-      expect(checker.isImplementedBy(tools)).toBe(true);
-    });
-  });
-
-  describe("Type inference", () => {
-    it("should infer input types from schemas", () => {
-      const binding = [
-        {
-          name: "TEST_TOOL" as const,
-          inputSchema: z.object({
-            id: z.string(),
-            count: z.number(),
-          }),
-          outputSchema: z.object({
-            success: z.boolean(),
-          }),
-        },
-      ] as const satisfies Binder;
-
-      type InputType = z.infer<(typeof binding)[0]["inputSchema"]>;
-      type OutputType = z.infer<
-        NonNullable<(typeof binding)[0]["outputSchema"]>
-      >;
-
-      const input: InputType = { id: "test", count: 5 };
-      const output: OutputType = { success: true };
-
-      expect(input.id).toBe("test");
-      expect(output.success).toBe(true);
-    });
-  });
-
-  describe("Real-world binding examples", () => {
-    it("should work with a channel binding", () => {
-      const CHANNEL_BINDING = [
-        {
-          name: "DECO_CHAT_CHANNELS_JOIN" as const,
-          inputSchema: z.object({
-            workspace: z.string(),
-            discriminator: z.string(),
-            agentId: z.string(),
-          }),
-          outputSchema: z.any(),
-        },
-        {
-          name: "DECO_CHAT_CHANNELS_LEAVE" as const,
-          inputSchema: z.object({
-            workspace: z.string(),
-            discriminator: z.string(),
-          }),
-          outputSchema: z.any(),
-        },
-        {
-          name: "DECO_CHAT_CHANNELS_LIST" as const,
-          inputSchema: z.any(),
-          outputSchema: z.object({
-            channels: z.array(
-              z.object({
-                label: z.string(),
-                value: z.string(),
-              }),
-            ),
-          }),
-          opt: true,
-        },
-      ] as const satisfies Binder;
-
-      const checker = createBindingChecker(CHANNEL_BINDING);
-
-      // Should pass with all tools
-      expect(
-        checker.isImplementedBy([
-          {
-            name: "DECO_CHAT_CHANNELS_JOIN",
-            inputSchema: z.object({
-              workspace: z.string(),
-              discriminator: z.string(),
-              agentId: z.string(),
-            }),
-            outputSchema: z.any(),
-          },
-          {
-            name: "DECO_CHAT_CHANNELS_LEAVE",
-            inputSchema: z.object({
-              workspace: z.string(),
-              discriminator: z.string(),
-            }),
-            outputSchema: z.any(),
-          },
-          {
-            name: "DECO_CHAT_CHANNELS_LIST",
-            inputSchema: z.any(),
-            outputSchema: z.object({
-              channels: z.array(
-                z.object({
-                  label: z.string(),
-                  value: z.string(),
-                }),
-              ),
-            }),
-          },
-        ]),
-      ).toBe(true);
-
-      // Should pass without optional tool
-      expect(
-        checker.isImplementedBy([
-          {
-            name: "DECO_CHAT_CHANNELS_JOIN",
-            inputSchema: z.object({
-              workspace: z.string(),
-              discriminator: z.string(),
-              agentId: z.string(),
-            }),
-            outputSchema: z.any(),
-          },
-          {
-            name: "DECO_CHAT_CHANNELS_LEAVE",
-            inputSchema: z.object({
-              workspace: z.string(),
-              discriminator: z.string(),
-            }),
-            outputSchema: z.any(),
-          },
-        ]),
-      ).toBe(true);
-
-      // Should fail without required tools
-      expect(
-        checker.isImplementedBy([
-          {
-            name: "DECO_CHAT_CHANNELS_JOIN",
-            inputSchema: z.object({
-              workspace: z.string(),
-              discriminator: z.string(),
-              agentId: z.string(),
-            }),
-            outputSchema: z.any(),
-          },
-        ]),
-      ).toBe(false);
-    });
-  });
-});