miadi 1.0.14

package/src/tool-registry.ts

@@ -0,0 +1,223 @@
+/**
+ * Tool Registry System for Miadi MCP Server
+ * 
+ * Provides environment variable-based tool selection to allow selective exposure
+ * of MCP tools based on deployment requirements, security constraints, and use cases.
+ */
+
+import { z } from "zod";
+
+/**
+ * Definition of a tool that can be registered with the MCP server
+ */
+export interface ToolDefinition {
+  name: string;
+  category: string;
+  description: string;
+  schema: Record<string, z.ZodType<any>>;
+  handler: (args: any) => Promise<any>;
+  dependencies?: string[];
+}
+
+/**
+ * Configuration for tool registry behavior
+ */
+export interface ToolRegistryConfig {
+  enabledCategories?: string[];
+  enabledTools?: string[];
+  disabledCategories?: string[];
+  disabledTools?: string[];
+  defaultEnabled?: boolean;
+}
+
+/**
+ * Category mappings for tool organization
+ */
+export const TOOL_CATEGORIES = {
+  memory: [
+    'miadi-get-memory', 'miadi-store-memory', 'miadi-update-memory-ttl',
+    'miadi-get-memory-meta', 'miadi-scan-keys', 'miadi-gather-memory-values',
+    'miadi-collect-memory', 'miadi-view-key-content', 'miadi-search-cluster'
+  ],
+  session: [
+    'miadi-start-session', 'miadi-get-current-session', 'miadi-switch-mode',
+    'miadi-switch-persona', 'miadi-end-session', 'miadi-list-sessions'
+  ],
+  capability: [
+    'miadi-resolve-capabilities', 'miadi-get-agent-info', 'miadi-detect-cues'
+  ],
+  ai: ['miadi-openai-request', 'miadi-ai-request'],
+  workflow: [
+    'miadi-register-agent', 'miadi-get-agent-events', 'miadi-get-workflow-howto'
+  ],
+  forge: [
+    'miadi-get-forge-state', 'miadi-update-forge-state', 'miadi-get-glyph-map'
+  ]
+};
+
+/**
+ * Registry for managing MCP tool registration with environment-based selection
+ */
+export class ToolRegistry {
+  private tools: Map<string, ToolDefinition> = new Map();
+  private config: ToolRegistryConfig;
+
+  constructor(config: ToolRegistryConfig) {
+    this.config = config;
+    this.validateConfig();
+  }
+
+  /**
+   * Register a tool with the registry
+   */
+  register(tool: ToolDefinition): void {
+    this.tools.set(tool.name, tool);
+  }
+
+  /**
+   * Check if a specific tool should be enabled based on configuration
+   */
+  isToolEnabled(toolName: string): boolean {
+    const tool = this.tools.get(toolName);
+    if (!tool) return false;
+
+    // Check category-level enablement
+    const categoryEnabled = this.isCategoryEnabled(tool.category);
+    const toolSpecificallyDisabled = this.config.disabledTools?.includes(toolName);
+    const toolSpecificallyEnabled = this.config.enabledTools?.includes(toolName);
+
+    // Priority: specific tool settings > category settings > default
+    if (toolSpecificallyEnabled) return true;
+    if (toolSpecificallyDisabled) return false;
+    return categoryEnabled;
+  }
+
+  /**
+   * Check if a category should be enabled based on configuration
+   */
+  private isCategoryEnabled(category: string): boolean {
+    // If specific tools are enabled but no categories are specified,
+    // default to false for category-based enablement
+    if (this.config.enabledTools && !this.config.enabledCategories) {
+      return false;
+    }
+    
+    if (this.config.enabledCategories) {
+      return this.config.enabledCategories.includes(category);
+    }
+    if (this.config.disabledCategories) {
+      return !this.config.disabledCategories.includes(category);
+    }
+    return this.config.defaultEnabled ?? true;
+  }
+
+  /**
+   * Get all enabled tools
+   */
+  getEnabledTools(): ToolDefinition[] {
+    return Array.from(this.tools.values()).filter(tool => 
+      this.isToolEnabled(tool.name)
+    );
+  }
+
+  /**
+   * Get all registered tools (regardless of enabled status)
+   */
+  getAllTools(): ToolDefinition[] {
+    return Array.from(this.tools.values());
+  }
+
+  /**
+   * Validate the registry configuration
+   */
+  validateConfig(): void {
+    const validCategories = Object.keys(TOOL_CATEGORIES);
+    
+    const checkCategories = (categories?: string[], context: string = '') => {
+      categories?.forEach(cat => {
+        if (!validCategories.includes(cat)) {
+          console.error(`⚠️  Unknown category in ${context}: ${cat}`);
+          console.error(`   Valid categories: ${validCategories.join(', ')}`);
+        }
+      });
+    };
+
+    checkCategories(this.config.enabledCategories, 'enabledCategories');
+    checkCategories(this.config.disabledCategories, 'disabledCategories');
+
+    // Check for conflicting configuration
+    if (this.config.enabledCategories && this.config.disabledCategories) {
+      const conflict = this.config.enabledCategories.find(cat => 
+        this.config.disabledCategories?.includes(cat)
+      );
+      if (conflict) {
+        console.error(`⚠️  Category '${conflict}' is both enabled and disabled`);
+      }
+    }
+  }
+
+  /**
+   * Register all enabled tools with the MCP server
+   */
+  registerAllEnabledTools(server: any): void {
+    const enabledTools = this.getEnabledTools();
+    const totalTools = this.tools.size;
+    
+    console.error(`🔧 Tool Registry Configuration:`);
+    console.error(`   Total tools available: ${totalTools}`);
+    console.error(`   Tools to register: ${enabledTools.length}`);
+    
+    if (enabledTools.length < totalTools) {
+      const disabledCount = totalTools - enabledTools.length;
+      console.error(`   Tools disabled: ${disabledCount}`);
+    }
+
+    // Group enabled tools by category for logging
+    const enabledByCategory: Record<string, string[]> = {};
+    enabledTools.forEach(tool => {
+      if (!enabledByCategory[tool.category]) {
+        enabledByCategory[tool.category] = [];
+      }
+      enabledByCategory[tool.category].push(tool.name);
+    });
+
+    console.error(`📋 Enabled tool categories:`);
+    Object.entries(enabledByCategory).forEach(([category, tools]) => {
+      console.error(`   ${category}: ${tools.length} tools`);
+    });
+    
+    enabledTools.forEach(tool => {
+      server.tool(tool.name, tool.description, tool.schema, tool.handler);
+    });
+
+    console.error(`✅ ${enabledTools.length} tools registered successfully`);
+  }
+
+  /**
+   * Get configuration summary for debugging
+   */
+  getConfigSummary(): string {
+    const lines = ['Tool Registry Configuration:'];
+    
+    if (this.config.enabledCategories) {
+      lines.push(`  Enabled Categories: ${this.config.enabledCategories.join(', ')}`);
+    }
+    if (this.config.disabledCategories) {
+      lines.push(`  Disabled Categories: ${this.config.disabledCategories.join(', ')}`);
+    }
+    if (this.config.enabledTools) {
+      lines.push(`  Enabled Tools: ${this.config.enabledTools.join(', ')}`);
+    }
+    if (this.config.disabledTools) {
+      lines.push(`  Disabled Tools: ${this.config.disabledTools.join(', ')}`);
+    }
+    
+    lines.push(`  Default Enabled: ${this.config.defaultEnabled ?? true}`);
+    
+    const enabledCount = this.getEnabledTools().length;
+    const totalCount = this.tools.size;
+    lines.push(`  Result: ${enabledCount}/${totalCount} tools enabled`);
+    
+    return lines.join('\n');
+  }
+}

