@hailer/mcp 0.0.6 → 0.1.1

package/dist/client/adaptive-documentation-bot.js

@@ -17,13 +17,11 @@ exports.AdaptiveDocumentationBot = void 0;
 const logger_1 = require("../lib/logger");
 const log_parser_1 = require("./log-parser");
 const description_updater_1 = require("./description-updater");
-const skill_generator_1 = require("./skill-generator");
 const simple_llm_caller_1 = require("./simple-llm-caller");
 const logger = (0, logger_1.createLogger)({ component: 'AdaptiveDocumentationBot' });
 class AdaptiveDocumentationBot {
     logParser;
     descriptionUpdater;
-    skillGenerator;
     llmCaller;
     config;
     errorPatterns = new Map();
@@ -41,7 +39,6 @@ class AdaptiveDocumentationBot {
         };
         this.logParser = new log_parser_1.LogParser(this.config.logPath);
         this.descriptionUpdater = new description_updater_1.DescriptionUpdater();
-        this.skillGenerator = new skill_generator_1.SkillGenerator();
         logger.info('Adaptive Documentation Bot initialized', {
             autoUpdate: this.config.autoUpdate,
             updateInterval: this.config.updateInterval,
@@ -314,12 +311,7 @@ Return ONLY valid JSON, no other text.`;
                 await this.descriptionUpdater.updateParameterDescription(toolName, analysis.affectedParameter, paramImproved, analysis.problem);
             }
         }
-        // 3. Create/update skill if needed
-        if (this.config.skillGeneration && analysis.needsSkill) {
-            await this.skillGenerator.updateOrCreateSkill(toolName, pattern, analysis.incorrectUsage || pattern.examples[0].attemptedCall, analysis.correctUsage || {});
-            // Update skill summary
-            await this.skillGenerator.updateSkillSummary(toolName);
-        }
+        // 3. Skill generation disabled (skills moved to docs/)
         logger.info('✅ Improvements applied', {
             tool: toolName,
             descriptionUpdated: analysis.isDescriptionIssue,
@@ -426,8 +418,7 @@ Return ONLY the improved description text.`;
         return {
             monitoring: this.isMonitoring,
             errorPatterns: this.errorPatterns.size,
-            improvements: this.descriptionUpdater.getStats(),
-            skills: this.skillGenerator.getStats()
+            improvements: this.descriptionUpdater.getStats()
         };
     }
     /**
@@ -452,15 +443,13 @@ Return ONLY the improved description text.`;
         for (const pattern of this.errorPatterns.values()) {
             if (pattern.count >= this.config.minErrorCount && !pattern.suggestedFix) {
                 const toolName = pattern.examples[0].toolName;
-                // Check if existing skill exists
-                const existingSkill = await this.skillGenerator['findExistingSkill'](toolName);
                 suggestions.push({
                     toolName,
                     errorCount: pattern.count,
                     errorMessage: pattern.examples[0].errorMessage,
-                    existingSkill: existingSkill?.name,
-                    wouldCreateSkill: !existingSkill,
-                    wouldUpdateSkill: !!existingSkill
+                    existingSkill: undefined,
+                    wouldCreateSkill: false,
+                    wouldUpdateSkill: false
                 });
             }
         }

package/dist/client/message-processor.js

@@ -201,6 +201,11 @@ class HailerMessageProcessor {
     async extractFromMessengerNew(signal) {
         try {
             const { discussion, msg_id, uid } = signal.data;
+            // Validate required fields
+            if (!uid || !discussion) {
+                console.warn("❌ MCP Client: Missing uid or discussion in messenger.new signal");
+                return [];
+            }
             // IMPORTANT: Ignore messages from our own bots to prevent loops
             if (this.mcpAgentIds.includes(uid)) {
                 console.log(`🔇 MCP Client: Ignoring message from bot ${uid} (preventing self-trigger loop)`);

package/dist/client/providers/anthropic-provider.js

@@ -118,10 +118,16 @@ class AnthropicProvider extends llm_provider_1.LlmProvider {
                     error: `Initial prompt too long: ${initialTokenCount.totalTokens} tokens exceeds safe limit of ${initialTokenCount.limit.safeTokens} tokens`,
                 };
             }
-            let response = await this.client.messages.create({
+            // Enable structured outputs with strict mode for schema validation
+            const strictTools = minimalTools.map(tool => ({
+                ...tool,
+                strict: true
+            }));
+            let response = await this.client.beta.messages.create({
                 model: this.config.model || "claude-sonnet-4-20250514",
                 max_tokens: this.config.maxTokens || 2000,
                 temperature: this.config.temperature || 0.7,
+                betas: ['structured-outputs-2025-11-13'],
                 system: [
                     {
                         type: "text",
@@ -135,7 +141,7 @@ class AnthropicProvider extends llm_provider_1.LlmProvider {
                         content: finalUserContent,
                     },
                 ],
-                tools: minimalTools,
+                tools: strictTools,
             });
             const toolCalls = [];
             // No conversation history - process each message independently
@@ -376,10 +382,16 @@ class AnthropicProvider extends llm_provider_1.LlmProvider {
                         }
                     }
                     // Make API call with potentially summarized messages and optimized tools
-                    response = await this.client.messages.create({
+                    // Add strict mode for structured outputs
+                    const strictOptimizedTools = optimizedTools.map(tool => ({
+                        ...tool,
+                        strict: true
+                    }));
+                    response = await this.client.beta.messages.create({
                         model: this.config.model || "claude-sonnet-4-20250514",
                         max_tokens: this.config.maxTokens || 2000,
                         temperature: this.config.temperature || 0.7,
+                        betas: ['structured-outputs-2025-11-13'],
                         system: [
                             {
                                 type: "text",
@@ -388,7 +400,7 @@ class AnthropicProvider extends llm_provider_1.LlmProvider {
                             }
                         ],
                         messages: messagesToSend,
-                        tools: optimizedTools,
+                        tools: strictOptimizedTools,
                     });
                     // Accumulate tokens from this API call
                     if (response.usage) {
@@ -445,11 +457,12 @@ class AnthropicProvider extends llm_provider_1.LlmProvider {
                         // Continue with truncated messages as fallback
                     }
                 }
-                // Make final call without tools
-                response = await this.client.messages.create({
+                // Make final call without tools (no strict mode needed - no tools)
+                response = await this.client.beta.messages.create({
                     model: this.config.model || "claude-sonnet-4-20250514",
                     max_tokens: this.config.maxTokens || 2000,
                     temperature: this.config.temperature || 0.7,
+                    betas: ['structured-outputs-2025-11-13'],
                     system: [
                         {
                             type: "text",
@@ -567,7 +580,7 @@ class AnthropicProvider extends llm_provider_1.LlmProvider {
         if (jsonData.error) {
             throw new Error(`MCP tool schema error: ${jsonData.error.message || jsonData.error}`);
         }
-        // Convert MCP tool format to Anthropic tool format
+        // Convert MCP tool format to Anthropic tool format with strict mode
         const toolSchema = {
             name: jsonData.result.name,
             description: jsonData.result.description || `Tool: ${jsonData.result.name}`,
@@ -576,6 +589,7 @@ class AnthropicProvider extends llm_provider_1.LlmProvider {
                 properties: {},
                 required: [],
             },
+            strict: true, // Enable structured outputs validation
         };
         // Cache the schema
         this.toolSchemaCache.set(cacheKey, toolSchema);

package/dist/mcp/UserContextCache.d.ts

@@ -8,6 +8,8 @@ export interface UserContext {
     workspaceCache: WorkspaceCache;
     apiKey: string;
     createdAt: number;
+    email: string;
+    password: string;
 }
 /**
  * Cache for user-specific data (client connections, init data, workspace cache)
@@ -16,20 +18,32 @@ export interface UserContext {
  * - Reuses shared connection pool from hailer-clients.ts
  * - Caches user-specific data (init, workspaceCache) separately from tool logic
  * - Used by both MCP Server and Client for consistent user context
+ * - Uses Promise memoization to prevent duplicate context creation on concurrent requests
  */
 export declare class UserContextCache {
     private static cache;
+    /** Pending context creation promises - prevents race conditions on concurrent requests */
+    private static pending;
     /** Life of each cache unit. */
     private static readonly DEFAULT_TTL_MS;
     /**
      * Get or create user context (client, init, workspaceCache) for an API key
      * This data is user-specific and should be cached per user
      *
+     * Uses Promise memoization to prevent race conditions: if multiple requests
+     * come in for the same API key simultaneously, they all wait for the same
+     * Promise instead of creating duplicate connections.
+     *
      * @param apiKey - Hailer API key for authentication
      * @param forceRefresh - If true, bypasses cache and creates fresh context (useful for testing or after permission changes)
      * @param ttlMs - Custom TTL in milliseconds, defaults to 15 minutes
      */
     static getContext(apiKey: string, forceRefresh?: boolean, ttlMs?: number): Promise<UserContext>;
+    /**
+     * Internal method that actually creates the context.
+     * Separated from getContext to support Promise memoization.
+     */
+    private static createContextInternal;
     /**
      * Clear cache entry for specific API key (for cleanup/testing)
      */

package/dist/mcp/UserContextCache.js

@@ -14,21 +14,33 @@ const logger = (0, logger_1.createLogger)({ component: 'user-context-cache' });
  * - Reuses shared connection pool from hailer-clients.ts
  * - Caches user-specific data (init, workspaceCache) separately from tool logic
  * - Used by both MCP Server and Client for consistent user context
+ * - Uses Promise memoization to prevent duplicate context creation on concurrent requests
  */
 class UserContextCache {
     static cache = new Map();
+    /** Pending context creation promises - prevents race conditions on concurrent requests */
+    static pending = new Map();
     /** Life of each cache unit. */
     static DEFAULT_TTL_MS = 15 * 60 * 1000; // 15 minutes
     /**
      * Get or create user context (client, init, workspaceCache) for an API key
      * This data is user-specific and should be cached per user
      *
+     * Uses Promise memoization to prevent race conditions: if multiple requests
+     * come in for the same API key simultaneously, they all wait for the same
+     * Promise instead of creating duplicate connections.
+     *
      * @param apiKey - Hailer API key for authentication
      * @param forceRefresh - If true, bypasses cache and creates fresh context (useful for testing or after permission changes)
      * @param ttlMs - Custom TTL in milliseconds, defaults to 15 minutes
      */
     static async getContext(apiKey, forceRefresh = false, ttlMs = this.DEFAULT_TTL_MS) {
-        console.log(`🔍 getContext called: apiKey=${apiKey.substring(0, 8)}..., forceRefresh=${forceRefresh}, cacheHas=${this.cache.has(apiKey)}`);
+        logger.debug('getContext called', {
+            apiKey: apiKey.substring(0, 8) + '...',
+            forceRefresh,
+            inCache: this.cache.has(apiKey),
+            isPending: this.pending.has(apiKey)
+        });
         // Check cache first (unless forceRefresh is requested)
         if (!forceRefresh && this.cache.has(apiKey)) {
             const cachedContext = this.cache.get(apiKey);
@@ -58,6 +70,31 @@ class UserContextCache {
                 apiKey: apiKey.substring(0, 8) + '...'
             });
         }
+        // Check if context creation is already in progress (prevents race condition)
+        if (!forceRefresh && this.pending.has(apiKey)) {
+            logger.debug('Waiting for pending context creation', {
+                apiKey: apiKey.substring(0, 8) + '...'
+            });
+            return this.pending.get(apiKey);
+        }
+        // Create the context and store the Promise immediately to prevent duplicates
+        const contextPromise = this.createContextInternal(apiKey);
+        this.pending.set(apiKey, contextPromise);
+        try {
+            const context = await contextPromise;
+            this.cache.set(apiKey, context);
+            return context;
+        }
+        finally {
+            // Always clean up pending entry
+            this.pending.delete(apiKey);
+        }
+    }
+    /**
+     * Internal method that actually creates the context.
+     * Separated from getContext to support Promise memoization.
+     */
+    static async createContextInternal(apiKey) {
         logger.info('Creating new user context', { apiKey: apiKey.substring(0, 8) + '...' });
         try {
             // Create client connection (uses existing connection pool)
@@ -69,45 +106,33 @@ class UserContextCache {
                 ['processes', 'users', 'network', 'networks']
             ]);
             // Create workspace cache from init data
-            const appConfig = (0, config_1.createApplicationConfig)(); // TODO: small concern here: it creates a new instance of config instaed of reusing it, is it wise?
+            const appConfig = (0, config_1.createApplicationConfig)();
             const workspaceCache = (0, workspace_cache_1.createWorkspaceCache)(init, appConfig.mcpConfig);
+            // Get credentials from config (for tools like publish_hailer_app that need external auth)
+            const accountConfig = appConfig.getClientConfig(apiKey);
             const context = {
                 client,
                 hailer,
                 init,
                 workspaceCache,
                 apiKey,
-                createdAt: Date.now()
+                createdAt: Date.now(),
+                email: accountConfig.email,
+                password: accountConfig.password,
             };
-            // Calculate cache sizes
+            // Calculate and log cache sizes
             const rawInitSize = Buffer.byteLength(JSON.stringify(init), 'utf8');
             const workspaceCacheSize = Buffer.byteLength(JSON.stringify(workspaceCache), 'utf8');
-            const totalContextSize = Buffer.byteLength(JSON.stringify({
-                init,
-                workspaceCache
-            }), 'utf8');
-            // Log cache sizes to console
-            console.log('\n📊 === WORKSPACE CACHE SIZE ANALYSIS ===');
-            console.log(`Raw init response: ${rawInitSize.toLocaleString()} bytes (${(rawInitSize / 1024).toFixed(2)} KB)`);
-            console.log(`Workspace cache:   ${workspaceCacheSize.toLocaleString()} bytes (${(workspaceCacheSize / 1024).toFixed(2)} KB)`);
-            console.log(`Total context:     ${totalContextSize.toLocaleString()} bytes (${(totalContextSize / 1024).toFixed(2)} KB)`);
-            console.log(`Reduction:         ${((1 - workspaceCacheSize / rawInitSize) * 100).toFixed(1)}%`);
-            console.log(`Workflows:         ${init.processes?.length || 0}`);
-            console.log(`Users:             ${workspaceCache.users.length}`);
-            console.log(`Workspaces:        ${Object.keys(workspaceCache.allWorkspaces).length}`);
-            console.log('=====================================\n');
-            // Cache for future requests
-            this.cache.set(apiKey, context);
+            const totalContextSize = Buffer.byteLength(JSON.stringify({ init, workspaceCache }), 'utf8');
             logger.info('User context created and cached', {
                 apiKey: apiKey.substring(0, 8) + '...',
                 workflowCount: init.processes?.length || 0,
                 userCount: workspaceCache.users.length,
-                rawInitBytes: rawInitSize,
-                workspaceCacheBytes: workspaceCacheSize,
-                totalContextBytes: totalContextSize,
+                workspaceCount: Object.keys(workspaceCache.allWorkspaces).length,
                 rawInitKB: (rawInitSize / 1024).toFixed(2),
                 workspaceCacheKB: (workspaceCacheSize / 1024).toFixed(2),
-                totalContextKB: (totalContextSize / 1024).toFixed(2)
+                totalContextKB: (totalContextSize / 1024).toFixed(2),
+                reductionPercent: ((1 - workspaceCacheSize / rawInitSize) * 100).toFixed(1)
             });
             return context;
         }

package/dist/mcp/auth.d.ts

@@ -1,2 +1,9 @@
+/**
+ * Custom fetch function that handles self-signed certificates in development.
+ *
+ * SECURITY: TLS bypass is only enabled when BOTH conditions are met:
+ * 1. NODE_ENV is explicitly set to 'development'
+ * 2. URL is a local development URL (localhost, 127.0.0.1, or *.local.gd)
+ */
 export declare const safeFetch: (url: string, options?: RequestInit) => Promise<Response>;
 //# sourceMappingURL=auth.d.ts.map

package/dist/mcp/auth.js

@@ -1,12 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.safeFetch = void 0;
-// Custom fetch function that handles self-signed certificates
+/**
+ * Custom fetch function that handles self-signed certificates in development.
+ *
+ * SECURITY: TLS bypass is only enabled when BOTH conditions are met:
+ * 1. NODE_ENV is explicitly set to 'development'
+ * 2. URL is a local development URL (localhost, 127.0.0.1, or *.local.gd)
+ */
 const safeFetch = async (url, options = {}) => {
-    const isLocalDev = url.includes('local.gd') || url.includes('localhost');
-    if (isLocalDev) {
-        // For Next.js/Node.js environment with self-signed certs
-        // We need to set the environment variable before making the request
+    const isDevelopment = process.env.NODE_ENV === 'development';
+    const isLocalUrl = url.startsWith('https://localhost') ||
+        url.startsWith('https://127.0.0.1') ||
+        url.includes('.local.gd');
+    if (isDevelopment && isLocalUrl) {
+        // For Node.js environment with self-signed certs in local development
         const originalValue = process.env.NODE_TLS_REJECT_UNAUTHORIZED;
         process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
         try {

package/dist/mcp/hailer-clients.d.ts

@@ -1,4 +1,5 @@
 import { Client } from "@hailer/cli";
+import { SignalType } from './utils/types';
 export interface HailerRestClient {
     fetch: (url: string, options?: RequestInit) => Promise<Response>;
     sessionKey: string;
@@ -13,6 +14,8 @@ export interface HailerClient {
  * This is called after authentication to retrieve the user ID automatically
  */
 export declare function getCurrentUserId(client: HailerClient): Promise<string>;
+/** Signal handler callback type */
+export type SignalHandler = (data: Record<string, unknown>) => void;
 /** Hailer Client for a specific account with listeners and basic handling logic */
 export declare class HailerClientManager {
     private host;
@@ -24,8 +27,8 @@ export declare class HailerClientManager {
     constructor(host: string, username: string, password: string);
     connect(): Promise<HailerClient>;
     private setupSignalHandling;
-    onSignal(eventType: string, handler: (data: any) => void): void;
-    offSignal(eventType: string, handler: (data: any) => void): void;
+    onSignal(eventType: SignalType | string, handler: SignalHandler): void;
+    offSignal(eventType: SignalType | string, handler: SignalHandler): void;
     disconnect(): void;
     isConnected(): boolean;
     getClient(): HailerClient | null;

package/dist/mcp/signal-handler.d.ts

@@ -4,9 +4,33 @@ import { HailerClient } from './hailer-clients';
  * Signal types that Hailer emits via socket.io
  */
 export type HailerSignalType = 'activities.updated' | 'activities.created' | 'activities.deleted' | 'discussion.message' | 'messenger.new' | 'user.joined' | 'user.left' | 'workspace.updated' | 'process.updated' | 'cache.invalidate';
+/** Raw signal from Hailer socket - tuple of [eventType, eventData] */
+export type HailerSocketSignal = [string, Record<string, unknown>];
+/** Message object nested in signal data */
+export interface HailerSignalMessage {
+    _id?: string;
+    content?: string;
+    discussion?: string;
+    user?: string;
+    userName?: string;
+}
+/** Signal data varies by type - common fields for type narrowing */
+export interface HailerSignalData {
+    _id?: string;
+    id?: string;
+    discussionId?: string;
+    msg_id?: string;
+    content?: string;
+    user?: string;
+    userName?: string;
+    discussion?: string;
+    uid?: string;
+    message?: HailerSignalMessage;
+    [key: string]: unknown;
+}
 export interface HailerSignal {
     type: HailerSignalType;
-    data: any;
+    data: HailerSignalData;
     timestamp: number;
     workspaceId?: string;
 }
@@ -39,7 +63,9 @@ export declare class SignalHandler {
     getSignalHistory(types?: HailerSignalType[], limit?: number, workspaceId?: string): HailerSignal[];
     getActiveSubscriptions(): SignalSubscription[];
     clearHistory(): void;
-    createMcpSignalTools(server: any): void;
+    createMcpSignalTools(server: {
+        tool: (...args: unknown[]) => void;
+    }): void;
 }
 export declare const createSignalHandler: (clients: HailerClient, workspaceCache?: WorkspaceCache) => SignalHandler;
 //# sourceMappingURL=signal-handler.d.ts.map

package/dist/mcp/signal-handler.js

@@ -150,9 +150,10 @@ class SignalHandler {
                 });
             }
             if (init.users) {
-                this.workspaceCache.users = init.users;
+                // Store raw users in rawInit - the users array is derived from this
+                this.workspaceCache.rawInit.users = init.users;
                 logger.info('Users cache refreshed', {
-                    userCount: init.users.length
+                    userCount: Object.keys(init.users).length
                 });
             }
             if (init.network) {
@@ -218,6 +219,7 @@ class SignalHandler {
         logger.info('Signal history cleared', { previousHistorySize: previousCount });
     }
     // Utility methods for MCP integration
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- MCP server type from @modelcontextprotocol/sdk
     createMcpSignalTools(server) {
         // Add MCP tools for signal subscription management
         server.tool("subscribe_to_signals", "🔔 Subscribe to real-time Hailer signals - Get notified of activity updates, new messages, and workspace changes", {

package/dist/mcp/tool-registry.d.ts

@@ -3,9 +3,15 @@
  *
  * 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
  */
 import { z } from 'zod';
 import { UserContext } from './UserContextCache';
+import { McpResponse } from './utils/types';
 /**
  * Tool groups for access control
  * READ: Safe read operations (workflows, activities, schemas)
@@ -27,7 +33,7 @@ export interface Tool<TSchema extends z.ZodType = z.ZodType> {
     group: ToolGroup;
     description: string;
     schema: TSchema;
-    execute: (args: z.infer<TSchema>, context: UserContext) => Promise<any>;
+    execute: (args: z.infer<TSchema>, context: UserContext) => Promise<McpResponse>;
 }
 /**
  * Tool definition for MCP protocol (JSON-RPC)
@@ -41,13 +47,33 @@ export interface ToolDefinition {
  * 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.
  */
 export declare class ToolRegistry {
     private tools;
     private enableNuclearTools;
+    private workspaceSchemas;
+    private workspaceSchemasLoaded;
+    private static readonly TOOL_TO_SCHEMA_MAP;
     constructor(options?: {
         enableNuclearTools?: boolean;
     });
+    /**
+     * Load workspace-specific schemas from configured path
+     * Schemas provide enum constraints for Claude's strict mode
+     */
+    private loadWorkspaceSchemas;
+    /**
+     * Get workspace schema for a workflow (if available)
+     */
+    getWorkspaceSchema(workflowName: string): any | null;
+    /**
+     * Check if workspace schemas are available
+     */
+    hasWorkspaceSchemas(): boolean;
     /**
      * Add a tool to the registry
      */
@@ -66,8 +92,17 @@ export declare class ToolRegistry {
     /**
      * 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: string, workflowName?: string): ToolDefinition | null;
+    /**
+     * Get all workflow-specific tool schemas
+     * Returns schemas with enum constraints for each workflow
      */
-    getToolSchema(toolName: string): ToolDefinition | null;
+    getAllWorkflowSchemas(): Map<string, ToolDefinition>;
     /**
      * Execute tool with validation
      */
@@ -87,7 +122,25 @@ export declare class ToolRegistry {
         totalTools: number;
         toolNames: string[];
         byGroup: Record<ToolGroup, number>;
+        workspaceSchemas: {
+            loaded: boolean;
+            count: number;
+            workflows: string[];
+        };
     };
+    /**
+     * Get all available workspace schemas (for listing available workflows)
+     */
+    getAvailableWorkflowSchemas(): Array<{
+        name: string;
+        workflowId: string;
+        description: string;
+    }>;
+    /**
+     * Get workflow-specific create tool definition
+     * Returns schema with enum constraints for valid phase IDs, field options, etc.
+     */
+    getWorkflowCreateToolDefinition(workflowName: string): ToolDefinition | null;
     /**
      * Convert Zod schema to JSON Schema format (required by MCP protocol)
      */