@decocms/bindings 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,90 @@
+import { ZodType } from 'zod';
+
+/**
+ * Core Binder Types and Utilities
+ *
+ * This module provides the core types and utilities for the bindings system.
+ * Bindings define standardized interfaces that integrations (MCPs) can implement.
+ */
+
+/**
+ * ToolBinder defines a single tool within a binding.
+ * It specifies the tool name, input/output schemas, and whether it's optional.
+ *
+ * @template TName - The tool name (can be a string or RegExp for pattern matching)
+ * @template TInput - The input type (inferred from inputSchema)
+ * @template TReturn - The return type (inferred from outputSchema)
+ */
+interface ToolBinder<TName extends string | RegExp = string, TInput = any, TReturn extends object | null | boolean = object> {
+    /** The name of the tool (e.g., "DECO_CHAT_CHANNELS_JOIN") */
+    name: TName;
+    /** Zod schema for validating tool input */
+    inputSchema: ZodType<TInput>;
+    /** Optional Zod schema for validating tool output */
+    outputSchema?: ZodType<TReturn>;
+    /**
+     * Whether this tool is optional in the binding.
+     * If true, an implementation doesn't need to provide this tool.
+     */
+    opt?: true;
+}
+/**
+ * Binder represents a collection of tool definitions that form a binding.
+ * A binding is like a TypeScript interface - it defines what tools must be implemented.
+ *
+ * @template TDefinition - Array of ToolBinder definitions
+ *
+ * @example
+ * ```ts
+ * const MY_BINDING = [{
+ *   name: "MY_TOOL" as const,
+ *   inputSchema: z.object({ id: z.string() }),
+ *   outputSchema: z.object({ success: z.boolean() }),
+ * }] as const satisfies Binder;
+ * ```
+ */
+type Binder<TDefinition extends readonly ToolBinder[] = readonly ToolBinder[]> = TDefinition;
+/**
+ * Tool with schemas for validation
+ */
+interface ToolWithSchemas {
+    name: string;
+    inputSchema?: ZodType<any> | Record<string, unknown>;
+    outputSchema?: ZodType<any> | Record<string, unknown>;
+}
+/**
+ * Binding checker interface
+ */
+interface BindingChecker {
+    /**
+     * Check if a set of tools implements the binding with full schema validation.
+     *
+     * Validates:
+     * - Tool name matches (exact or regex)
+     * - Input schema: Tool accepts what binder requires (no removals from binder to tool)
+     * - Output schema: Tool provides what binder expects (no removals from tool to binder)
+     *
+     * @param tools - Array of tools with names and schemas
+     * @returns Promise<boolean> - true if all tools implement the binding correctly
+     */
+    isImplementedBy: (tools: ToolWithSchemas[]) => Promise<boolean>;
+}
+/**
+ * Creates a binding checker with full schema validation using json-schema-diff.
+ *
+ * This performs strict compatibility checking:
+ * - For input schemas: Validates that the tool can accept what the binder requires
+ * - For output schemas: Validates that the tool provides what the binder expects
+ *
+ * @param binderTools - The binding definition to check against
+ * @returns A binding checker with an async isImplementedBy method
+ *
+ * @example
+ * ```ts
+ * const checker = createBindingChecker(MY_BINDING);
+ * const isCompatible = await checker.isImplementedBy(availableTools);
+ * ```
+ */
+declare function createBindingChecker<TDefinition extends readonly ToolBinder[]>(binderTools: TDefinition): BindingChecker;
+
+export { type Binder, type BindingChecker, type ToolBinder, type ToolWithSchemas, createBindingChecker };

package/dist/index.js