package/src/tools/ai-tools.ts

@@ -0,0 +1,69 @@
+import { miadiApi } from '../api-client';
+import {
+  OpenAIRequest,
+  OpenAIResponse,
+  AIRequest,
+  AIResponse
+} from '../types';
+
+export const aiTools = {
+  /**
+   * Make a request to OpenAI API through Miadi system
+   */
+  openaiRequest: async (
+    prompt: string,
+    modelId?: string,
+    maxTokens?: number,
+    temperature?: number,
+    stream?: boolean
+  ): Promise<OpenAIResponse> => {
+    try {
+      if (!prompt) {
+        throw new Error('Prompt is required');
+      }
+
+      const requestBody: OpenAIRequest = {
+        prompt
+      };
+
+      if (modelId) requestBody.modelId = modelId;
+      if (maxTokens !== undefined) requestBody.maxTokens = maxTokens;
+      if (temperature !== undefined) requestBody.temperature = temperature;
+      if (stream !== undefined) requestBody.stream = stream;
+
+      return await miadiApi.openaiRequest(requestBody);
+    } catch (error: any) {
+      throw new Error(`Failed to make OpenAI request: ${error.message}`);
+    }
+  },
+
+  /**
+   * Make a generic AI request through Miadi system
+   */
+  aiRequest: async (
+    prompt: string,
+    modelId?: string,
+    maxTokens?: number,
+    temperature?: number
+  ): Promise<AIResponse> => {
+    try {
+      if (!prompt) {
+        throw new Error('Prompt is required');
+      }
+
+      const requestBody: AIRequest = {
+        prompt
+      };
+
+      if (modelId) requestBody.modelId = modelId;
+      if (maxTokens !== undefined) requestBody.maxTokens = maxTokens;
+      if (temperature !== undefined) requestBody.temperature = temperature;
+
+      return await miadiApi.aiRequest(requestBody);
+    } catch (error: any) {
+      throw new Error(`Failed to make AI request: ${error.message}`);
+    }
+  }
+};
+
+export default aiTools;

