@kadi.build/core 0.0.1-alpha.1 → 0.0.1-alpha.11

package/dist/tools/ToolRegistry.d.ts

@@ -0,0 +1,256 @@
+/**
+ * Tool Registry (MCP-Based)
+ * ===========================
+ *
+ * Manages registration and retrieval of tools using Model Context Protocol (MCP)
+ * JSON Schemas for validation.
+ *
+ * **Breaking Change (v2.0.0)**:
+ * - Replaced Zod schemas with MCP JSON Schemas
+ * - Uses AJV for schema validation
+ * - Tools now use KadiTool interface
+ *
+ * @module tools/ToolRegistry
+ */
+import type { ToolHandler, RegisteredTool, ToolDefinition, KadiTool } from '../types/index.js';
+import { SchemaValidator } from '../validation/index.js';
+/**
+ * Tool Registry
+ * ==============
+ *
+ * Single responsibility: Manage tool registration and retrieval.
+ * Does NOT handle:
+ * - Tool invocation (that's the transport's job)
+ * - Broker communication (that's BrokerProtocol's job)
+ * - Events (that's EventHub's job)
+ *
+ * **Features**:
+ * - MCP-compliant tool definitions
+ * - AJV schema validation (global cache for performance)
+ * - KADI extensions (version, tags, networks)
+ *
+ * @example
+ * ```typescript
+ * const registry = new ToolRegistry();
+ *
+ * // Register a tool with MCP schema
+ * registry.register({
+ *   name: 'add',
+ *   description: 'Add two numbers',
+ *   version: '1.0.0',
+ *   tags: ['math'],
+ *   inputSchema: {
+ *     type: 'object',
+ *     properties: {
+ *       a: { type: 'number' },
+ *       b: { type: 'number' }
+ *     },
+ *     required: ['a', 'b']
+ *   },
+ *   outputSchema: {
+ *     type: 'object',
+ *     properties: {
+ *       result: { type: 'number' }
+ *     }
+ *   }
+ * }, async ({ a, b }) => ({ result: a + b }));
+ *
+ * // Retrieve a tool
+ * const tool = registry.get('add');
+ * if (tool) {
+ *   const result = await tool.handler({ a: 5, b: 3 });
+ * }
+ * ```
+ */
+export declare class ToolRegistry {
+    /**
+     * Internal storage for registered tools
+     */
+    private readonly tools;
+    /**
+     * Schema validator (uses global cache for performance)
+     */
+    private readonly validator;
+    /**
+     * Register a new tool
+     *
+     * @template TInput - Tool input type
+     * @template TOutput - Tool output type
+     *
+     * @param definition - MCP-compliant tool definition
+     * @param handler - Function that implements the tool
+     *
+     * @throws {KadiError} If name is invalid, tool already exists, or schema is invalid
+     *
+     * @example
+     * ```typescript
+     * registry.register({
+     *   name: 'greet',
+     *   description: 'Greet a user',
+     *   inputSchema: {
+     *     type: 'object',
+     *     properties: {
+     *       name: { type: 'string' }
+     *     },
+     *     required: ['name']
+     *   },
+     *   outputSchema: {
+     *     type: 'object',
+     *     properties: {
+     *       message: { type: 'string' }
+     *     }
+     *   }
+     * }, async ({ name }) => ({ message: `Hello, ${name}!` }));
+     * ```
+     */
+    register<TInput = unknown, TOutput = unknown>(definition: KadiTool, handler: ToolHandler<TInput, TOutput>): void;
+    /**
+     * Get a registered tool by name
+     *
+     * @param name - Tool identifier
+     * @returns The registered tool or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const tool = registry.get('add');
+     * if (tool) {
+     *   const result = await tool.handler({ a: 1, b: 2 });
+     * }
+     * ```
+     */
+    get(name: string): RegisteredTool | undefined;
+    /**
+     * Get handler function for a tool
+     *
+     * @param name - Tool identifier
+     * @returns Tool handler function or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const handler = registry.getHandler('add');
+     * if (handler) {
+     *   const result = await handler({ a: 5, b: 3 });
+     * }
+     * ```
+     */
+    getHandler<TInput = unknown, TOutput = unknown>(name: string): ToolHandler<TInput, TOutput> | undefined;
+    /**
+     * Get all registered tools
+     *
+     * @returns Array of all registered tools
+     *
+     * @example
+     * ```typescript
+     * const allTools = registry.getAll();
+     * console.log('Available tools:', allTools.map(t => t.definition.name));
+     * ```
+     */
+    getAll(): RegisteredTool[];
+    /**
+     * Check if a tool is registered
+     *
+     * @param name - Tool identifier
+     * @returns true if tool exists, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (registry.has('add')) {
+     *   // Tool is available
+     * }
+     * ```
+     */
+    has(name: string): boolean;
+    /**
+     * Unregister a tool
+     *
+     * @param name - Tool identifier to remove
+     * @returns true if tool was removed, false if it didn't exist
+     *
+     * @example
+     * ```typescript
+     * registry.unregister('old-tool');
+     * ```
+     */
+    unregister(name: string): boolean;
+    /**
+     * Clear all registered tools
+     *
+     * @example
+     * ```typescript
+     * registry.clear();
+     * ```
+     */
+    clear(): void;
+    /**
+     * Get the number of registered tools
+     *
+     * @example
+     * ```typescript
+     * console.log(`${registry.size} tools registered`);
+     * ```
+     */
+    get size(): number;
+    /**
+     * Extract tool definitions for broker registration
+     *
+     * Converts registered tools into MCP-compliant format for sending to the broker.
+     *
+     * @returns Array of MCP tool definitions
+     *
+     * @example
+     * ```typescript
+     * const definitions = registry.extractDefinitions();
+     * await broker.registerCapabilities({ tools: definitions });
+     * ```
+     */
+    extractDefinitions(): ToolDefinition[];
+    /**
+     * Validate input against a tool's schema
+     *
+     * @param toolName - Tool name
+     * @param input - Input data to validate
+     * @returns Validation result
+     *
+     * @example
+     * ```typescript
+     * const result = registry.validateInput('add', { a: 5, b: 3 });
+     * if (!result.valid) {
+     *   console.error('Invalid input:', result.errors);
+     * }
+     * ```
+     */
+    validateInput(toolName: string, input: unknown): import("../validation/SchemaValidator.js").ValidationResult;
+    /**
+     * Validate output against a tool's schema
+     *
+     * @param toolName - Tool name
+     * @param output - Output data to validate
+     * @returns Validation result
+     *
+     * @example
+     * ```typescript
+     * const result = registry.validateOutput('add', { result: 8 });
+     * if (!result.valid) {
+     *   console.error('Invalid output:', result.errors);
+     * }
+     * ```
+     */
+    validateOutput(toolName: string, output: unknown): import("../validation/SchemaValidator.js").ValidationResult;
+    /**
+     * Get schema validator instance
+     *
+     * Useful for advanced schema operations.
+     *
+     * @returns Schema validator
+     */
+    getValidator(): SchemaValidator;
+    /**
+     * Get global schema cache statistics
+     *
+     * @returns Cache statistics
+     */
+    static getCacheStats(): {
+        cachedSchemas: number;
+    };
+}
+//# sourceMappingURL=ToolRegistry.d.ts.map

