@decocms/bindings 0.2.4-beta.4 → 1.0.0-test.1

package/dist/index-D0aUdNls.d.ts

@@ -1,153 +0,0 @@
-import { z, ZodType } from 'zod/v3';
-import { MCPConnection } from './core/connection.js';
-
-interface FetchOptions extends RequestInit {
-    path?: string;
-    segments?: string[];
-}
-declare const MCPClient: {
-    forConnection: <TDefinition extends readonly ToolBinder[]>(connection: MCPConnection) => MCPClientFetchStub<TDefinition>;
-};
-
-declare const isStreamableToolBinder: (toolBinder: ToolBinder) => toolBinder is ToolBinder<string, any, any, true>;
-type MCPClientStub<TDefinition extends readonly ToolBinder[]> = {
-    [K in TDefinition[number] as K["name"]]: K extends ToolBinder<string, infer TInput, infer TReturn> ? (params: TInput, init?: RequestInit) => Promise<TReturn> : never;
-};
-type MCPClientFetchStub<TDefinition extends readonly ToolBinder[]> = {
-    [K in TDefinition[number] as K["name"]]: K["streamable"] extends true ? K extends ToolBinder<string, infer TInput, any, true> ? (params: TInput, init?: RequestInit) => Promise<Response> : never : K extends ToolBinder<string, infer TInput, infer TReturn, any> ? (params: TInput, init?: RequestInit) => Promise<Awaited<TReturn>> : never;
-};
-interface MCPClientRaw {
-    callTool: (tool: string, args: unknown) => Promise<unknown>;
-    listTools: () => Promise<{
-        name: string;
-        inputSchema: any;
-        outputSchema?: any;
-        description: string;
-    }[]>;
-}
-type JSONSchemaToZodConverter = (jsonSchema: any) => z.ZodTypeAny;
-interface CreateStubAPIOptions {
-    connection: MCPConnection;
-    streamable?: Record<string, boolean>;
-    debugId?: () => string;
-    getErrorByStatusCode?: (statusCode: number, message?: string, traceId?: string, errorObject?: unknown) => Error;
-}
-declare function createMCPFetchStub<TDefinition extends readonly ToolBinder[]>(options: CreateStubAPIOptions): MCPClientFetchStub<TDefinition>;
-
-/**
- * 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.
- */
-
-type JsonSchema = Record<string, unknown>;
-/**
- * Normalizes a schema to JSON Schema format.
- * Accepts either a Zod schema or a JSON schema and returns a JSON schema.
- *
- * @param schema - A Zod schema or JSON schema
- * @returns The JSON schema representation, or null if input is null/undefined
- */
-declare function normalizeToJsonSchema(schema: ZodType<any> | JsonSchema | null | undefined): JsonSchema | null;
-/**
- * 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, TStreamable extends boolean = boolean> {
-    /** 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?: TStreamable extends true ? never : ZodType<TReturn>;
-    /**
-     * Whether this tool is streamable.
-     */
-    streamable?: TStreamable;
-    /**
-     * 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[]) => boolean;
-}
-declare const bindingClient: <TDefinition extends readonly ToolBinder[]>(binder: TDefinition) => {
-    forConnection: (mcpConnection: MCPConnection) => MCPClientFetchStub<TDefinition>;
-    /**
-     * 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[]) => boolean;
-};
-type MCPBindingClient<T extends ReturnType<typeof bindingClient>> = ReturnType<T["forConnection"]>;
-/**
- * Creates a binding checker with full schema validation using structural subset checking.
- *
- * This performs strict compatibility checking:
- * - For input schemas: Validates that the tool can accept what the binder requires (binder ⊆ tool)
- * - For output schemas: Validates that the tool provides what the binder expects (binder ⊆ tool)
- *
- * @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 as B, type CreateStubAPIOptions as C, type FetchOptions as F, type JSONSchemaToZodConverter as J, type MCPClientFetchStub as M, type ToolWithSchemas as T, type ToolBinder as a, MCPClient as b, type MCPClientStub as c, type MCPClientRaw as d, createMCPFetchStub as e, type BindingChecker as f, bindingClient as g, type MCPBindingClient as h, isStreamableToolBinder as i, createBindingChecker as j, normalizeToJsonSchema as n };

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-export { B as Binder, f as BindingChecker, a as ToolBinder, T as ToolWithSchemas, j as createBindingChecker } from './index-D0aUdNls.js';
-import 'zod/v3';
-import './core/connection.js';

package/dist/index.js

@@ -1,7 +0,0 @@
-import {
-  createBindingChecker
-} from "./core/binder";
-export {
-  createBindingChecker
-};
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * @decocms/bindings\n *\n * Core type definitions for the bindings system.\n * Bindings define standardized interfaces that integrations (MCPs) can implement.\n */\n\n// Re-export core binder types and utilities\nexport {\n  createBindingChecker,\n  type Binder,\n  type BindingChecker,\n  type ToolBinder,\n  type ToolWithSchemas,\n} from \"./core/binder\";\n"],"mappings":"AAQA;AAAA,EACE;AAAA,OAKK;","names":[]}