package/src/tools/capability-tools.ts

@@ -0,0 +1,79 @@
+import { miadiApi } from '../api-client';
+import {
+  CapabilityResolveRequest,
+  CapabilityResolveResponse,
+  AgentInfoResponse,
+  CueDetectRequest,
+  CueDetectResponse,
+  ContextVariable,
+  AgentSession
+} from '../types';
+
+export const capabilityTools = {
+  /**
+   * Resolve capabilities for persona/mode combination
+   */
+  resolveCapabilities: async (
+    persona: string,
+    mode: string,
+    context?: ContextVariable[]
+  ): Promise<CapabilityResolveResponse> => {
+    try {
+      if (!persona || !mode) {
+        throw new Error('Persona and mode are required');
+      }
+
+      const requestBody: CapabilityResolveRequest = {
+        persona,
+        mode
+      };
+
+      if (context) requestBody.context = context;
+
+      return await miadiApi.resolveCapabilities(requestBody);
+    } catch (error: any) {
+      throw new Error(`Failed to resolve capabilities: ${error.message}`);
+    }
+  },
+
+  /**
+   * Get comprehensive agent system information
+   */
+  getAgentInfo: async (): Promise<AgentInfoResponse> => {
+    try {
+      return await miadiApi.getAgentInfo();
+    } catch (error: any) {
+      throw new Error(`Failed to get agent info: ${error.message}`);
+    }
+  },
+
+  /**
+   * Detect mode/persona switch cues from natural language text
+   */
+  detectCues: async (
+    text: string,
+    currentSession?: AgentSession,
+    availableModes?: string[],
+    availablePersonas?: string[]
+  ): Promise<CueDetectResponse> => {
+    try {
+      if (!text) {
+        throw new Error('Text is required for cue detection');
+      }
+
+      const requestBody: CueDetectRequest = {
+        text
+      };
+
+      if (currentSession) requestBody.currentSession = currentSession;
+      if (availableModes) requestBody.availableModes = availableModes;
+      if (availablePersonas) requestBody.availablePersonas = availablePersonas;
+
+      return await miadiApi.detectCues(requestBody);
+    } catch (error: any) {
+      throw new Error(`Failed to detect cues: ${error.message}`);
+    }
+  }
+};
+
+export default capabilityTools;

package/src/tools/forge-tools.ts

@@ -0,0 +1,51 @@
+import { miadiApi } from '../api-client';
+import {
+  ForgeStateRequest,
+  ForgeStateResponse,
+  ForgeStateUpdateResponse
+} from '../types';
+
+export const forgeTools = {
+  /**
+   * Get the current forge state
+   */
+  getForgeState: async (): Promise<ForgeStateResponse> => {
+    try {
+      return await miadiApi.getForgeState();
+    } catch (error: any) {
+      throw new Error(`Failed to get forge state: ${error.message}`);
+    }
+  },
+
+  /**
+   * Update the forge state (open/close)
+   */
+  updateForgeState: async (state: boolean): Promise<ForgeStateUpdateResponse> => {
+    try {
+      if (typeof state !== 'boolean') {
+        throw new Error('State must be a boolean value (true for open, false for closed)');
+      }
+
+      const requestBody: ForgeStateRequest = {
+        state
+      };
+
+      return await miadiApi.updateForgeState(requestBody);
+    } catch (error: any) {
+      throw new Error(`Failed to update forge state: ${error.message}`);
+    }
+  },
+
+  /**
+   * Get glyph map information
+   */
+  getGlyphMap: async (): Promise<any> => {
+    try {
+      return await miadiApi.getGlyphMap();
+    } catch (error: any) {
+      throw new Error(`Failed to get glyph map: ${error.message}`);
+    }
+  }
+};
+
+export default forgeTools;