@@ -0,0 +1,79 @@
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { diffSchemas } from 'json-schema-diff';
+
+// src/core/binder.ts
+function normalizeSchema(schema) {
+  if (!schema) return void 0;
+  if (schema._def) {
+    const jsonSchema2 = zodToJsonSchema(schema, {
+      // Don't add additionalProperties: false to allow structural compatibility
+      $refStrategy: "none"
+    });
+    if (jsonSchema2.type === "object") {
+      delete jsonSchema2.additionalProperties;
+    }
+    return jsonSchema2;
+  }
+  const jsonSchema = schema;
+  if (jsonSchema.type === "object" && "additionalProperties" in jsonSchema) {
+    const copy = { ...jsonSchema };
+    delete copy.additionalProperties;
+    return copy;
+  }
+  return jsonSchema;
+}
+function createBindingChecker(binderTools) {
+  return {
+    isImplementedBy: async (tools) => {
+      for (const binderTool of binderTools) {
+        const pattern = typeof binderTool.name === "string" ? new RegExp(`^${binderTool.name}$`) : binderTool.name;
+        const matchedTool = tools.find((t) => pattern.test(t.name));
+        if (!matchedTool && binderTool.opt) {
+          continue;
+        }
+        if (!matchedTool) {
+          return false;
+        }
+        const binderInputSchema = normalizeSchema(binderTool.inputSchema);
+        const toolInputSchema = normalizeSchema(matchedTool.inputSchema);
+        if (binderInputSchema && toolInputSchema) {
+          try {
+            const inputDiff = await diffSchemas({
+              sourceSchema: binderInputSchema,
+              destinationSchema: toolInputSchema
+            });
+            if (inputDiff.removalsFound) {
+              return false;
+            }
+          } catch (error) {
+            return false;
+          }
+        } else if (binderInputSchema && !toolInputSchema) {
+          return false;
+        }
+        const binderOutputSchema = normalizeSchema(binderTool.outputSchema);
+        const toolOutputSchema = normalizeSchema(matchedTool.outputSchema);
+        if (binderOutputSchema && toolOutputSchema) {
+          try {
+            const outputDiff = await diffSchemas({
+              sourceSchema: binderOutputSchema,
+              destinationSchema: toolOutputSchema
+            });
+            if (outputDiff.removalsFound) {
+              return false;
+            }
+          } catch (error) {
+            return false;
+          }
+        } else if (binderOutputSchema && !toolOutputSchema) {
+          return false;
+        }
+      }
+      return true;
+    }
+  };
+}
+
+export { createBindingChecker };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/binder.ts"],"names":["jsonSchema"],"mappings":"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","file":"index.js","sourcesContent":["/**\n * Core Binder Types and Utilities\n *\n * This module provides the core types and utilities for the bindings system.\n * Bindings define standardized interfaces that integrations (MCPs) can implement.\n */\n\nimport type { ZodType } from \"zod\";\nimport { zodToJsonSchema } from \"zod-to-json-schema\";\nimport { diffSchemas } from \"json-schema-diff\";\n\n/**\n * ToolBinder defines a single tool within a binding.\n * It specifies the tool name, input/output schemas, and whether it's optional.\n *\n * @template TName - The tool name (can be a string or RegExp for pattern matching)\n * @template TInput - The input type (inferred from inputSchema)\n * @template TReturn - The return type (inferred from outputSchema)\n */\nexport interface ToolBinder<\n  TName extends string | RegExp = string,\n  // biome-ignore lint/suspicious/noExplicitAny: Generic type parameter\n  TInput = any,\n  TReturn extends object | null | boolean = object,\n> {\n  /** The name of the tool (e.g., \"DECO_CHAT_CHANNELS_JOIN\") */\n  name: TName;\n\n  /** Zod schema for validating tool input */\n  inputSchema: ZodType<TInput>;\n\n  /** Optional Zod schema for validating tool output */\n  outputSchema?: ZodType<TReturn>;\n\n  /**\n   * Whether this tool is optional in the binding.\n   * If true, an implementation doesn't need to provide this tool.\n   */\n  opt?: true;\n}\n\n/**\n * Binder represents a collection of tool definitions that form a binding.\n * A binding is like a TypeScript interface - it defines what tools must be implemented.\n *\n * @template TDefinition - Array of ToolBinder definitions\n *\n * @example\n * ```ts\n * const MY_BINDING = [{\n *   name: \"MY_TOOL\" as const,\n *   inputSchema: z.object({ id: z.string() }),\n *   outputSchema: z.object({ success: z.boolean() }),\n * }] as const satisfies Binder;\n * ```\n */\nexport type Binder<\n  TDefinition extends readonly ToolBinder[] = readonly ToolBinder[],\n> = TDefinition;\n\n/**\n * Tool with schemas for validation\n */\nexport interface ToolWithSchemas {\n  name: string;\n  inputSchema?: ZodType<any> | Record<string, unknown>;\n  outputSchema?: ZodType<any> | Record<string, unknown>;\n}\n\n/**\n * Converts a schema to JSON Schema format if it's a Zod schema\n */\nfunction normalizeSchema(schema: any): Record<string, unknown> | undefined {\n  if (!schema) return undefined;\n\n  // If it's a Zod schema (has _def property), convert it\n  if (schema._def) {\n    const jsonSchema = zodToJsonSchema(schema, {\n      // Don't add additionalProperties: false to allow structural compatibility\n      $refStrategy: \"none\",\n    }) as Record<string, unknown>;\n\n    // Remove additionalProperties constraint to allow subtyping\n    if (jsonSchema.type === \"object\") {\n      delete jsonSchema.additionalProperties;\n    }\n\n    return jsonSchema;\n  }\n\n  // Otherwise assume it's already a JSON Schema\n  const jsonSchema = schema as Record<string, unknown>;\n\n  // Remove additionalProperties constraint if present\n  if (jsonSchema.type === \"object\" && \"additionalProperties\" in jsonSchema) {\n    const copy = { ...jsonSchema };\n    delete copy.additionalProperties;\n    return copy;\n  }\n\n  return jsonSchema;\n}\n\n/**\n * Binding checker interface\n */\nexport interface BindingChecker {\n  /**\n   * Check if a set of tools implements the binding with full schema validation.\n   *\n   * Validates:\n   * - Tool name matches (exact or regex)\n   * - Input schema: Tool accepts what binder requires (no removals from binder to tool)\n   * - Output schema: Tool provides what binder expects (no removals from tool to binder)\n   *\n   * @param tools - Array of tools with names and schemas\n   * @returns Promise<boolean> - true if all tools implement the binding correctly\n   */\n  isImplementedBy: (tools: ToolWithSchemas[]) => Promise<boolean>;\n}\n\n/**\n * Creates a binding checker with full schema validation using json-schema-diff.\n *\n * This performs strict compatibility checking:\n * - For input schemas: Validates that the tool can accept what the binder requires\n * - For output schemas: Validates that the tool provides what the binder expects\n *\n * @param binderTools - The binding definition to check against\n * @returns A binding checker with an async isImplementedBy method\n *\n * @example\n * ```ts\n * const checker = createBindingChecker(MY_BINDING);\n * const isCompatible = await checker.isImplementedBy(availableTools);\n * ```\n */\nexport function createBindingChecker<TDefinition extends readonly ToolBinder[]>(\n  binderTools: TDefinition,\n): BindingChecker {\n  return {\n    isImplementedBy: async (tools: ToolWithSchemas[]) => {\n      for (const binderTool of binderTools) {\n        // Find matching tool by name (exact or regex)\n        const pattern =\n          typeof binderTool.name === \"string\"\n            ? new RegExp(`^${binderTool.name}$`)\n            : binderTool.name;\n\n        const matchedTool = tools.find((t) => pattern.test(t.name));\n\n        // Skip optional tools that aren't present\n        if (!matchedTool && binderTool.opt) {\n          continue;\n        }\n\n        // Required tool not found\n        if (!matchedTool) {\n          return false;\n        }\n\n        // === INPUT SCHEMA VALIDATION ===\n        // Tool must accept what binder requires\n        // Check: binder (source) -> tool (destination)\n        // If removals found, tool doesn't accept something binder requires\n        const binderInputSchema = normalizeSchema(binderTool.inputSchema);\n        const toolInputSchema = normalizeSchema(matchedTool.inputSchema);\n\n        if (binderInputSchema && toolInputSchema) {\n          try {\n            const inputDiff = await diffSchemas({\n              sourceSchema: binderInputSchema,\n              destinationSchema: toolInputSchema,\n            });\n\n            // If something was removed from binder to tool, tool can't accept it\n            if (inputDiff.removalsFound) {\n              return false;\n            }\n          } catch (error) {\n            // Schema diff failed - consider incompatible\n            return false;\n          }\n        } else if (binderInputSchema && !toolInputSchema) {\n          // Binder requires input schema but tool doesn't have one\n          return false;\n        }\n\n        // === OUTPUT SCHEMA VALIDATION ===\n        // Tool must provide what binder expects (but can provide more)\n        // Check: binder (source) -> tool (destination)\n        // If removals found, tool doesn't provide something binder expects\n        const binderOutputSchema = normalizeSchema(binderTool.outputSchema);\n        const toolOutputSchema = normalizeSchema(matchedTool.outputSchema);\n\n        if (binderOutputSchema && toolOutputSchema) {\n          try {\n            const outputDiff = await diffSchemas({\n              sourceSchema: binderOutputSchema,\n              destinationSchema: toolOutputSchema,\n            });\n\n            // If something was removed from binder to tool, tool doesn't provide it\n            if (outputDiff.removalsFound) {\n              return false;\n            }\n          } catch (error) {\n            // Schema diff failed - consider incompatible\n            return false;\n          }\n        } else if (binderOutputSchema && !toolOutputSchema) {\n          // Binder expects output schema but tool doesn't have one\n          return false;\n        }\n      }\n\n      return true;\n    },\n  };\n}\n\n"]}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@decocms/bindings",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "json-schema-diff": "^1.0.0",
+    "zod": "^3.25.76",
+    "zod-to-json-schema": "^3.24.4"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**/*",
+    "src/**/*"
+  ],
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "devDependencies": {
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.3",
+    "vitest": "3.2.4"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}
+

