@ema.co/mcp-toolkit 0.2.0

package/dist/mcp/tools-consolidated.js

@@ -0,0 +1,590 @@
+/**
+ * Consolidated MCP Tools for Ema
+ *
+ * Follows Unix CLI patterns:
+ * - Single command with flags instead of separate get/list/create tools
+ * - Consistent terminology: "persona" (not mixed "ai_employee")
+ * - Mode flags for different operations on same resource
+ *
+ * ~45 tools → 9 commands:
+ * 1. env       - Environment listing
+ * 2. persona   - AI Employee management
+ * 3. workflow  - Workflow generation, analysis, deploy, optimize
+ * 4. action    - Actions/agents lookup
+ * 5. template  - Patterns, widgets, templates
+ * 6. knowledge - Data sources & embedding
+ * 7. reference - Platform concepts & guidance
+ * 8. sync      - Environment sync
+ * 9. demo      - Demo data utilities (RAG document generation)
+ */
+// Helper to add env parameter to schema
+function withEnvParam(props, required = [], envNames = [], defaultEnv = "demo") {
+    return {
+        type: "object",
+        properties: {
+            ...props,
+            env: {
+                type: "string",
+                description: `Target environment. Available: ${envNames.join(", ") || "demo, staging, dev"}. Default: ${defaultEnv}`,
+            },
+        },
+        required,
+    };
+}
+/**
+ * Generate consolidated tool definitions
+ */
+export function generateConsolidatedTools(envNames, defaultEnv) {
+    const withEnv = (props, required = []) => withEnvParam(props, required, envNames, defaultEnv);
+    return [
+        // ═══════════════════════════════════════════════════════════════════════
+        // 1. ENV - Environment listing (simplest tool)
+        // ═══════════════════════════════════════════════════════════════════════
+        {
+            name: "env",
+            description: "List available Ema environments. Shows which is default.",
+            inputSchema: { type: "object", properties: {}, required: [] },
+        },
+        // ═══════════════════════════════════════════════════════════════════════
+        // 2. PERSONA - AI Employee management (CRUD + compare)
+        // ═══════════════════════════════════════════════════════════════════════
+        {
+            name: "persona",
+            description: `Unified AI Employee (persona) management.
+
+**Get single** (default when id provided):
+  persona(id="IT Support Bot")
+  persona(id="abc-123", include_workflow=true)
+
+**List/Search** (when --all or filters used):
+  persona(all=true)
+  persona(query="support", status="active")
+  persona(trigger_type="voice")
+
+**Create**:
+  persona(mode="create", name="New Bot", type="voice")
+
+**Update**:
+  persona(id="abc-123", mode="update", name="Renamed")
+
+**Compare**:
+  persona(id="abc-123", mode="compare", compare_to="def-456")
+
+**Templates** (list available templates):
+  persona(templates=true)`,
+            inputSchema: withEnv({
+                // ID (or exact name) (optional - if omitted with all=true, lists all)
+                id: {
+                    type: "string",
+                    description: "Persona ID (UUID) or exact name. Omit for list operations."
+                },
+                // Deprecated alias (backwards compatibility)
+                identifier: {
+                    type: "string",
+                    deprecated: true,
+                    description: "DEPRECATED: use id. Persona ID (UUID) or exact name.",
+                },
+                // Mode (defaults to "get" if id provided, "list" if all=true)
+                mode: {
+                    type: "string",
+                    enum: ["get", "list", "create", "update", "compare"],
+                    description: "Operation mode. Default: 'get' with id, 'list' without."
+                },
+                // List/Search flags
+                all: { type: "boolean", description: "List all personas" },
+                query: { type: "string", description: "Search by name (partial match)" },
+                status: { type: "string", description: "Filter: 'active', 'inactive', 'draft'" },
+                trigger_type: { type: "string", description: "Filter: 'voice', 'chat', 'dashboard'" },
+                limit: { type: "number", description: "Max results (default: 50)" },
+                // Get flags
+                include_workflow: { type: "boolean", description: "Include full workflow_def" },
+                include_fingerprint: { type: "boolean", description: "Include config hash" },
+                // Create flags
+                name: { type: "string", description: "Name (for create/update)" },
+                description: { type: "string", description: "Description (for create/update)" },
+                type: {
+                    type: "string",
+                    enum: ["voice", "chat", "dashboard"],
+                    description: "Persona type (for create)"
+                },
+                template_id: { type: "string", description: "Template ID (for create)" },
+                clone_from: { type: "string", description: "Clone from persona ID (for create)" },
+                // Update flags
+                enabled: { type: "boolean", description: "Enable/disable (for update)" },
+                // Compare flags
+                compare_to: { type: "string", description: "Second persona ID (for compare)" },
+                compare_env: { type: "string", description: "Environment of compare_to persona" },
+                // Templates flag
+                templates: { type: "boolean", description: "List available templates" },
+            }),
+        },
+        // ═══════════════════════════════════════════════════════════════════════
+        // 3. WORKFLOW - Generation, analysis, deployment
+        // ═══════════════════════════════════════════════════════════════════════
+        {
+            name: "workflow",
+            description: `Unified workflow generation and analysis.
+
+**Greenfield** (NEW workflow from scratch):
+  workflow(input="IT helpdesk with KB search")
+  workflow(mode="generate", input="customer support bot")
+
+**Brownfield** (UPDATE existing workflow - auto-detected when persona_id + input provided):
+  workflow(persona_id="abc-123", input="add KB search capability")
+  workflow(persona_id="abc", input="add HITL approval for ticket creation")
+
+**Analyze** (inspect existing):
+  workflow(persona_id="abc-123")
+  workflow(persona_id="abc-123", mode="analyze")
+  workflow(workflow_def={...}, mode="analyze")
+
+**Deploy**:
+  workflow(persona_id="abc-123", mode="deploy", workflow_def={...})
+  workflow(persona_id="abc", mode="deploy", auto_fix=true)
+
+**Optimize** (analyze + fix + optional deploy):
+  workflow(persona_id="abc-123", mode="optimize")
+  workflow(persona_id="abc", mode="optimize", preview=true)
+
+**Compare**:
+  workflow(persona_id="abc", mode="compare", compare_to="def")
+
+**Compile** (from node spec):
+  workflow(mode="compile", name="...", description="...", nodes=[...], result_mappings=[...])`,
+            inputSchema: withEnv({
+                // Common metadata (primarily used for mode="compile")
+                name: { type: "string", description: "Workflow name (required for compile mode)" },
+                description: { type: "string", description: "Workflow description (required for compile mode)" },
+                // Input (one of these for generation)
+                input: {
+                    anyOf: [
+                        { type: "string", description: "Natural language description" },
+                        { type: "object", description: "Workflow intent/spec object" },
+                    ],
+                    description: "Natural language description OR workflow intent/spec object",
+                },
+                persona_id: {
+                    type: "string",
+                    description: "Persona ID for existing workflow operations"
+                },
+                workflow_def: {
+                    type: "object",
+                    description: "Workflow JSON for analysis or deployment"
+                },
+                // Mode
+                mode: {
+                    type: "string",
+                    enum: ["generate", "analyze", "deploy", "optimize", "compare", "compile"],
+                    description: "Operation mode. Default: 'generate' with input, 'analyze' with persona_id. Use 'optimize' for one-click fix & deploy."
+                },
+                // Optimize flags
+                preview: { type: "boolean", description: "Preview changes without deploying (for optimize mode)" },
+                // Generate flags
+                type: {
+                    type: "string",
+                    enum: ["voice", "chat", "dashboard"],
+                    description: "Persona type (default: chat)"
+                },
+                use_autobuilder: { type: "boolean", description: "Force Auto Builder API" },
+                // Analyze flags - what to include
+                include: {
+                    type: "array",
+                    items: { type: "string", enum: ["issues", "connections", "fixes", "metrics"] },
+                    description: "What to include in analysis. Default: all.",
+                },
+                // Deploy flags
+                auto_fix: { type: "boolean", description: "Auto-fix issues before deploy" },
+                validate: { type: "boolean", description: "Validate before deploy (default: true)" },
+                proto_config: { type: "object", description: "Persona config (voice settings, etc.)" },
+                // Compare flags
+                compare_to: { type: "string", description: "Second persona ID for comparison" },
+                // Compile flags (for mode="compile")
+                nodes: { type: "array", description: "Node definitions for compilation" },
+                result_mappings: { type: "array", description: "Output mappings for compilation" },
+            }),
+        },
+        // ═══════════════════════════════════════════════════════════════════════
+        // 4. ACTION - Actions/agents lookup (API + reference docs)
+        // ═══════════════════════════════════════════════════════════════════════
+        {
+            name: "action",
+            description: `Unified action/agent lookup. Gets live API data AND reference docs.
+
+**Get single**:
+  action(id="chat_categorizer")
+  action(id="abc-123-uuid")
+  action(id="search", include_docs=true)
+
+**List/Search**:
+  action(all=true)
+  action(category="routing")
+  action(query="search")
+  action(persona_id="abc")  # Actions in workflow
+
+**Suggest for use case**:
+  action(suggest="IT helpdesk with ticket creation")
+
+**Categories**:
+  action(categories=true)`,
+            inputSchema: withEnv({
+                // ID (or name)
+                id: {
+                    type: "string",
+                    description: "Action ID or name (e.g., 'chat_categorizer')"
+                },
+                // Deprecated alias (backwards compatibility)
+                identifier: {
+                    type: "string",
+                    deprecated: true,
+                    description: "DEPRECATED: use id. Action ID or name (e.g., 'chat_categorizer')",
+                },
+                // List/Search flags
+                all: { type: "boolean", description: "List all available actions" },
+                query: { type: "string", description: "Search by name" },
+                category: { type: "string", description: "Filter by category" },
+                persona_id: { type: "string", description: "List actions in this workflow" },
+                enabled: { type: "boolean", description: "Filter by enabled status" },
+                limit: { type: "number", description: "Max results" },
+                // Include flags
+                include_docs: { type: "boolean", description: "Include full documentation" },
+                // Suggest mode
+                suggest: { type: "string", description: "Get recommendations for use case" },
+                // List categories
+                categories: { type: "boolean", description: "List action categories" },
+            }),
+        },
+        // ═══════════════════════════════════════════════════════════════════════
+        // 5. TEMPLATE - Patterns, widgets, persona templates
+        // ═══════════════════════════════════════════════════════════════════════
+        {
+            name: "template",
+            description: `Get workflow patterns, widget references, and configuration templates.
+
+**Workflow patterns**:
+  template(pattern="intent-routing")
+  template(patterns=true)
+  template(patterns=true, type="voice")
+
+**Widget reference**:
+  template(widgets="voice")
+  template(widgets="chat")
+
+**Persona config template**:
+  template(config="voice")  # Voice AI settings template
+
+**Qualifying questions** (for requirements gathering):
+  template(questions=true)
+  template(questions=true, category="Voice")`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    // Workflow patterns
+                    pattern: {
+                        type: "string",
+                        enum: ["simple-kb-search", "intent-routing", "multi-source-search", "tool-calling", "hitl-approval", "document-processing", "guardrails-pattern"],
+                        description: "Get specific workflow pattern"
+                    },
+                    patterns: { type: "boolean", description: "List all workflow patterns" },
+                    // Widget reference
+                    widgets: {
+                        type: "string",
+                        enum: ["voice", "chat", "dashboard"],
+                        description: "Get widget reference for persona type"
+                    },
+                    // Persona config template
+                    config: {
+                        type: "string",
+                        enum: ["voice", "chat", "dashboard"],
+                        description: "Get config template (voice settings, etc.)"
+                    },
+                    // Qualifying questions
+                    questions: { type: "boolean", description: "Get qualifying questions" },
+                    category: {
+                        type: "string",
+                        enum: ["AI Type", "Intent", "Data", "Actions", "Validation", "Output", "Voice", "Guardrails"],
+                        description: "Filter questions by category"
+                    },
+                    required_only: { type: "boolean", description: "Only required questions" },
+                    // Filter
+                    type: {
+                        type: "string",
+                        enum: ["voice", "chat", "dashboard"],
+                        description: "Filter patterns by persona type"
+                    },
+                },
+                required: [],
+            },
+        },
+        // ═══════════════════════════════════════════════════════════════════════
+        // 6. KNOWLEDGE - Data sources & embedding management
+        // ═══════════════════════════════════════════════════════════════════════
+        {
+            name: "knowledge",
+            description: `Manage AI Employee knowledge base (data sources & embedding).
+
+**List files**:
+  knowledge(persona_id="abc-123")
+  knowledge(persona_id="abc", mode="list")
+
+**Upload file**:
+  knowledge(persona_id="abc", mode="upload", file="/path/to/doc.pdf")
+
+**Delete file**:
+  knowledge(persona_id="abc", mode="delete", file_id="file-123")
+
+**Embedding status**:
+  knowledge(persona_id="abc", mode="status")
+
+**Toggle embedding**:
+  knowledge(persona_id="abc", mode="toggle", enabled=true)`,
+            inputSchema: withEnv({
+                persona_id: { type: "string", description: "AI Employee ID (required)" },
+                mode: {
+                    type: "string",
+                    enum: ["list", "upload", "delete", "status", "toggle"],
+                    description: "Operation. Default: 'list'"
+                },
+                // Upload flags
+                file: { type: "string", description: "File path for upload" },
+                tags: { type: "string", description: "Tags for uploaded file" },
+                // Delete flags
+                file_id: { type: "string", description: "File ID to delete" },
+                // Toggle flags
+                enabled: { type: "boolean", description: "Enable/disable embedding" },
+            }, ["persona_id"]),
+        },
+        // ═══════════════════════════════════════════════════════════════════════
+        // 7. REFERENCE - Platform concepts, guidance, validation
+        // ═══════════════════════════════════════════════════════════════════════
+        {
+            name: "reference",
+            description: `Get platform documentation and validation tools.
+
+**Concepts**:
+  reference(concept="HITL")
+  reference(concepts=true)  # List all
+
+**Guidance**:
+  reference(guidance="categorizer-routing")
+  reference(guidance="type-compatibility")
+
+**Debugging**:
+  reference(mistakes=true)
+  reference(checklist=true)
+  reference(execution=true)  # Workflow execution model
+
+**Validation**:
+  reference(check_types={source: "CHAT_CONVERSATION", target: "TEXT_WITH_SOURCES"})
+  reference(validate_prompt="Create a bot...")`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    // Concepts
+                    concept: { type: "string", description: "Get definition of platform term" },
+                    concepts: { type: "boolean", description: "List all platform concepts" },
+                    // Guidance
+                    guidance: {
+                        type: "string",
+                        enum: [
+                            "categorizer-routing", "type-compatibility", "named-inputs",
+                            "hitl-patterns", "multi-source-search", "voice-tool-calling",
+                            "guardrails", "output-mapping", "workflow-execution", "conversation-vs-query"
+                        ],
+                        description: "Get guidance on topic"
+                    },
+                    // Debugging
+                    mistakes: { type: "boolean", description: "Get common mistakes list" },
+                    checklist: { type: "boolean", description: "Get debug checklist" },
+                    execution: { type: "boolean", description: "Get workflow execution model" },
+                    // Validation
+                    check_types: {
+                        type: "object",
+                        properties: {
+                            source: { type: "string", description: "Source output type" },
+                            target: { type: "string", description: "Target input type" },
+                        },
+                        description: "Check type compatibility"
+                    },
+                    validate_prompt: { type: "string", description: "Validate workflow prompt" },
+                },
+                required: [],
+            },
+        },
+        // ═══════════════════════════════════════════════════════════════════════
+        // 8. SYNC - Environment synchronization
+        // ═══════════════════════════════════════════════════════════════════════
+        {
+            name: "sync",
+            description: `Sync AI Employees across environments.
+
+**Sync single**:
+  sync(id="IT Support", target="dev")
+  sync(id="abc-123", target="staging", dry_run=true)
+
+**Sync all tagged**:
+  sync(target="dev", scope="all")
+
+**Status**:
+  sync(mode="status", id="abc-123")
+  sync(mode="status", list_synced=true)
+
+**Config**:
+  sync(mode="config")`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    // What to sync
+                    id: { type: "string", description: "Persona ID or name" },
+                    // Deprecated alias (backwards compatibility)
+                    identifier: { type: "string", deprecated: true, description: "DEPRECATED: use id. Persona ID or name" },
+                    // Mode
+                    mode: {
+                        type: "string",
+                        enum: ["run", "status", "config"],
+                        description: "Operation. Default: 'run'"
+                    },
+                    // Sync flags
+                    source: { type: "string", description: "Source environment (default: current)" },
+                    target: { type: "string", description: "Target environment (required for run)" },
+                    scope: {
+                        type: "string",
+                        enum: ["one", "all"],
+                        description: "Sync one or all tagged"
+                    },
+                    dry_run: { type: "boolean", description: "Simulate without changes" },
+                    include_status: { type: "boolean", description: "Also sync enabled/disabled" },
+                    // Status flags
+                    list_synced: { type: "boolean", description: "List all synced personas" },
+                    master_env: { type: "string", description: "Filter by master environment" },
+                    env: { type: "string", description: "Target environment for status queries" },
+                },
+                required: [],
+            },
+        },
+        // ═══════════════════════════════════════════════════════════════════════
+        // 9. DEMO - Demo data management (keep as separate concern)
+        // ═══════════════════════════════════════════════════════════════════════
+        {
+            name: "demo",
+            description: `Manage demo data for RAG knowledge bases.
+
+**Consolidate** (join JSON → Markdown):
+  demo(mode="consolidate", source="./data", output="./kb", entity="customer", primary="customers.json")
+
+**Generate single document**:
+  demo(mode="generate", entity="customer", data={...})
+
+**Validate document**:
+  demo(mode="validate", file="./kb/customer-acme.md")
+
+**Get template**:
+  demo(mode="template", entity="customer")`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    mode: {
+                        type: "string",
+                        enum: ["consolidate", "generate", "validate", "template"],
+                        description: "Operation"
+                    },
+                    // Consolidate flags
+                    source: { type: "string", description: "Source directory" },
+                    output: { type: "string", description: "Output directory" },
+                    primary: { type: "string", description: "Primary JSON file" },
+                    joins: {
+                        type: "array",
+                        description: "Files to join [{file, on, as}]"
+                    },
+                    // Entity type
+                    entity: {
+                        type: "string",
+                        enum: ["customer", "product", "employee", "scenario", "reference"],
+                        description: "Entity type"
+                    },
+                    // Generate flags
+                    data: { type: "object", description: "Entity data for generation" },
+                    related: { type: "object", description: "Related data to include" },
+                    // Validate flags
+                    file: { type: "string", description: "File path to validate" },
+                    content: { type: "string", description: "Content to validate" },
+                    // Common
+                    tags: { type: "string", description: "Tags for metadata" },
+                },
+                required: [],
+            },
+        },
+    ];
+}
+/**
+ * Tool name mapping for backward compatibility
+ * Maps old tool names to new consolidated tool + args
+ */
+export const LEGACY_TOOL_MAPPING = {
+    // Environment
+    list_environments: { tool: "env", transform: () => ({}) },
+    // Persona tools → persona
+    get_persona: { tool: "persona", transform: (a) => ({ ...a, mode: "get" }) },
+    find_personas: { tool: "persona", transform: (a) => ({ ...a, all: true }) },
+    create_ai_employee: { tool: "persona", transform: (a) => ({ ...a, mode: "create" }) },
+    update_ai_employee: { tool: "persona", transform: (a) => ({ ...a, mode: "update", id: a.persona_id }) },
+    compare_ai_employees: { tool: "persona", transform: (a) => ({ id: a.persona_id_1, mode: "compare", compare_to: a.persona_id_2, compare_env: a.env_2 }) },
+    list_ai_employee_templates: { tool: "persona", transform: () => ({ templates: true }) },
+    // Workflow tools → workflow
+    deploy_workflow: { tool: "workflow", transform: (a) => ({ ...a, mode: "deploy" }) },
+    optimize_workflow: { tool: "workflow", transform: (a) => ({ ...a, mode: "optimize", id: a.identifier }) },
+    compile_workflow: { tool: "workflow", transform: (a) => ({ ...a, mode: "compile" }) },
+    analyze_workflow: { tool: "workflow", transform: (a) => ({ ...a, mode: "analyze" }) },
+    detect_workflow_issues: { tool: "workflow", transform: (a) => ({ ...a, mode: "analyze" }) },
+    validate_workflow_connections: { tool: "workflow", transform: (a) => ({ ...a, mode: "analyze", include: ["connections"] }) },
+    suggest_workflow_fixes: { tool: "workflow", transform: (a) => ({ ...a, mode: "analyze", include: ["fixes"] }) },
+    compare_workflow_versions: { tool: "workflow", transform: (a) => ({ persona_id: a.persona_id_before, mode: "compare", compare_to: a.persona_id_after }) },
+    get_workflow_metrics: { tool: "workflow", transform: (a) => ({ ...a, mode: "analyze", include: ["metrics"] }) },
+    // Action tools → action
+    get_workflow_action: { tool: "action", transform: (a) => a },
+    find_workflow_actions: { tool: "action", transform: (a) => ({ ...a, all: true }) },
+    list_auto_builder_agents: { tool: "action", transform: (a) => ({ ...a, all: true, include_docs: true }) },
+    get_auto_builder_agent: { tool: "action", transform: (a) => ({ id: a.action_name, include_docs: true }) },
+    suggest_agents_for_use_case: { tool: "action", transform: (a) => ({ suggest: a.use_case }) },
+    // Template tools → template
+    get_workflow_pattern: { tool: "template", transform: (a) => ({ pattern: a.pattern_name }) },
+    list_workflow_patterns: { tool: "template", transform: (a) => ({ patterns: true, type: a.persona_type }) },
+    get_widget_reference: { tool: "template", transform: (a) => ({ widgets: a.persona_type }) },
+    get_voice_persona_template: { tool: "template", transform: () => ({ config: "voice" }) },
+    get_qualifying_questions: { tool: "template", transform: (a) => ({ questions: true, ...a }) },
+    // Knowledge tools → knowledge  
+    upload_data_source: { tool: "knowledge", transform: (a) => ({ ...a, mode: "upload", file: a.file_path }) },
+    delete_data_source: { tool: "knowledge", transform: (a) => ({ ...a, mode: "delete" }) },
+    list_data_sources: { tool: "knowledge", transform: (a) => ({ ...a, mode: "list" }) },
+    get_embedding_status: { tool: "knowledge", transform: (a) => ({ ...a, mode: "status" }) },
+    toggle_embedding: { tool: "knowledge", transform: (a) => ({ ...a, mode: "toggle" }) },
+    // Reference tools → reference
+    get_platform_concept: { tool: "reference", transform: (a) => ({ concept: a.term }) },
+    list_platform_concepts: { tool: "reference", transform: () => ({ concepts: true }) },
+    get_common_mistakes: { tool: "reference", transform: () => ({ mistakes: true }) },
+    get_debug_checklist: { tool: "reference", transform: () => ({ checklist: true }) },
+    get_workflow_execution_model: { tool: "reference", transform: () => ({ execution: true }) },
+    get_auto_builder_guidance: { tool: "reference", transform: (a) => ({ guidance: a.topic }) },
+    validate_workflow_prompt: { tool: "reference", transform: (a) => ({ validate_prompt: a.prompt }) },
+    check_type_compatibility: { tool: "reference", transform: (a) => ({ check_types: { source: a.source_type, target: a.target_type } }) },
+    // Demo data tools → demo
+    consolidate_demo_data: { tool: "demo", transform: (a) => ({ mode: "consolidate", source: a.source_dir, output: a.output_dir, ...a }) },
+    generate_demo_document: { tool: "demo", transform: (a) => ({ mode: "generate", ...a }) },
+    validate_demo_document: { tool: "demo", transform: (a) => ({ mode: "validate", file: a.file_path, content: a.content }) },
+    get_demo_data_template: { tool: "demo", transform: (a) => ({ mode: "template", entity: a.entity_type }) },
+};
+// Summary of consolidation
+export const CONSOLIDATION_SUMMARY = {
+    before: 45,
+    after: 9,
+    tools: [
+        { name: "env", replaces: ["list_environments"] },
+        { name: "persona", replaces: ["get_persona", "find_personas", "create_ai_employee", "update_ai_employee", "compare_ai_employees", "list_ai_employee_templates"] },
+        { name: "workflow", replaces: ["workflow", "deploy_workflow", "optimize_workflow", "compile_workflow", "analyze_workflow", "detect_workflow_issues", "validate_workflow_connections", "suggest_workflow_fixes", "compare_workflow_versions", "get_workflow_metrics"] },
+        { name: "action", replaces: ["get_workflow_action", "find_workflow_actions", "list_auto_builder_agents", "get_auto_builder_agent", "suggest_agents_for_use_case"] },
+        { name: "template", replaces: ["get_workflow_pattern", "list_workflow_patterns", "get_widget_reference", "get_voice_persona_template", "get_qualifying_questions"] },
+        { name: "knowledge", replaces: ["upload_data_source", "delete_data_source", "list_data_sources", "get_embedding_status", "toggle_embedding"] },
+        { name: "reference", replaces: ["get_platform_concept", "list_platform_concepts", "get_common_mistakes", "get_debug_checklist", "get_workflow_execution_model", "get_auto_builder_guidance", "validate_workflow_prompt", "check_type_compatibility"] },
+        { name: "sync", replaces: ["sync", "sync_info"] },
+        { name: "demo", replaces: ["consolidate_demo_data", "generate_demo_document", "validate_demo_document", "get_demo_data_template"] },
+    ],
+};