package/src/tools/memory-tools.ts

@@ -0,0 +1,137 @@
+import { miadiApi } from '../api-client';
+import { GetMemoryResponse, StoreMemoryRequest, StoreMemoryResponse, ScanResponse, GatherMemoryResponse } from '../types';
+
+export const memoryTools = {
+  /**
+   * Retrieve memory data from Redis storage
+   */
+  getMemory: async (
+    key?: string,
+    list?: boolean,
+    pattern?: string,
+    type?: 'auto' | 'string' | 'hash' | 'list' | 'set' | 'zset'
+  ): Promise<GetMemoryResponse> => {
+    try {
+      return await miadiApi.getMemory(key, list, pattern, type);
+    } catch (error: any) {
+      throw new Error(`Failed to retrieve memory: ${error.message}`);
+    }
+  },
+
+  /**
+   * Store data in memory with optional TTL and type
+   */
+  storeMemory: async (
+    key: string,
+    value: string,
+    ttl?: number,
+    type?: 'string' | 'hash' | 'list'
+  ): Promise<StoreMemoryResponse> => {
+    try {
+      const requestBody: StoreMemoryRequest = { key, value };
+      if (ttl !== undefined) requestBody.ttl = ttl;
+      if (type) requestBody.type = type;
+      
+      return await miadiApi.storeMemory(requestBody);
+    } catch (error: any) {
+      throw new Error(`Failed to store memory: ${error.message}`);
+    }
+  },
+
+  /**
+   * Update TTL for an existing memory key
+   */
+  updateMemoryTTL: async (key: string, ttl: number): Promise<any> => {
+    try {
+      return await miadiApi.updateMemoryTTL(key, ttl);
+    } catch (error: any) {
+      throw new Error(`Failed to update memory TTL: ${error.message}`);
+    }
+  },
+
+  /**
+   * Get metadata for a memory key
+   */
+  getMemoryMeta: async (key: string): Promise<any> => {
+    try {
+      return await miadiApi.getMemoryMeta(key);
+    } catch (error: any) {
+      throw new Error(`Failed to get memory metadata: ${error.message}`);
+    }
+  },
+
+  /**
+   * Scan Redis keys using pattern matching or regex
+   */
+  scanKeys: async (
+    pattern?: string,
+    regex?: string,
+    limit?: number
+  ): Promise<ScanResponse> => {
+    try {
+      return await miadiApi.scanKeys(pattern, regex, limit);
+    } catch (error: any) {
+      throw new Error(`Failed to scan keys: ${error.message}`);
+    }
+  },
+
+  /**
+   * Gather memory values using pattern matching
+   */
+  gatherMemoryValues: async (
+    pattern?: string,
+    regex?: string,
+    limit?: number,
+    scanLimit?: number
+  ): Promise<GatherMemoryResponse> => {
+    try {
+      return await miadiApi.gatherMemoryValues(pattern, regex, limit, scanLimit);
+    } catch (error: any) {
+      throw new Error(`Failed to gather memory values: ${error.message}`);
+    }
+  },
+
+  /**
+   * Collect specific memory values by keys
+   */
+  collectMemory: async (keys: string[]): Promise<any> => {
+    try {
+      if (!keys || keys.length === 0) {
+        throw new Error('Keys array is required and cannot be empty');
+      }
+      return await miadiApi.collectMemory(keys);
+    } catch (error: any) {
+      throw new Error(`Failed to collect memory: ${error.message}`);
+    }
+  },
+
+  /**
+   * View key content for cluster operations
+   */
+  viewKeyContent: async (key: string): Promise<any> => {
+    try {
+      if (!key) {
+        throw new Error('Key is required');
+      }
+      return await miadiApi.viewKeyContent(key);
+    } catch (error: any) {
+      throw new Error(`Failed to view key content: ${error.message}`);
+    }
+  },
+
+  /**
+   * Search cluster for keys
+   */
+  searchCluster: async (term: string): Promise<{ keys: string[] }> => {
+    try {
+      if (!term) {
+        throw new Error('Search term is required');
+      }
+      return await miadiApi.searchCluster(term);
+    } catch (error: any) {
+      throw new Error(`Failed to search cluster: ${error.message}`);
+    }
+  }
+};
+
+export default memoryTools;