package/dist/tools/ToolRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolRegistry.d.ts","sourceRoot":"","sources":["../../src/tools/ToolRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,cAAc,EACd,cAAc,EACd,QAAQ,EACT,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,qBAAa,YAAY;IACvB;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqC;IAE3D;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAyB;IAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,QAAQ,CAAC,MAAM,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO,EAC1C,UAAU,EAAE,QAAQ,EACpB,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,GACpC,IAAI;IAmGP;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAI7C;;;;;;;;;;;;;OAaG;IACH,UAAU,CAAC,MAAM,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO,EAC5C,IAAI,EAAE,MAAM,GACX,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS;IAK3C;;;;;;;;;;OAUG;IACH,MAAM,IAAI,cAAc,EAAE;IAI1B;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B;;;;;;;;;;OAUG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAMjC;;;;;;;OAOG;IACH,KAAK,IAAI,IAAI;IAQb;;;;;;;OAOG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;;;;;;;;;OAYG;IACH,kBAAkB,IAAI,cAAc,EAAE;IAetC;;;;;;;;;;;;;;OAcG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;IAI9C;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO;IAIhD;;;;;;OAMG;IACH,YAAY,IAAI,eAAe;IAI/B;;;;OAIG;IACH,MAAM,CAAC,aAAa,IAAI;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE;CAGlD"}

package/dist/tools/ToolRegistry.js

