@hailer/mcp 1.1.16 → 1.1.17-beta.1

package/dist/mcp/tool-registry.js

@@ -1,63 +1,15 @@
 "use strict";
 /**
- * Clean Tool Registry with Dependency Injection
- *
- * No singletons, no statics - just clean, explicit tool registration
- * with per-agent access control via dependency injection.
- *
- * Supports workspace-specific schema overrides for structured outputs:
- * - Load schemas from WORKSPACE_SCHEMAS_PATH environment variable
- * - Schemas contain enum constraints (valid IDs, phase options, etc.)
- * - Enables Claude's strict mode validation with actual workspace values
+ * Tool Registry — register, list, validate, execute MCP tools.
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToolRegistry = exports.ToolGroup = void 0;
 const zod_1 = require("zod");
 const logger_1 = require("../lib/logger");
 const request_logger_1 = require("../lib/request-logger");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
 const logger = (0, logger_1.createLogger)({ component: 'tool-registry' });
 /**
  * Tool groups for access control
- * READ: Safe read operations (workflows, activities, schemas)
- * WRITE: Create/update operations (activities, discussions)
- * PLAYGROUND: Admin/dev tools (workflow/app management)
- * NUCLEAR: Destructive operations (remove workflows, apps, insights, templates)
- * BOT_INTERNAL: Tools for autonomous bots only (not exposed to MCP clients by default)
  */
 var ToolGroup;
 (function (ToolGroup) {
@@ -67,220 +19,63 @@ var ToolGroup;
     ToolGroup["NUCLEAR"] = "nuclear";
     ToolGroup["BOT_INTERNAL"] = "bot_internal";
 })(ToolGroup || (exports.ToolGroup = ToolGroup = {}));