package/src/tools/session-tools.ts

@@ -0,0 +1,135 @@
+import { miadiApi } from '../api-client';
+import {
+  SessionStartRequest,
+  SessionStartResponse,
+  SessionCurrentResponse,
+  SessionSwitchModeRequest,
+  SessionSwitchPersonaRequest,
+  SessionListResponse,
+  ContextVariable
+} from '../types';
+
+export const sessionTools = {
+  /**
+   * Start a new agent session with specified persona and mode
+   */
+  startSession: async (
+    persona: string,
+    mode: string,
+    userId?: string,
+    contextOverrides?: ContextVariable[]
+  ): Promise<SessionStartResponse> => {
+    try {
+      if (!persona || !mode) {
+        throw new Error('Persona and mode are required');
+      }
+
+      const requestBody: SessionStartRequest = {
+        persona,
+        mode
+      };
+
+      if (userId) requestBody.userId = userId;
+      if (contextOverrides) requestBody.contextOverrides = contextOverrides;
+
+      return await miadiApi.startSession(requestBody);
+    } catch (error: any) {
+      throw new Error(`Failed to start session: ${error.message}`);
+    }
+  },
+
+  /**
+   * Get current session details
+   */
+  getCurrentSession: async (sessionId?: string): Promise<SessionCurrentResponse> => {
+    try {
+      return await miadiApi.getCurrentSession(sessionId);
+    } catch (error: any) {
+      throw new Error(`Failed to get current session: ${error.message}`);
+    }
+  },
+
+  /**
+   * Switch mode in an existing session
+   */
+  switchMode: async (
+    sessionId: string,
+    newMode: string,
+    contextOverrides?: ContextVariable[]
+  ): Promise<SessionCurrentResponse> => {
+    try {
+      if (!sessionId || !newMode) {
+        throw new Error('Session ID and new mode are required');
+      }
+
+      const requestBody: SessionSwitchModeRequest = {
+        sessionId,
+        newMode
+      };
+
+      if (contextOverrides) requestBody.contextOverrides = contextOverrides;
+
+      return await miadiApi.switchMode(requestBody);
+    } catch (error: any) {
+      throw new Error(`Failed to switch mode: ${error.message}`);
+    }
+  },
+
+  /**
+   * Switch persona in an existing session
+   */
+  switchPersona: async (
+    sessionId: string,
+    newPersona: string,
+    preserveMode?: boolean
+  ): Promise<SessionCurrentResponse> => {
+    try {
+      if (!sessionId || !newPersona) {
+        throw new Error('Session ID and new persona are required');
+      }
+
+      const requestBody: SessionSwitchPersonaRequest = {
+        sessionId,
+        newPersona
+      };
+
+      if (preserveMode !== undefined) requestBody.preserveMode = preserveMode;
+
+      return await miadiApi.switchPersona(requestBody);
+    } catch (error: any) {
+      throw new Error(`Failed to switch persona: ${error.message}`);
+    }
+  },
+
+  /**
+   * End an active session
+   */
+  endSession: async (sessionId: string): Promise<{ success: boolean; message: string; timestamp: string }> => {
+    try {
+      if (!sessionId) {
+        throw new Error('Session ID is required');
+      }
+
+      return await miadiApi.endSession(sessionId);
+    } catch (error: any) {
+      throw new Error(`Failed to end session: ${error.message}`);
+    }
+  },
+
+  /**
+   * List active sessions with optional filtering
+   */
+  listSessions: async (
+    userId?: string,
+    limit?: number,
+    offset?: number
+  ): Promise<SessionListResponse> => {
+    try {
+      return await miadiApi.listSessions(userId, limit, offset);
+    } catch (error: any) {
+      throw new Error(`Failed to list sessions: ${error.message}`);
+    }
+  }
+};
+
+export default sessionTools;