@@ -0,0 +1,340 @@
+/**
+ * Tool Registry (MCP-Based)
+ * ===========================
+ *
+ * Manages registration and retrieval of tools using Model Context Protocol (MCP)
+ * JSON Schemas for validation.
+ *
+ * **Breaking Change (v2.0.0)**:
+ * - Replaced Zod schemas with MCP JSON Schemas
+ * - Uses AJV for schema validation
+ * - Tools now use KadiTool interface
+ *
+ * @module tools/ToolRegistry
+ */
+import { KadiError, ErrorCode } from '../types/index.js';
+import { SchemaValidator } from '../validation/index.js';
+/**
+ * Tool Registry
+ * ==============
+ *
+ * Single responsibility: Manage tool registration and retrieval.
+ * Does NOT handle:
+ * - Tool invocation (that's the transport's job)
+ * - Broker communication (that's BrokerProtocol's job)
+ * - Events (that's EventHub's job)
+ *
+ * **Features**:
+ * - MCP-compliant tool definitions
+ * - AJV schema validation (global cache for performance)
+ * - KADI extensions (version, tags, networks)
+ *
+ * @example
+ * ```typescript
+ * const registry = new ToolRegistry();
+ *
+ * // Register a tool with MCP schema
+ * registry.register({
+ *   name: 'add',
+ *   description: 'Add two numbers',
+ *   version: '1.0.0',
+ *   tags: ['math'],
+ *   inputSchema: {
+ *     type: 'object',
+ *     properties: {
+ *       a: { type: 'number' },
+ *       b: { type: 'number' }
+ *     },
+ *     required: ['a', 'b']
+ *   },
+ *   outputSchema: {
+ *     type: 'object',
+ *     properties: {
+ *       result: { type: 'number' }
+ *     }
+ *   }
+ * }, async ({ a, b }) => ({ result: a + b }));
+ *
+ * // Retrieve a tool
+ * const tool = registry.get('add');
+ * if (tool) {
+ *   const result = await tool.handler({ a: 5, b: 3 });
+ * }
+ * ```
+ */
+export class ToolRegistry {
+    /**
+     * Internal storage for registered tools
+     */
+    tools = new Map();
+    /**
+     * Schema validator (uses global cache for performance)
+     */
+    validator = new SchemaValidator();
+    /**
+     * Register a new tool
+     *
+     * @template TInput - Tool input type
+     * @template TOutput - Tool output type
+     *
+     * @param definition - MCP-compliant tool definition
+     * @param handler - Function that implements the tool
+     *
+     * @throws {KadiError} If name is invalid, tool already exists, or schema is invalid
+     *
+     * @example
+     * ```typescript
+     * registry.register({
+     *   name: 'greet',
+     *   description: 'Greet a user',
+     *   inputSchema: {
+     *     type: 'object',
+     *     properties: {
+     *       name: { type: 'string' }
+     *     },
+     *     required: ['name']
+     *   },
+     *   outputSchema: {
+     *     type: 'object',
+     *     properties: {
+     *       message: { type: 'string' }
+     *     }
+     *   }
+     * }, async ({ name }) => ({ message: `Hello, ${name}!` }));
+     * ```
+     */
+    register(definition, handler) {
+        // Validate tool name
+        if (!definition.name || typeof definition.name !== 'string' || definition.name.trim().length === 0) {
+            throw new KadiError('Tool name must be a non-empty string', ErrorCode.INVALID_INPUT, 400, { definition });
+        }
+        // Check for duplicates
+        if (this.tools.has(definition.name)) {
+            throw new KadiError(`Tool '${definition.name}' is already registered`, ErrorCode.TOOL_ALREADY_REGISTERED, 409, { name: definition.name });
+        }
+        // Validate handler
+        if (typeof handler !== 'function') {
+            throw new KadiError('Tool handler must be a function', ErrorCode.INVALID_INPUT, 400, { name: definition.name, handlerType: typeof handler });
+        }
+        // Validate inputSchema (required in MCP)
+        if (!definition.inputSchema) {
+            throw new KadiError(`Tool '${definition.name}' must have an inputSchema`, ErrorCode.SCHEMA_VALIDATION_FAILED, 400, { name: definition.name });
+        }
+        // MCP requires inputSchema.type === 'object'
+        if (definition.inputSchema.type !== 'object') {
+            throw new KadiError(`Tool '${definition.name}' inputSchema must be type 'object' (MCP requirement)`, ErrorCode.SCHEMA_VALIDATION_FAILED, 400, { name: definition.name, schemaType: definition.inputSchema.type });
+        }
+        // Validate inputSchema is valid JSON Schema
+        const inputValidation = this.validator.validateSchemaDefinition(definition.inputSchema);
+        if (!inputValidation.valid) {
+            throw new KadiError(`Invalid inputSchema for tool '${definition.name}': ${inputValidation.errors.join(', ')}`, ErrorCode.SCHEMA_VALIDATION_FAILED, 400, { name: definition.name, errors: inputValidation.errors });
+        }
+        // Validate outputSchema if provided (optional in MCP, but we validate if present)
+        if (definition.outputSchema) {
+            if (definition.outputSchema.type !== 'object') {
+                throw new KadiError(`Tool '${definition.name}' outputSchema must be type 'object' (MCP requirement)`, ErrorCode.SCHEMA_VALIDATION_FAILED, 400, { name: definition.name, schemaType: definition.outputSchema.type });
+            }
+            const outputValidation = this.validator.validateSchemaDefinition(definition.outputSchema);
+            if (!outputValidation.valid) {
+                throw new KadiError(`Invalid outputSchema for tool '${definition.name}': ${outputValidation.errors.join(', ')}`, ErrorCode.SCHEMA_VALIDATION_FAILED, 400, { name: definition.name, errors: outputValidation.errors });
+            }
+        }
+        // Register schemas with validator for runtime validation
+        this.validator.registerTool(definition.name, definition.inputSchema, definition.outputSchema);
+        // Register the tool
+        this.tools.set(definition.name, {
+            definition,
+            handler: handler,
+            registeredAt: Date.now()
+        });
+    }
+    /**
+     * Get a registered tool by name
+     *
+     * @param name - Tool identifier
+     * @returns The registered tool or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const tool = registry.get('add');
+     * if (tool) {
+     *   const result = await tool.handler({ a: 1, b: 2 });
+     * }
+     * ```
+     */
+    get(name) {
+        return this.tools.get(name);
+    }
+    /**
+     * Get handler function for a tool
+     *
+     * @param name - Tool identifier
+     * @returns Tool handler function or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const handler = registry.getHandler('add');
+     * if (handler) {
+     *   const result = await handler({ a: 5, b: 3 });
+     * }
+     * ```
+     */
+    getHandler(name) {
+        const tool = this.tools.get(name);
+        return tool?.handler;
+    }
+    /**
+     * Get all registered tools
+     *
+     * @returns Array of all registered tools
+     *
+     * @example
+     * ```typescript
+     * const allTools = registry.getAll();
+     * console.log('Available tools:', allTools.map(t => t.definition.name));
+     * ```
+     */
+    getAll() {
+        return Array.from(this.tools.values());
+    }
+    /**
+     * Check if a tool is registered
+     *
+     * @param name - Tool identifier
+     * @returns true if tool exists, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (registry.has('add')) {
+     *   // Tool is available
+     * }
+     * ```
+     */
+    has(name) {
+        return this.tools.has(name);
+    }
+    /**
+     * Unregister a tool
+     *
+     * @param name - Tool identifier to remove
+     * @returns true if tool was removed, false if it didn't exist
+     *
+     * @example
+     * ```typescript
+     * registry.unregister('old-tool');
+     * ```
+     */
+    unregister(name) {
+        // Remove from validator as well
+        this.validator.unregisterTool(name);
+        return this.tools.delete(name);
+    }
+    /**
+     * Clear all registered tools
+     *
+     * @example
+     * ```typescript
+     * registry.clear();
+     * ```
+     */
+    clear() {
+        // Clear validator registrations
+        for (const name of this.tools.keys()) {
+            this.validator.unregisterTool(name);
+        }
+        this.tools.clear();
+    }
+    /**
+     * Get the number of registered tools
+     *
+     * @example
+     * ```typescript
+     * console.log(`${registry.size} tools registered`);
+     * ```
+     */
+    get size() {
+        return this.tools.size;
+    }
+    /**
+     * Extract tool definitions for broker registration
+     *
+     * Converts registered tools into MCP-compliant format for sending to the broker.
+     *
+     * @returns Array of MCP tool definitions
+     *
+     * @example
+     * ```typescript
+     * const definitions = registry.extractDefinitions();
+     * await broker.registerCapabilities({ tools: definitions });
+     * ```
+     */
+    extractDefinitions() {
+        return this.getAll().map(tool => ({
+            name: tool.definition.name,
+            title: tool.definition.title,
+            description: tool.definition.description,
+            version: tool.definition.version,
+            tags: tool.definition.tags,
+            networks: tool.definition.networks,
+            inputSchema: tool.definition.inputSchema,
+            outputSchema: tool.definition.outputSchema,
+            annotations: tool.definition.annotations,
+            _meta: tool.definition._meta
+        }));
+    }
+    /**
+     * Validate input against a tool's schema
+     *
+     * @param toolName - Tool name
+     * @param input - Input data to validate
+     * @returns Validation result
+     *
+     * @example
+     * ```typescript
+     * const result = registry.validateInput('add', { a: 5, b: 3 });
+     * if (!result.valid) {
+     *   console.error('Invalid input:', result.errors);
+     * }
+     * ```
+     */
+    validateInput(toolName, input) {
+        return this.validator.validateInput(toolName, input);
+    }
+    /**
+     * Validate output against a tool's schema
+     *
+     * @param toolName - Tool name
+     * @param output - Output data to validate
+     * @returns Validation result
+     *
+     * @example
+     * ```typescript
+     * const result = registry.validateOutput('add', { result: 8 });
+     * if (!result.valid) {
+     *   console.error('Invalid output:', result.errors);
+     * }
+     * ```
+     */
+    validateOutput(toolName, output) {
+        return this.validator.validateOutput(toolName, output);
+    }
+    /**
+     * Get schema validator instance
+     *
+     * Useful for advanced schema operations.
+     *
+     * @returns Schema validator
+     */
+    getValidator() {
+        return this.validator;
+    }
+    /**
+     * Get global schema cache statistics
+     *
+     * @returns Cache statistics
+     */
+    static getCacheStats() {
+        return SchemaValidator.getCacheStats();
+    }
+}
+//# sourceMappingURL=ToolRegistry.js.map