-/**
- * ToolRegistry - Clean, testable, dependency-injected tool registry
- *
- * NO SINGLETON PATTERN - instantiated explicitly and passed through DI
- *
- * Workspace Schema Support:
- * Set WORKSPACE_SCHEMAS_PATH env var to load Claude-compatible schemas
- * with enum constraints for workflow IDs, phase IDs, field options, etc.
- */
 class ToolRegistry {
     tools = new Map();
+    jsonSchemas = new Map();
     _lazyGuard;
     enableNuclearTools;
-    workspaceSchemas = new Map();
-    workspaceSchemasLoaded = false;
     constructor(options = {}) {
         this.enableNuclearTools = options.enableNuclearTools ?? false;
-        logger.debug('ToolRegistry instance created', {
-            enableNuclearTools: this.enableNuclearTools
-        });
-        // Load workspace schemas if path is configured
-        this.loadWorkspaceSchemas();
     }
-    /**
-     * Load workspace-specific schemas from configured path
-     * Schemas provide enum constraints for Claude's strict mode
-     */
-    loadWorkspaceSchemas() {
-        const schemasPath = process.env.WORKSPACE_SCHEMAS_PATH;
-        if (!schemasPath) {
-            logger.debug('WORKSPACE_SCHEMAS_PATH not set, using generic schemas');
-            return;
-        }
-        const claudeSchemasPath = path.join(schemasPath, 'claude');
-        if (!fs.existsSync(claudeSchemasPath)) {
-            logger.warn('Workspace schemas path not found', { path: claudeSchemasPath });
-            return;
-        }
-        try {
-            const files = fs.readdirSync(claudeSchemasPath);
-            for (const file of files) {
-                if (file.endsWith('.schema.json')) {
-                    const schemaPath = path.join(claudeSchemasPath, file);
-                    const schema = JSON.parse(fs.readFileSync(schemaPath, 'utf-8'));
-                    const name = file.replace('.schema.json', '');
-                    this.workspaceSchemas.set(name, schema);
-                    logger.debug('Loaded workspace schema', { name, file });
-                }
-            }
-            this.workspaceSchemasLoaded = true;
-            logger.debug('Workspace schemas loaded for structured outputs', {
-                count: this.workspaceSchemas.size,
-                schemas: Array.from(this.workspaceSchemas.keys()),
-                path: claudeSchemasPath
-            });
-        }
-        catch (error) {
-            logger.error('Failed to load workspace schemas', error);
-        }
-    }
-    /**
-     * Get workspace schema for a workflow (if available)
-     */
-    getWorkspaceSchema(workflowName) {
-        const normalizedName = workflowName.toLowerCase().replace(/ /g, '_');
-        return this.workspaceSchemas.get(normalizedName) || null;
-    }
-    /**
-     * Check if workspace schemas are available
-     */
-    hasWorkspaceSchemas() {
-        return this.workspaceSchemasLoaded && this.workspaceSchemas.size > 0;
-    }
-    /**
-     * Add a tool to the registry
-     */
     addTool(tool) {
-        // Short-circuit: Skip NUCLEAR tools when not enabled
-        if (tool.group === ToolGroup.NUCLEAR && !this.enableNuclearTools) {
-            logger.debug('Skipping NUCLEAR tool (not enabled)', {
-                name: tool.name,
-                group: tool.group
-            });
+        if (tool.group === ToolGroup.NUCLEAR && !this.enableNuclearTools)
             return;
-        }
-        if (this.tools.has(tool.name)) {
-            logger.warn('Tool already registered, replacing', { name: tool.name });
-        }
         this.tools.set(tool.name, tool);
-        logger.debug('Tool registered', { name: tool.name, group: tool.group });
+        this.jsonSchemas.set(tool.name, this.convertZodSchemaToJsonSchema(tool.schema));
     }
-    /**
-     * Get tool definitions filtered by contextType — single-pass, no secondary lookups
-     */
+    /** Filter tools by contextType */
     getToolDefinitionsByContextType(contextType) {
         return Array.from(this.tools.values())
             .filter(t => (t.contextType ?? 'hailer') === contextType)
             .map(tool => ({
             name: tool.name,
             description: tool.description,
-            inputSchema: this.convertZodSchemaToJsonSchema(tool.schema)
+            inputSchema: this.jsonSchemas.get(tool.name)
         }));
     }
-    /**
-     * Get tool definitions with optional filtering
-     *
-     * @param filter - Optional filter configuration
-     * @param filter.allowedGroups - Filter by tool groups
-     * @param filter.allowedTools - Explicit whitelist of tool names
-     */
+    /** Get tool definitions with optional group/name filtering */
     getToolDefinitions(filter) {
         let toolsToExpose = Array.from(this.tools.values());
         if (filter) {
             if (filter.allowedTools) {
-                // Explicit whitelist by tool name (takes precedence)
                 toolsToExpose = toolsToExpose.filter(t => filter.allowedTools.includes(t.name));
-                logger.debug('Filtered tools by allowedTools', {
-                    count: toolsToExpose.length,
-                    allowedTools: filter.allowedTools
-                });
             }
             else if (filter.allowedGroups) {
-                // Filter by tool groups
                 toolsToExpose = toolsToExpose.filter(t => filter.allowedGroups.includes(t.group));
-                logger.debug('Filtered tools by allowedGroups', {
-                    count: toolsToExpose.length,
-                    allowedGroups: filter.allowedGroups
-                });
             }
         }
         return toolsToExpose.map(tool => ({
             name: tool.name,
             description: tool.description,
-            inputSchema: this.convertZodSchemaToJsonSchema(tool.schema)
+            inputSchema: this.jsonSchemas.get(tool.name)
         }));
     }
-    /**
-     * Get specific tool schema on-demand
-     * Token-efficient: ~200 tokens per tool vs loading all tools upfront
-     *
-     * For activity tools (create_activity, update_activity), returns the master
-     * workspace schema with ALL valid IDs as enums. This enables Claude's strict
-     * mode to constrain outputs to valid values without needing them in the prompt.
-     */
-    getToolSchema(toolName, workflowName) {
+    /** Get specific tool schema on-demand */
+    getToolSchema(toolName) {
         const tool = this.tools.get(toolName);
-        if (!tool) {
-            logger.warn('Tool not found', { toolName });
+        if (!tool)
             return null;
-        }
-        // For activity tools, return master schema with ALL enum constraints
-        if (this.workspaceSchemasLoaded &&
-            (toolName === 'create_activity' || toolName === 'update_activity')) {
-            const masterSchema = this.workspaceSchemas.get('_master_activity');
-            if (masterSchema) {
-                logger.debug('Using master workspace schema with enum constraints', {
-                    toolName,
-                    workflowCount: masterSchema.properties?.workflowId?.enum?.length || 0,
-                    phaseCount: masterSchema.properties?.phaseId?.enum?.length || 0
-                });
-                return {
-                    name: tool.name,
-                    description: `${tool.description} [Enum-constrained to valid workspace IDs]`,
-                    inputSchema: masterSchema
-                };
-            }
-        }
-        // For workflow-specific request, return that workflow's schema
-        if (this.workspaceSchemasLoaded && workflowName) {
-            const workspaceSchema = this.getWorkspaceSchema(workflowName);
-            if (workspaceSchema) {
-                logger.debug('Using workflow-specific schema', { toolName, workflowName });
-                return {
-                    name: tool.name,
-                    description: `${tool.description} [Schema-constrained to ${workflowName}]`,
-                    inputSchema: workspaceSchema
-                };
-            }
-        }
-        // Fallback to generic Zod-converted schema
         return {
             name: tool.name,
             description: tool.description,
-            inputSchema: this.convertZodSchemaToJsonSchema(tool.schema)
+            inputSchema: this.jsonSchemas.get(tool.name)
         };
     }
-    /**
-     * Get all workflow-specific tool schemas
-     * Returns schemas with enum constraints for each workflow
-     */
-    getAllWorkflowSchemas() {
-        const schemas = new Map();
-        if (!this.workspaceSchemasLoaded) {
-            return schemas;
-        }
-        for (const [workflowName, schema] of this.workspaceSchemas.entries()) {
-            if (workflowName.startsWith('_'))
-                continue; // Skip meta schemas
-            schemas.set(workflowName, {
-                name: `create_${workflowName}`,
-                description: `Create activity in ${workflowName}. Enum-constrained to valid IDs.`,
-                inputSchema: schema
-            });
-        }
-        return schemas;
-    }
-    /**
-     * Execute tool with validation
-     */
+    /** Execute tool with Zod validation */
     async executeTool(name, args, context) {
         const tool = this.tools.get(name);
-        if (!tool) {
+        if (!tool)
             throw new Error(`Tool "${name}" not found`);
-        }
         logger.debug('Executing tool', {
             name,
             auth: context?.apiKey
@@ -292,7 +87,6 @@ class ToolRegistry {
         if (name === 'install_workflow' && args.workflowTemplates) {
             transformedArgs = this.preTransformInstallWorkflow(args);
         }
-        // Zod validation
         try {
             const validated = tool.schema.parse(transformedArgs);
             return await tool.execute(validated, context);
@@ -300,57 +94,31 @@ class ToolRegistry {
         catch (error) {
             if (error instanceof zod_1.z.ZodError) {
                 const errorDetails = error.errors.map(e => `${e.path.join('.')}: ${e.message}`).join(', ');
-                // Track in request logger or log separately
                 const reqLogger = request_logger_1.RequestLogger.getCurrent();
                 if (reqLogger) {
                     reqLogger.toolError(name, errorDetails);
                 }
                 else {
-                    logger.warn('Tool validation failed', {
-                        toolName: name,
-                        errors: errorDetails,
-                        receivedArgs: JSON.stringify(args)
-                    });
+                    logger.warn('Tool validation failed', { toolName: name, errors: errorDetails, receivedArgs: JSON.stringify(args) });
                 }
-                // Check if tool has a skill hint
                 const hasSkillHint = tool.description.includes('Use Skill');
                 const skillName = hasSkillHint ? tool.description.match(/`([^`]+)-skill`/)?.[1] + '-skill' : null;
-                const errorMessage = `❌ **Validation Error for \`${name}\`**
-
-**Errors:** ${errorDetails}
-
-**You provided:**
-\`\`\`json
-${JSON.stringify(args, null, 2)}
-\`\`\`
-
-${skillName ? `💡 **Next step:** Load the skill first to see correct format and examples:
-\`\`\`
-get_skill({ skillName: "${skillName}" })
-\`\`\`
-
-Then retry \`${name}\` with the correct format from the skill examples.` : `💡 **Next step:** Use \`tools/get_schema\` to see the full schema for \`${name}\`, then retry with correct parameters.`}`;
                 return {
                     content: [{
                             type: "text",
-                            text: errorMessage
+                            text: `❌ **Validation Error for \`${name}\`**\n\n**Errors:** ${errorDetails}\n\n**You provided:**\n\`\`\`json\n${JSON.stringify(args, null, 2)}\n\`\`\`\n\n${skillName ? `💡 **Next step:** Load the skill first:\n\`\`\`\nget_skill({ skillName: "${skillName}" })\n\`\`\`\nThen retry with the correct format.` : `💡 **Next step:** Use \`tools/get_schema\` to see the full schema for \`${name}\`, then retry.`}`
                         }]
                 };
             }
             throw error;
         }
     }
-    /**
-     * Pre-transform install_workflow args to fix common LLM mistakes BEFORE validation
-     */
+    /** Fix common LLM mistakes in install_workflow before validation */
     preTransformInstallWorkflow(args) {
         let templates = args.workflowTemplates;
-        // Fix: single object instead of array
-        if (!Array.isArray(templates)) {
+        if (!Array.isArray(templates))
             templates = [templates];
-        }
-        // Transform each template
-        templates = templates.map((template, tIdx) => {
+        templates = templates.map((template) => {
             const result = { ...template };
             // Fix: fields as array instead of object
             if (Array.isArray(template.fields)) {
@@ -363,7 +131,6 @@ Then retry \`${name}\` with the correct format from the skill examples.` : `💡
                 result.fields = fieldsObj;
             }
             else if (template.fields) {
-                // Fix: field IDs not matching pattern
                 const fieldsObj = {};
                 let idx = 0;
                 for (const [key, field] of Object.entries(template.fields)) {
@@ -379,19 +146,16 @@ Then retry \`${name}\` with the correct format from the skill examples.` : `💡
             if (Array.isArray(template.phases)) {
                 const phasesObj = {};
                 template.phases.forEach((phase, idx) => {
-                    const phaseId = `_${2000 + idx}`;
-                    phasesObj[phaseId] = { name: phase.name };
+                    phasesObj[`_${2000 + idx}`] = { name: phase.name };
                 });
                 result.phases = phasesObj;
             }
             else if (template.phases) {
-                // Fix: phase IDs not matching pattern
                 const phasesObj = {};
                 let idx = 0;
                 for (const [key, phase] of Object.entries(template.phases)) {
                     const phaseId = /^_\d{4}$/.test(key) ? key : `_${2000 + idx}`;
-                    const p = phase;
-                    phasesObj[phaseId] = { name: p.name || key };
+                    phasesObj[phaseId] = { name: phase.name || key };
                     idx++;
                 }
                 result.phases = phasesObj;
@@ -400,10 +164,8 @@ Then retry \`${name}\` with the correct format from the skill examples.` : `💡
             if (result.fields) {
                 for (const fieldId of Object.keys(result.fields)) {
                     const f = result.fields[fieldId];
-                    // select → textpredefinedoptions
                     if (f.type === 'select')
                         f.type = 'textpredefinedoptions';
-                    // user → users
                     if (f.type === 'user')
                         f.type = 'users';
                 }
@@ -412,127 +174,55 @@ Then retry \`${name}\` with the correct format from the skill examples.` : `💡
         });
         return { ...args, workflowTemplates: templates };
     }
-    /**
-     * Get tool metadata (for access control checks)
-     */
     getTool(name) {
         return this.tools.get(name);
     }
-    /**
-     * Get total tool count
-     */
     getToolCount() {
         return this.tools.size;
     }
-    /**
-     * Get statistics for monitoring/debugging
-     */
     getCacheStats() {
         const byGroup = {
-            [ToolGroup.READ]: 0,
-            [ToolGroup.WRITE]: 0,
-            [ToolGroup.PLAYGROUND]: 0,
-            [ToolGroup.NUCLEAR]: 0,
-            [ToolGroup.BOT_INTERNAL]: 0
+            [ToolGroup.READ]: 0, [ToolGroup.WRITE]: 0,
+            [ToolGroup.PLAYGROUND]: 0, [ToolGroup.NUCLEAR]: 0, [ToolGroup.BOT_INTERNAL]: 0
         };
-        for (const tool of this.tools.values()) {
+        for (const tool of this.tools.values())
             byGroup[tool.group]++;
-        }
-        return {
-            totalTools: this.tools.size,
-            toolNames: Array.from(this.tools.keys()),
-            byGroup,
-            workspaceSchemas: {
-                loaded: this.workspaceSchemasLoaded,
-                count: this.workspaceSchemas.size,
-                workflows: Array.from(this.workspaceSchemas.keys())
-            }
-        };
+        return { totalTools: this.tools.size, toolNames: Array.from(this.tools.keys()), byGroup };
     }
-    /**
-     * Get all available workspace schemas (for listing available workflows)
-     */
-    getAvailableWorkflowSchemas() {
-        const workflows = [];
-        for (const [name, schema] of this.workspaceSchemas.entries()) {
-            if (name.startsWith('_'))
-                continue; // Skip meta schemas like _workspace
-            workflows.push({
-                name: name.replace(/_/g, ' ').replace(/\b\w/g, l => l.toUpperCase()),
-                workflowId: schema.properties?.workflowId?.const || '',
-                description: schema.description || ''
-            });
-        }
-        return workflows;
-    }
-    /**
-     * Get workflow-specific create tool definition
-     * Returns schema with enum constraints for valid phase IDs, field options, etc.
-     */
-    getWorkflowCreateToolDefinition(workflowName) {
-        const schema = this.getWorkspaceSchema(workflowName);
-        if (!schema) {
-            return null;
-        }
-        const normalizedName = workflowName.toLowerCase().replace(/ /g, '_');
-        return {
-            name: `create_${normalizedName}`,
-            description: `Create activity in ${workflowName}. Schema-validated with enum constraints for valid IDs.`,
-            inputSchema: schema
-        };
-    }
-    /**
-     * Convert Zod schema to JSON Schema format (required by MCP protocol)
-     */
+    // ===== ZOD → JSON SCHEMA CONVERSION =====
     convertZodSchemaToJsonSchema(zodSchema) {
-        // Handle ZodObject by extracting its shape
         if (zodSchema._def?.typeName === 'ZodObject') {
             zodSchema = zodSchema._def.shape();
         }
         const properties = {};
         const required = [];
-        // Handle the schema object
         for (const [key, value] of Object.entries(zodSchema)) {
             if (value && typeof value === "object" && "_def" in value) {
                 const zodType = value;
                 const property = this.convertZodTypeToJsonSchema(zodType);
-                // Handle optional vs required - Check for ZodOptional and ZodDefault wrappers
                 const isOptional = zodType._def?.typeName === 'ZodOptional';
                 const hasDefault = zodType._def?.typeName === 'ZodDefault';
-                if (!isOptional && !hasDefault) {
+                if (!isOptional && !hasDefault)
                     required.push(key);
-                }
-                // Handle default values - Extract from ZodDefault wrapper
                 if (hasDefault && typeof zodType._def?.defaultValue === 'function') {
                     property.default = zodType._def.defaultValue();
                 }
                 properties[key] = property;
             }
         }
-        return {
-            type: "object",
-            properties,
-            required,
-        };
+        return { type: "object", properties, required };
     }
-    /**
-     * Convert a single Zod type to JSON Schema
-     */
     convertZodTypeToJsonSchema(zodType) {
-        // Unwrap ZodOptional and ZodDefault wrappers to get the inner type
         let unwrappedType = zodType;
         while (unwrappedType._def?.typeName === 'ZodOptional' || unwrappedType._def?.typeName === 'ZodDefault') {
             unwrappedType = unwrappedType._def.innerType;
         }
         const typeName = unwrappedType._def?.typeName;
         const property = {};
-        // Add description if available (check both wrapped and unwrapped)
-        if (zodType._def?.description) {
+        if (zodType._def?.description)
             property.description = zodType._def.description;
-        }
-        else if (unwrappedType._def?.description) {
+        else if (unwrappedType._def?.description)
             property.description = unwrappedType._def.description;
-        }
         switch (typeName) {
             case "ZodString":
                 property.type = "string";
@@ -545,23 +235,17 @@ Then retry \`${name}\` with the correct format from the skill examples.` : `💡
                 break;
             case "ZodArray":
                 property.type = "array";
-                // Handle array items
-                if (unwrappedType._def?.type) {
-                    property.items = this.convertZodTypeToJsonSchema(unwrappedType._def.type);
-                }
-                else {
-                    property.items = { type: "string" };
-                }
+                property.items = unwrappedType._def?.type
+                    ? this.convertZodTypeToJsonSchema(unwrappedType._def.type)
+                    : { type: "string" };
                 break;
             case "ZodObject":
                 property.type = "object";
-                // Recursively handle object properties if needed
                 if (unwrappedType._def?.shape) {
                     const nestedSchema = this.convertZodSchemaToJsonSchema(unwrappedType._def.shape);
                     property.properties = nestedSchema.properties;
-                    if (nestedSchema.required?.length > 0) {
+                    if (nestedSchema.required?.length > 0)
                         property.required = nestedSchema.required;
-                    }
                 }
                 break;
             case "ZodRecord":
@@ -569,28 +253,21 @@ Then retry \`${name}\` with the correct format from the skill examples.` : `💡
                 break;
             case "ZodEnum":
                 property.type = "string";
-                // Handle enum values
-                if (unwrappedType._def?.values) {
+                if (unwrappedType._def?.values)
                     property.enum = Array.from(unwrappedType._def.values);
-                }
                 break;
             case "ZodUnion":
-                // For unions, try to extract types
-                if (unwrappedType._def?.options && unwrappedType._def.options.length > 0) {
-                    const firstOption = unwrappedType._def.options[0];
-                    const firstType = this.convertZodTypeToJsonSchema(firstOption);
+                if (unwrappedType._def?.options?.length > 0) {
+                    const firstType = this.convertZodTypeToJsonSchema(unwrappedType._def.options[0]);
                     property.type = firstType.type;
-                    if (firstType.enum) {
+                    if (firstType.enum)
                         property.enum = firstType.enum;
-                    }
                 }
                 else {
                     property.type = "string";
                 }
                 break;
             case "ZodLazy":
-                // Unwrap lazy schema (used for recursive types like WhereFilter)
-                // Guard against infinite recursion from self-referencing schemas
                 if (!this._lazyGuard)
                     this._lazyGuard = new Set();
                 if (this._lazyGuard.has(unwrappedType)) {
@@ -609,8 +286,7 @@ Then retry \`${name}\` with the correct format from the skill examples.` : `💡
                 this._lazyGuard.delete(unwrappedType);
                 property.type = "object";
                 break;
-            default:
-                property.type = "string";
+            default: property.type = "string";
         }
         return property;
     }