package/src/core/binder.ts

@@ -0,0 +1,221 @@
+/**
+ * Core Binder Types and Utilities
+ *
+ * This module provides the core types and utilities for the bindings system.
+ * Bindings define standardized interfaces that integrations (MCPs) can implement.
+ */
+
+import type { ZodType } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { diffSchemas } from "json-schema-diff";
+
+/**
+ * ToolBinder defines a single tool within a binding.
+ * It specifies the tool name, input/output schemas, and whether it's optional.
+ *
+ * @template TName - The tool name (can be a string or RegExp for pattern matching)
+ * @template TInput - The input type (inferred from inputSchema)
+ * @template TReturn - The return type (inferred from outputSchema)
+ */
+export interface ToolBinder<
+  TName extends string | RegExp = string,
+  // biome-ignore lint/suspicious/noExplicitAny: Generic type parameter
+  TInput = any,
+  TReturn extends object | null | boolean = object,
+> {
+  /** The name of the tool (e.g., "DECO_CHAT_CHANNELS_JOIN") */
+  name: TName;
+
+  /** Zod schema for validating tool input */
+  inputSchema: ZodType<TInput>;
+
+  /** Optional Zod schema for validating tool output */
+  outputSchema?: ZodType<TReturn>;
+
+  /**
+   * Whether this tool is optional in the binding.
+   * If true, an implementation doesn't need to provide this tool.
+   */
+  opt?: true;
+}
+
+/**
+ * Binder represents a collection of tool definitions that form a binding.
+ * A binding is like a TypeScript interface - it defines what tools must be implemented.
+ *
+ * @template TDefinition - Array of ToolBinder definitions
+ *
+ * @example
+ * ```ts
+ * const MY_BINDING = [{
+ *   name: "MY_TOOL" as const,
+ *   inputSchema: z.object({ id: z.string() }),
+ *   outputSchema: z.object({ success: z.boolean() }),
+ * }] as const satisfies Binder;
+ * ```
+ */
+export type Binder<
+  TDefinition extends readonly ToolBinder[] = readonly ToolBinder[],
+> = TDefinition;
+
+/**
+ * Tool with schemas for validation
+ */
+export interface ToolWithSchemas {
+  name: string;
+  inputSchema?: ZodType<any> | Record<string, unknown>;
+  outputSchema?: ZodType<any> | Record<string, unknown>;
+}
+
+/**
+ * Converts a schema to JSON Schema format if it's a Zod schema
+ */
+function normalizeSchema(schema: any): Record<string, unknown> | undefined {
+  if (!schema) return undefined;
+
+  // If it's a Zod schema (has _def property), convert it
+  if (schema._def) {
+    const jsonSchema = zodToJsonSchema(schema, {
+      // Don't add additionalProperties: false to allow structural compatibility
+      $refStrategy: "none",
+    }) as Record<string, unknown>;
+
+    // Remove additionalProperties constraint to allow subtyping
+    if (jsonSchema.type === "object") {
+      delete jsonSchema.additionalProperties;
+    }
+
+    return jsonSchema;
+  }
+
+  // Otherwise assume it's already a JSON Schema
+  const jsonSchema = schema as Record<string, unknown>;
+
+  // Remove additionalProperties constraint if present
+  if (jsonSchema.type === "object" && "additionalProperties" in jsonSchema) {
+    const copy = { ...jsonSchema };
+    delete copy.additionalProperties;
+    return copy;
+  }
+
+  return jsonSchema;
+}
+
+/**
+ * Binding checker interface
+ */
+export interface BindingChecker {
+  /**
+   * Check if a set of tools implements the binding with full schema validation.
+   *
+   * Validates:
+   * - Tool name matches (exact or regex)
+   * - Input schema: Tool accepts what binder requires (no removals from binder to tool)
+   * - Output schema: Tool provides what binder expects (no removals from tool to binder)
+   *
+   * @param tools - Array of tools with names and schemas
+   * @returns Promise<boolean> - true if all tools implement the binding correctly
+   */
+  isImplementedBy: (tools: ToolWithSchemas[]) => Promise<boolean>;
+}
+
+/**
+ * Creates a binding checker with full schema validation using json-schema-diff.
+ *
+ * This performs strict compatibility checking:
+ * - For input schemas: Validates that the tool can accept what the binder requires
+ * - For output schemas: Validates that the tool provides what the binder expects
+ *
+ * @param binderTools - The binding definition to check against
+ * @returns A binding checker with an async isImplementedBy method
+ *
+ * @example
+ * ```ts
+ * const checker = createBindingChecker(MY_BINDING);
+ * const isCompatible = await checker.isImplementedBy(availableTools);
+ * ```
+ */
+export function createBindingChecker<TDefinition extends readonly ToolBinder[]>(
+  binderTools: TDefinition,
+): BindingChecker {
+  return {
+    isImplementedBy: async (tools: ToolWithSchemas[]) => {
+      for (const binderTool of binderTools) {
+        // Find matching tool by name (exact or regex)
+        const pattern =
+          typeof binderTool.name === "string"
+            ? new RegExp(`^${binderTool.name}$`)
+            : binderTool.name;
+
+        const matchedTool = tools.find((t) => pattern.test(t.name));
+
+        // Skip optional tools that aren't present
+        if (!matchedTool && binderTool.opt) {
+          continue;
+        }
+
+        // Required tool not found
+        if (!matchedTool) {
+          return false;
+        }
+
+        // === INPUT SCHEMA VALIDATION ===
+        // Tool must accept what binder requires
+        // Check: binder (source) -> tool (destination)
+        // If removals found, tool doesn't accept something binder requires
+        const binderInputSchema = normalizeSchema(binderTool.inputSchema);
+        const toolInputSchema = normalizeSchema(matchedTool.inputSchema);
+
+        if (binderInputSchema && toolInputSchema) {
+          try {
+            const inputDiff = await diffSchemas({
+              sourceSchema: binderInputSchema,
+              destinationSchema: toolInputSchema,
+            });
+
+            // If something was removed from binder to tool, tool can't accept it
+            if (inputDiff.removalsFound) {
+              return false;
+            }
+          } catch (error) {
+            // Schema diff failed - consider incompatible
+            return false;
+          }
+        } else if (binderInputSchema && !toolInputSchema) {
+          // Binder requires input schema but tool doesn't have one
+          return false;
+        }
+
+        // === OUTPUT SCHEMA VALIDATION ===
+        // Tool must provide what binder expects (but can provide more)
+        // Check: binder (source) -> tool (destination)
+        // If removals found, tool doesn't provide something binder expects
+        const binderOutputSchema = normalizeSchema(binderTool.outputSchema);
+        const toolOutputSchema = normalizeSchema(matchedTool.outputSchema);
+
+        if (binderOutputSchema && toolOutputSchema) {
+          try {
+            const outputDiff = await diffSchemas({
+              sourceSchema: binderOutputSchema,
+              destinationSchema: toolOutputSchema,
+            });
+
+            // If something was removed from binder to tool, tool doesn't provide it
+            if (outputDiff.removalsFound) {
+              return false;
+            }
+          } catch (error) {
+            // Schema diff failed - consider incompatible
+            return false;
+          }
+        } else if (binderOutputSchema && !toolOutputSchema) {
+          // Binder expects output schema but tool doesn't have one
+          return false;
+        }
+      }
+
+      return true;
+    },
+  };
+}
+

package/src/index.ts

@@ -0,0 +1,16 @@
+/**
+ * @decocms/bindings
+ *
+ * Core type definitions for the bindings system.
+ * Bindings define standardized interfaces that integrations (MCPs) can implement.
+ */
+
+// Re-export core binder types and utilities
+export {
+  type ToolBinder,
+  type Binder,
+  type ToolWithSchemas,
+  type BindingChecker,
+  createBindingChecker,
+} from "./core/binder";
+