package/dist/tools/ToolRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolRegistry.js","sourceRoot":"","sources":["../../src/tools/ToolRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAQH,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,OAAO,YAAY;IACvB;;OAEG;IACc,KAAK,GAAG,IAAI,GAAG,EAA0B,CAAC;IAE3D;;OAEG;IACc,SAAS,GAAG,IAAI,eAAe,EAAE,CAAC;IAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,QAAQ,CACN,UAAoB,EACpB,OAAqC;QAErC,qBAAqB;QACrB,IAAI,CAAC,UAAU,CAAC,IAAI,IAAI,OAAO,UAAU,CAAC,IAAI,KAAK,QAAQ,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACnG,MAAM,IAAI,SAAS,CACjB,sCAAsC,EACtC,SAAS,CAAC,aAAa,EACvB,GAAG,EACH,EAAE,UAAU,EAAE,CACf,CAAC;QACJ,CAAC;QAED,uBAAuB;QACvB,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;YACpC,MAAM,IAAI,SAAS,CACjB,SAAS,UAAU,CAAC,IAAI,yBAAyB,EACjD,SAAS,CAAC,uBAAuB,EACjC,GAAG,EACH,EAAE,IAAI,EAAE,UAAU,CAAC,IAAI,EAAE,CAC1B,CAAC;QACJ,CAAC;QAED,mBAAmB;QACnB,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE,CAAC;YAClC,MAAM,IAAI,SAAS,CACjB,iCAAiC,EACjC,SAAS,CAAC,aAAa,EACvB,GAAG,EACH,EAAE,IAAI,EAAE,UAAU,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,OAAO,EAAE,CACvD,CAAC;QACJ,CAAC;QAED,yCAAyC;QACzC,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC;YAC5B,MAAM,IAAI,SAAS,CACjB,SAAS,UAAU,CAAC,IAAI,4BAA4B,EACpD,SAAS,CAAC,wBAAwB,EAClC,GAAG,EACH,EAAE,IAAI,EAAE,UAAU,CAAC,IAAI,EAAE,CAC1B,CAAC;QACJ,CAAC;QAED,6CAA6C;QAC7C,IAAI,UAAU,CAAC,WAAW,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC7C,MAAM,IAAI,SAAS,CACjB,SAAS,UAAU,CAAC,IAAI,uDAAuD,EAC/E,SAAS,CAAC,wBAAwB,EAClC,GAAG,EACH,EAAE,IAAI,EAAE,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,CAAC,WAAW,CAAC,IAAI,EAAE,CACnE,CAAC;QACJ,CAAC;QAED,4CAA4C;QAC5C,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,wBAAwB,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;QACxF,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC;YAC3B,MAAM,IAAI,SAAS,CACjB,iCAAiC,UAAU,CAAC,IAAI,MAAM,eAAe,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,EACzF,SAAS,CAAC,wBAAwB,EAClC,GAAG,EACH,EAAE,IAAI,EAAE,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,eAAe,CAAC,MAAM,EAAE,CAC1D,CAAC;QACJ,CAAC;QAED,kFAAkF;QAClF,IAAI,UAAU,CAAC,YAAY,EAAE,CAAC;YAC5B,IAAI,UAAU,CAAC,YAAY,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC9C,MAAM,IAAI,SAAS,CACjB,SAAS,UAAU,CAAC,IAAI,wDAAwD,EAChF,SAAS,CAAC,wBAAwB,EAClC,GAAG,EACH,EAAE,IAAI,EAAE,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,CAAC,YAAY,CAAC,IAAI,EAAE,CACpE,CAAC;YACJ,CAAC;YAED,MAAM,gBAAgB,GAAG,IAAI,CAAC,SAAS,CAAC,wBAAwB,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;YAC1F,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;gBAC5B,MAAM,IAAI,SAAS,CACjB,kCAAkC,UAAU,CAAC,IAAI,MAAM,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,EAC3F,SAAS,CAAC,wBAAwB,EAClC,GAAG,EACH,EAAE,IAAI,EAAE,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,gBAAgB,CAAC,MAAM,EAAE,CAC3D,CAAC;YACJ,CAAC;QACH,CAAC;QAED,yDAAyD;QACzD,IAAI,CAAC,SAAS,CAAC,YAAY,CACzB,UAAU,CAAC,IAAI,EACf,UAAU,CAAC,WAAW,EACtB,UAAU,CAAC,YAAY,CACxB,CAAC;QAEF,oBAAoB;QACpB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,EAAE;YAC9B,UAAU;YACV,OAAO,EAAE,OAAsB;YAC/B,YAAY,EAAE,IAAI,CAAC,GAAG,EAAE;SACzB,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAC,IAAY;QACd,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,UAAU,CACR,IAAY;QAEZ,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAClC,OAAO,IAAI,EAAE,OAAmD,CAAC;IACnE,CAAC;IAED;;;;;;;;;;OAUG;IACH,MAAM;QACJ,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;IACzC,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,IAAY;QACd,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAED;;;;;;;;;;OAUG;IACH,UAAU,CAAC,IAAY;QACrB,gCAAgC;QAChC,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QACpC,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAED;;;;;;;OAOG;IACH,KAAK;QACH,gCAAgC;QAChC,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC;YACrC,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QACtC,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC;IAED;;;;;;;OAOG;IACH,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;IACzB,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,kBAAkB;QAChB,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAChC,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI;YAC1B,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK;YAC5B,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,WAAW;YACxC,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,OAAO;YAChC,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI;YAC1B,QAAQ,EAAE,IAAI,CAAC,UAAU,CAAC,QAAQ;YAClC,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,WAAW;YACxC,YAAY,EAAE,IAAI,CAAC,UAAU,CAAC,YAAY;YAC1C,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,WAAW;YACxC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK;SAC7B,CAAC,CAAC,CAAC;IACN,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,aAAa,CAAC,QAAgB,EAAE,KAAc;QAC5C,OAAO,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IACvD,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,QAAgB,EAAE,MAAe;QAC9C,OAAO,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACzD,CAAC;IAED;;;;;;OAMG;IACH,YAAY;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,aAAa;QAClB,OAAO,eAAe,CAAC,aAAa,EAAE,CAAC;IACzC,CAAC;CACF"}

package/dist/tools/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tools Module
+ *
+ * Exports for tool registration and management.
+ */
+export { ToolRegistry } from './ToolRegistry.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/tools/index.js

@@ -0,0 +1,7 @@
+/**
+ * Tools Module
+ *
+ * Exports for tool registration and management.
+ */
+export { ToolRegistry } from './ToolRegistry.js';
+//# sourceMappingURL=index.js.map

package/dist/tools/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC"}