@chandshantanu/agentbuilder-mcp-server 0.2.0

package/dist/index.js

@@ -0,0 +1,2751 @@
+#!/usr/bin/env node
+/**
+ * AgentBuilder MCP Server
+ * Provides workflow creation and management tools for Claude Code
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import axios from 'axios';
+import * as http from 'http';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+const CREDENTIALS_PATH = path.join(os.homedir(), '.agentbuilder', 'credentials.json');
+const FRONTEND_URL = 'https://www.chatslytics.com';
+function loadStoredToken() {
+    try {
+        if (fs.existsSync(CREDENTIALS_PATH)) {
+            const creds = JSON.parse(fs.readFileSync(CREDENTIALS_PATH, 'utf-8'));
+            if (creds.token && creds.expires_at && Date.now() < creds.expires_at) {
+                return creds.token;
+            }
+        }
+    }
+    catch { }
+    return null;
+}
+function saveToken(token, expiresIn = 3600) {
+    const dir = path.dirname(CREDENTIALS_PATH);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(CREDENTIALS_PATH, JSON.stringify({
+        token,
+        expires_at: Date.now() + (expiresIn * 1000) - 60000, // 1 min buffer
+    }));
+}
+async function promptLogin() {
+    return new Promise((resolve, reject) => {
+        // Start local HTTP server to receive the token callback
+        const server = http.createServer((req, res) => {
+            // Allow CORS from the frontend
+            res.setHeader('Access-Control-Allow-Origin', FRONTEND_URL);
+            res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+            if (req.method === 'OPTIONS') {
+                res.writeHead(204);
+                res.end();
+                return;
+            }
+            if (req.method === 'POST' && req.url === '/callback') {
+                let body = '';
+                req.on('data', chunk => { body += chunk; });
+                req.on('end', () => {
+                    try {
+                        const { token, expires_in } = JSON.parse(body);
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ success: true }));
+                        server.close();
+                        saveToken(token, expires_in || 3600);
+                        resolve(token);
+                    }
+                    catch (e) {
+                        res.writeHead(400);
+                        res.end('Invalid payload');
+                        reject(new Error('Invalid token callback payload'));
+                    }
+                });
+            }
+            else {
+                res.writeHead(404);
+                res.end();
+            }
+        });
+        server.listen(0, '127.0.0.1', async () => {
+            const port = server.address().port;
+            const loginUrl = `${FRONTEND_URL}/login?mcp_callback=http://127.0.0.1:${port}/callback`;
+            console.error('\n🔐 AgentBuilder Login Required');
+            console.error('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            console.error(`Opening browser to login page...`);
+            console.error(`If it doesn't open automatically, visit:\n  ${loginUrl}`);
+            console.error('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            try {
+                const { default: open } = await import('open');
+                await open(loginUrl);
+            }
+            catch { }
+            // Timeout after 5 minutes
+            setTimeout(() => {
+                server.close();
+                reject(new Error('Login timed out after 5 minutes'));
+            }, 5 * 60 * 1000);
+        });
+        server.on('error', reject);
+    });
+}
+// AgentBuilder API Client
+class AgentBuilderClient {
+    client;
+    apiBaseUrl;
+    authToken = null; // DEPRECATED: Use connectionId instead
+    connectionId = null; // Production OAuth connection ID
+    constructor() {
+        // PRODUCTION ONLY: Always use production API
+        this.apiBaseUrl = process.env.AGENTBUILDER_API_URL || 'https://agentsapi.chatslytics.com';
+        // Ensure no localhost connections
+        if (this.apiBaseUrl.includes('localhost') || this.apiBaseUrl.includes('127.0.0.1')) {
+            console.error('❌ Localhost connections are disabled. Only production API is allowed.');
+            this.apiBaseUrl = 'https://agentsapi.chatslytics.com';
+        }
+        this.client = axios.create({
+            baseURL: this.apiBaseUrl,
+            timeout: 30000,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        // Add request interceptor to inject connection ID header
+        this.client.interceptors.request.use((config) => {
+            if (this.connectionId) {
+                // Production mode: Use connection ID
+                config.headers['X-MCP-Connection-ID'] = this.connectionId;
+            }
+            else if (this.authToken) {
+                // Dev/test mode: Use direct auth token (DEPRECATED)
+                console.warn('⚠️  Using deprecated auth token. Please use set_connection for production.');
+                config.headers['Authorization'] = `Bearer ${this.authToken}`;
+            }
+            return config;
+        });
+        // Auto-authenticate: env var → stored credentials file
+        const envToken = process.env.AGENTBUILDER_AUTH_TOKEN;
+        if (envToken) {
+            this.authToken = envToken;
+            console.error('[MCP] Authenticated from AGENTBUILDER_AUTH_TOKEN env var');
+        }
+        else {
+            const storedToken = loadStoredToken();
+            if (storedToken) {
+                this.authToken = storedToken;
+                console.error('[MCP] Authenticated from stored credentials');
+            }
+        }
+        console.error(`[MCP] Configured for PRODUCTION API: ${this.apiBaseUrl}`);
+    }
+    isAuthenticated() {
+        return !!(this.connectionId || this.authToken);
+    }
+    /**
+     * Set MCP connection ID (Production OAuth)
+     * Obtains connection ID from dashboard after OAuth flow
+     */
+    setConnection(connectionId) {
+        this.connectionId = connectionId;
+        console.log(`[MCP] Connected with connection ID: ${connectionId}`);
+    }
+    /**
+     * Get connection ID from backend to validate connection
+     */
+    async validateConnection(connectionId) {
+        const response = await this.client.get(`/api/v1/mcp/connections/${connectionId}`);
+        return response.data;
+    }
+    /**
+     * Set authentication token for API requests
+     * @deprecated Use setConnection() for production. This method is for dev/test only.
+     */
+    setAuthToken(token) {
+        console.warn('⚠️  setAuthToken is deprecated for production use. Use setConnection() instead.');
+        this.authToken = token;
+    }
+    /**
+     * Create a new workflow
+     */
+    async createWorkflow(params) {
+        const payload = {
+            name: params.name,
+            description: params.description || '',
+            nodes: params.nodes || [],
+            connections: params.connections || [],
+        };
+        // Add optional fields if provided
+        if (params.triggers) {
+            payload.triggers = params.triggers;
+        }
+        if (params.max_execution_time !== undefined) {
+            payload.max_execution_time = params.max_execution_time;
+        }
+        if (params.retry_attempts !== undefined) {
+            payload.retry_attempts = params.retry_attempts;
+        }
+        const response = await this.client.post('/api/v1/workflows', payload);
+        return response.data;
+    }
+    /**
+     * List workflows
+     */
+    async listWorkflows(params) {
+        const response = await this.client.get('/api/v1/workflows', {
+            params: {
+                limit: params?.limit || 20,
+                offset: params?.offset || 0,
+                status: params?.status,
+            },
+        });
+        return response.data;
+    }
+    /**
+     * Get workflow by ID
+     */
+    async getWorkflow(workflowId) {
+        const response = await this.client.get(`/api/v1/workflows/${workflowId}`);
+        return response.data;
+    }
+    /**
+     * Update workflow
+     */
+    async updateWorkflow(workflowId, updates) {
+        const response = await this.client.put(`/api/v1/workflows/${workflowId}`, updates);
+        return response.data;
+    }
+    /**
+     * Execute workflow
+     */
+    async executeWorkflow(workflowId, input) {
+        const response = await this.client.post(`/api/v1/workflows/${workflowId}/execute`, {
+            input: input || {},
+        });
+        return response.data;
+    }
+    /**
+     * Get workflow execution status
+     */
+    async getExecutionStatus(executionId) {
+        const response = await this.client.get(`/api/v1/executions/${executionId}`);
+        return response.data;
+    }
+    /**
+     * List workflow executions
+     */
+    async listExecutions(workflowId) {
+        const params = {};
+        if (workflowId) {
+            params.workflow_id = workflowId;
+        }
+        const response = await this.client.get('/api/v1/executions', { params });
+        return response.data;
+    }
+    /**
+     * Delete workflow
+     */
+    async deleteWorkflow(workflowId) {
+        const response = await this.client.delete(`/api/v1/workflows/${workflowId}`);
+        return response.data;
+    }
+    /**
+     * Validate workflow
+     */
+    async validateWorkflow(workflow) {
+        const response = await this.client.post('/api/v1/workflows/validate', workflow);
+        return response.data;
+    }
+    /**
+     * Check if workflow is ready for deployment
+     */
+    async checkDeploymentReadiness(workflowId) {
+        const response = await this.client.get(`/api/v1/workflows/${workflowId}/deployment-readiness`);
+        return response.data;
+    }
+    /**
+     * Deploy workflow to production
+     */
+    async deployWorkflow(workflowId, config) {
+        const response = await this.client.post(`/api/v1/seller/workflows/${workflowId}/deploy`, {
+            display_name: config.instance_name,
+            pricing: {
+                model: 'pay_per_use',
+                price_per_execution: config.price_per_execution || 0.01,
+                currency: 'USD'
+            }
+        });
+        return response.data;
+    }
+    /**
+     * List workflows created via MCP
+     */
+    async listMCPWorkflows(filter) {
+        const response = await this.client.get('/api/v1/workflows', {
+            params: {
+                source_type: 'mcp_server',
+                deployment_filter: filter
+            }
+        });
+        return response.data;
+    }
+    /**
+     * List agents
+     */
+    async listAgents(params) {
+        const response = await this.client.get('/api/v1/agents', {
+            params: {
+                page: params?.page || 1,
+                page_size: params?.page_size || 50,
+                search: params?.search,
+                category: params?.category,
+                agent_type: params?.agent_type,
+                pricing_model: params?.pricing_model,
+                agent_status: params?.agent_status,
+                creator_id: params?.creator_id,
+                is_featured: params?.is_featured,
+                sort_by: params?.sort_by || 'created_at',
+                sort_order: params?.sort_order || 'desc',
+            },
+        });
+        return response.data;
+    }
+    /**
+     * Get agent by ID
+     */
+    async getAgent(agentId) {
+        const response = await this.client.get(`/api/v1/agents/${agentId}`);
+        return response.data;
+    }
+    /**
+     * Execute an agent
+     */
+    async executeAgent(agentId, input) {
+        const response = await this.client.post(`/api/v1/agents/${agentId}/execute`, {
+            input: input || {},
+        });
+        return response.data;
+    }
+    /**
+     * Deploy an agent to Kubernetes
+     */
+    async deployAgent(agentId, deploymentConfig) {
+        const response = await this.client.post(`/api/v1/agents/${agentId}/deploy`, deploymentConfig || {});
+        return response.data;
+    }
+    async redeployAgent(agentId, body) {
+        const response = await this.client.post(`/api/v1/agents/${agentId}/redeploy`, body || {});
+        return response.data;
+    }
+    async getMcpPlanLimits() {
+        const response = await this.client.get('/api/v1/agents/mcp/plan-limits');
+        return response.data;
+    }
+    /**
+     * Create a new agent
+     */
+    async createAgent(params) {
+        const response = await this.client.post('/api/v1/agents', params);
+        return response.data;
+    }
+    /**
+     * Update an existing agent
+     */
+    async updateAgent(agentId, updates) {
+        const response = await this.client.put(`/api/v1/agents/${agentId}`, updates);
+        return response.data;
+    }
+    /**
+     * Set wizard configuration for an agent
+     */
+    async setAgentWizardConfig(agentId, wizardConfiguration) {
+        const response = await this.client.put(`/api/v1/agents/${agentId}/wizard-configuration`, wizardConfiguration);
+        return response.data;
+    }
+    /**
+     * Set LangGraph workflow definition for an agent
+     */
+    async setAgentGraph(agentId, graph) {
+        const response = await this.client.put(`/api/v1/agents/${agentId}/graph`, graph);
+        return response.data;
+    }
+    /**
+     * Validate agent configuration before publishing
+     */
+    async validateAgentConfiguration(agentId) {
+        const response = await this.client.get(`/api/v1/agents/${agentId}/validate`);
+        return response.data;
+    }
+    /**
+     * Publish agent to marketplace
+     */
+    async publishAgent(agentId) {
+        const response = await this.client.post(`/api/v1/agents/${agentId}/publish`, {});
+        return response.data;
+    }
+    // ==========================================
+    // DASHBOARD TOOLS
+    // ==========================================
+    /**
+     * Create or update agent dashboard configuration
+     */
+    async createAgentDashboard(agentId, dashboardConfig) {
+        const response = await this.client.post(`/api/v1/agents/${agentId}/dashboard/config`, dashboardConfig);
+        return response.data;
+    }
+    /**
+     * Get agent dashboard configuration
+     */
+    async getAgentDashboardConfig(agentId) {
+        const response = await this.client.get(`/api/v1/agents/${agentId}/dashboard/config`);
+        return response.data;
+    }
+    /**
+     * Update agent dashboard
+     */
+    async updateAgentDashboard(agentId, updates) {
+        const response = await this.client.put(`/api/v1/agents/${agentId}/dashboard/config`, updates);
+        return response.data;
+    }
+    /**
+     * Add widget to agent dashboard
+     */
+    async addDashboardWidget(agentId, widgetConfig) {
+        const response = await this.client.post(`/api/v1/agents/${agentId}/dashboard/widgets`, widgetConfig);
+        return response.data;
+    }
+    /**
+     * Configure agent page (landing, configuration, dashboard)
+     */
+    async configureAgentPage(agentId, pageConfig) {
+        const response = await this.client.put(`/api/v1/agents/${agentId}/page/${pageConfig.page_type}`, { content: pageConfig.content });
+        return response.data;
+    }
+    // ==========================================
+    // AGENT COMPOSITION TOOLS
+    // ==========================================
+    /**
+     * Create a composed/clubbed agent from multiple sub-agents
+     */
+    async composeAgents(params) {
+        const response = await this.client.post('/api/v1/agent-composition/create', params);
+        return response.data;
+    }
+    /**
+     * List composed agents owned by the authenticated user
+     */
+    async listComposedAgents(params) {
+        const response = await this.client.get('/api/v1/agent-composition/list', {
+            params: {
+                page: params?.page || 1,
+                limit: params?.limit || 20,
+            },
+        });
+        return response.data;
+    }
+    /**
+     * Get a specific composed agent by ID
+     */
+    async getComposedAgent(agentId) {
+        const response = await this.client.get(`/api/v1/agent-composition/${agentId}`);
+        return response.data;
+    }
+    /**
+     * Preview a composition before creating it (shows pricing & execution flow)
+     */
+    async previewComposition(params) {
+        const response = await this.client.post('/api/v1/agent-composition/preview', params);
+        return response.data;
+    }
+    /**
+     * Execute a composed agent with input data
+     */
+    async executeComposedAgent(agentId, inputData) {
+        const response = await this.client.post(`/api/v1/agent-composition/execute/${agentId}`, {
+            input_data: inputData || {},
+        });
+        return response.data;
+    }
+    /**
+     * Delete a composed agent
+     */
+    async deleteComposedAgent(agentId) {
+        const response = await this.client.delete(`/api/v1/agent-composition/${agentId}`);
+        return response.data;
+    }
+    /**
+     * List available agent type templates (instagram_dm_sales, whatsapp_business, etc.)
+     */
+    async listAgentTypes() {
+        const response = await this.client.get('/api/v1/seller/wizard/agent-types');
+        return response.data;
+    }
+    /**
+     * Clone an existing agent as a starting point
+     */
+    async cloneAgent(agentId, newName) {
+        const response = await this.client.post(`/api/v1/agents/${agentId}/clone`, {
+            new_name: newName,
+        });
+        return response.data;
+    }
+    // ==========================================
+    // WIDGET GENERATION
+    // ==========================================
+    /**
+     * Compile and store a custom React widget (source code provided by caller)
+     */
+    async generateWidget(params) {
+        const response = await this.client.post('/api/v1/widgets/generate', params);
+        return response.data;
+    }
+    /**
+     * List generated widgets for an agent
+     */
+    async listGeneratedWidgets(agentId) {
+        const response = await this.client.get(`/api/v1/widgets/agent/${agentId}`);
+        return response.data;
+    }
+    /**
+     * Regenerate a widget with new source code
+     */
+    async regenerateWidget(widgetId, agentId, params) {
+        const response = await this.client.post(`/api/v1/widgets/${widgetId}/regenerate?agent_id=${agentId}`, params);
+        return response.data;
+    }
+    /**
+     * Delete a generated widget
+     */
+    async deleteGeneratedWidget(widgetId, agentId) {
+        const response = await this.client.delete(`/api/v1/widgets/${widgetId}?agent_id=${agentId}`);
+        return response.data;
+    }
+}
+// MCP Server
+class AgentBuilderMCPServer {
+    server;
+    client;
+    constructor() {
+        this.server = new Server({
+            name: 'agentbuilder-mcp-server',
+            version: '0.0.1',
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.client = new AgentBuilderClient();
+        this.setupHandlers();
+        this.setupErrorHandling();
+    }
+    setupErrorHandling() {
+        this.server.onerror = (error) => {
+            console.error('[MCP Error]', error);
+        };
+        process.on('SIGINT', async () => {
+            await this.server.close();
+            process.exit(0);
+        });
+    }
+    setupHandlers() {
+        // List available tools
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: this.getTools(),
+            };
+        });
+        // Handle tool calls
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                switch (name) {
+                    case 'create_workflow':
+                        return await this.handleCreateWorkflow(args);
+                    case 'list_workflows':
+                        return await this.handleListWorkflows(args);
+                    case 'get_workflow':
+                        return await this.handleGetWorkflow(args);
+                    case 'update_workflow':
+                        return await this.handleUpdateWorkflow(args);
+                    case 'execute_workflow':
+                        return await this.handleExecuteWorkflow(args);
+                    case 'get_execution_status':
+                        return await this.handleGetExecutionStatus(args);
+                    case 'list_executions':
+                        return await this.handleListExecutions(args);
+                    case 'delete_workflow':
+                        return await this.handleDeleteWorkflow(args);
+                    case 'validate_workflow':
+                        return await this.handleValidateWorkflow(args);
+                    case 'check_deployment_readiness':
+                        return await this.handleCheckDeploymentReadiness(args);
+                    case 'deploy_workflow':
+                        return await this.handleDeployWorkflow(args);
+                    case 'list_mcp_workflows':
+                        return await this.handleListMCPWorkflows(args);
+                    case 'list_agents':
+                        return await this.handleListAgents(args);
+                    case 'get_agent':
+                        return await this.handleGetAgent(args);
+                    case 'execute_agent':
+                        return await this.handleExecuteAgent(args);
+                    case 'deploy_agent':
+                        return await this.handleDeployAgent(args);
+                    case 'redeploy_agent':
+                        return await this.handleRedeployAgent(args);
+                    // Agent Management Tools
+                    case 'create_agent':
+                        return await this.handleCreateAgent(args);
+                    case 'update_agent':
+                        return await this.handleUpdateAgent(args);
+                    case 'set_agent_wizard_config':
+                        return await this.handleSetAgentWizardConfig(args);
+                    case 'set_agent_graph':
+                        return await this.handleSetAgentGraph(args);
+                    case 'validate_agent_configuration':
+                        return await this.handleValidateAgentConfiguration(args);
+                    case 'publish_agent':
+                        return await this.handlePublishAgent(args);
+                    case 'set_auth_token':
+                        return await this.handleSetAuthToken(args);
+                    case 'set_connection':
+                        return await this.handleSetConnection(args);
+                    // Dashboard Tools
+                    case 'create_agent_dashboard':
+                        return await this.handleCreateAgentDashboard(args);
+                    case 'get_agent_dashboard_config':
+                        return await this.handleGetAgentDashboardConfig(args);
+                    case 'update_agent_dashboard':
+                        return await this.handleUpdateAgentDashboard(args);
+                    case 'add_dashboard_widget':
+                        return await this.handleAddDashboardWidget(args);
+                    case 'configure_agent_page':
+                        return await this.handleConfigureAgentPage(args);
+                    // Widget Generation Tools
+                    case 'generate_dashboard_widget':
+                        return await this.handleGenerateDashboardWidget(args);
+                    case 'list_generated_widgets':
+                        return await this.handleListGeneratedWidgets(args);
+                    case 'regenerate_widget':
+                        return await this.handleRegenerateWidget(args);
+                    case 'delete_generated_widget':
+                        return await this.handleDeleteGeneratedWidget(args);
+                    // Agent Composition Tools
+                    case 'compose_agents':
+                        return await this.handleComposeAgents(args);
+                    case 'list_composed_agents':
+                        return await this.handleListComposedAgents(args);
+                    case 'get_composed_agent':
+                        return await this.handleGetComposedAgent(args);
+                    case 'preview_composition':
+                        return await this.handlePreviewComposition(args);
+                    case 'execute_composed_agent':
+                        return await this.handleExecuteComposedAgent(args);
+                    case 'list_agent_types':
+                        return await this.handleListAgentTypes(args);
+                    case 'clone_agent':
+                        return await this.handleCloneAgent(args);
+                    case 'get_mcp_plan_limits':
+                        return await this.handleGetMcpPlanLimits();
+                    default:
+                        throw new Error(`Unknown tool: ${name}`);
+                }
+            }
+            catch (error) {
+                const errorMessage = this.formatErrorMessage(error);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: errorMessage,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        });
+    }
+    getTools() {
+        return [
+            {
+                name: 'set_connection',
+                description: 'Connect to AgentBuilder workspace using OAuth connection ID (PRODUCTION). Obtain connection ID from dashboard after OAuth flow.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        connection_id: {
+                            type: 'string',
+                            description: 'MCP connection ID from dashboard (format: mcp_conn_xxx)',
+                            pattern: '^mcp_conn_[a-zA-Z0-9_-]+$',
+                        },
+                    },
+                    required: ['connection_id'],
+                },
+            },
+            {
+                name: 'set_auth_token',
+                description: 'DEPRECATED: Set authentication token for dev/test only. Use set_connection for production.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        token: {
+                            type: 'string',
+                            description: 'JWT authentication token from Supabase (dev/test only)',
+                        },
+                    },
+                    required: ['token'],
+                },
+            },
+            {
+                name: 'create_workflow',
+                description: 'Create a new custom workflow with nodes and edges. NOTE: This creates a new workflow from scratch. To use pre-built agent templates, use list_agents and execute_agent instead.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string',
+                            description: 'Name of the workflow',
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Description of what the workflow does',
+                        },
+                        nodes: {
+                            type: 'array',
+                            description: 'Array of workflow nodes',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    id: {
+                                        type: 'string',
+                                        description: 'Unique node identifier'
+                                    },
+                                    type: {
+                                        type: 'string',
+                                        description: 'Node type (e.g., start, openai, telegram, slack)'
+                                    },
+                                    title: {
+                                        type: 'string',
+                                        description: 'Display title for the node'
+                                    },
+                                    description: {
+                                        type: 'string',
+                                        description: 'Optional node description'
+                                    },
+                                    position: {
+                                        type: 'object',
+                                        description: 'UI position coordinates',
+                                        properties: {
+                                            x: { type: 'number' },
+                                            y: { type: 'number' }
+                                        }
+                                    },
+                                    config: {
+                                        type: 'object',
+                                        description: 'Node-specific configuration'
+                                    }
+                                },
+                                required: ['id', 'type', 'title']
+                            },
+                        },
+                        connections: {
+                            type: 'array',
+                            description: 'Array of connections between nodes',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    id: {
+                                        type: 'string',
+                                        description: 'Unique connection identifier'
+                                    },
+                                    source: {
+                                        type: 'string',
+                                        description: 'Source node ID'
+                                    },
+                                    target: {
+                                        type: 'string',
+                                        description: 'Target node ID'
+                                    },
+                                    source_port: {
+                                        type: 'string',
+                                        description: 'Source output port (default: "output")'
+                                    },
+                                    target_port: {
+                                        type: 'string',
+                                        description: 'Target input port (default: "input")'
+                                    }
+                                },
+                                required: ['id', 'source', 'target']
+                            },
+                        },
+                        triggers: {
+                            type: 'array',
+                            description: 'Optional workflow triggers (schedule, webhook, etc.)'
+                        },
+                        max_execution_time: {
+                            type: 'number',
+                            description: 'Maximum execution time in seconds (default: 3600)'
+                        },
+                        retry_attempts: {
+                            type: 'number',
+                            description: 'Number of retry attempts on failure (default: 3)'
+                        }
+                    },
+                    required: ['name'],
+                },
+            },
+            {
+                name: 'list_workflows',
+                description: 'List custom workflows created by the authenticated user. NOTE: For pre-built agent templates (like Instagram DM Sales Agent), use list_agents instead.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        limit: {
+                            type: 'number',
+                            description: 'Number of workflows to return (default: 20)',
+                        },
+                        offset: {
+                            type: 'number',
+                            description: 'Pagination offset (default: 0)',
+                        },
+                        status: {
+                            type: 'string',
+                            description: 'Filter by status (draft, active, archived)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'get_workflow',
+                description: 'Get details of a specific workflow by ID',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        workflow_id: {
+                            type: 'string',
+                            description: 'Workflow ID',
+                        },
+                    },
+                    required: ['workflow_id'],
+                },
+            },
+            {
+                name: 'update_workflow',
+                description: 'Update an existing workflow',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        workflow_id: {
+                            type: 'string',
+                            description: 'Workflow ID',
+                        },
+                        updates: {
+                            type: 'object',
+                            description: 'Fields to update (name, description, nodes, edges, status, etc.)',
+                        },
+                    },
+                    required: ['workflow_id', 'updates'],
+                },
+            },
+            {
+                name: 'execute_workflow',
+                description: 'Execute a workflow with optional input data',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        workflow_id: {
+                            type: 'string',
+                            description: 'Workflow ID',
+                        },
+                        input: {
+                            type: 'object',
+                            description: 'Input data for the workflow execution',
+                        },
+                    },
+                    required: ['workflow_id'],
+                },
+            },
+            {
+                name: 'get_execution_status',
+                description: 'Get the status and results of a workflow execution',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        execution_id: {
+                            type: 'string',
+                            description: 'Execution ID',
+                        },
+                    },
+                    required: ['execution_id'],
+                },
+            },
+            {
+                name: 'list_executions',
+                description: 'List workflow executions, optionally filtered by workflow ID',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        workflow_id: {
+                            type: 'string',
+                            description: 'Filter executions by workflow ID (optional)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'delete_workflow',
+                description: 'Delete a workflow by ID',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        workflow_id: {
+                            type: 'string',
+                            description: 'Workflow ID to delete',
+                        },
+                    },
+                    required: ['workflow_id'],
+                },
+            },
+            {
+                name: 'validate_workflow',
+                description: 'Validate a workflow structure before creating/updating',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        workflow: {
+                            type: 'object',
+                            description: 'Workflow object to validate',
+                        },
+                    },
+                    required: ['workflow'],
+                },
+            },
+            {
+                name: 'check_deployment_readiness',
+                description: 'Check if workflow is ready for deployment and see required credentials',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        workflow_id: {
+                            type: 'string',
+                            description: 'Workflow ID to check for deployment readiness',
+                        },
+                    },
+                    required: ['workflow_id'],
+                },
+            },
+            {
+                name: 'deploy_workflow',
+                description: 'Deploy workflow as a production instance on Kubernetes',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        workflow_id: {
+                            type: 'string',
+                            description: 'Workflow ID to deploy',
+                        },
+                        instance_name: {
+                            type: 'string',
+                            description: 'Display name for the deployed instance',
+                        },
+                        price_per_execution: {
+                            type: 'number',
+                            description: 'Price to charge per execution in USD (default: 0.01)',
+                        },
+                    },
+                    required: ['workflow_id', 'instance_name'],
+                },
+            },
+            {
+                name: 'list_mcp_workflows',
+                description: 'List workflows created via MCP with deployment status',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        filter: {
+                            type: 'string',
+                            enum: ['all', 'deployable', 'pending', 'failed'],
+                            description: 'Filter by deployment status',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'list_agents',
+                description: 'List all agents with filtering and pagination. Agents are pre-built workflow templates (e.g., Instagram DM Sales Agent, Patient Follow-up WhatsApp Agent) that can be deployed and executed.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        page: {
+                            type: 'number',
+                            description: 'Page number (default: 1)',
+                        },
+                        page_size: {
+                            type: 'number',
+                            description: 'Number of agents per page (default: 50)',
+                        },
+                        search: {
+                            type: 'string',
+                            description: 'Search query for agent name or description',
+                        },
+                        category: {
+                            type: 'string',
+                            description: 'Filter by category (e.g., healthcare, sales, customer-support)',
+                        },
+                        agent_type: {
+                            type: 'string',
+                            description: 'Filter by agent type (workflow, chatbot, api)',
+                        },
+                        pricing_model: {
+                            type: 'string',
+                            description: 'Filter by pricing model (free, subscription, pay_per_use)',
+                        },
+                        agent_status: {
+                            type: 'string',
+                            description: 'Filter by status (active, draft, archived)',
+                        },
+                        creator_id: {
+                            type: 'string',
+                            description: 'Filter by creator user ID',
+                        },
+                        is_featured: {
+                            type: 'boolean',
+                            description: 'Filter featured agents only',
+                        },
+                        sort_by: {
+                            type: 'string',
+                            description: 'Sort by field (name, created_at, updated_at, metrics.views, metrics.average_rating)',
+                        },
+                        sort_order: {
+                            type: 'string',
+                            description: 'Sort order (asc, desc)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'get_agent',
+                description: 'Get detailed information about a specific agent by ID',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Agent ID',
+                        },
+                    },
+                    required: ['agent_id'],
+                },
+            },
+            {
+                name: 'execute_agent',
+                description: 'Execute an agent with input data',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Agent ID to execute',
+                        },
+                        input: {
+                            type: 'object',
+                            description: 'Input data for the agent execution',
+                        },
+                    },
+                    required: ['agent_id'],
+                },
+            },
+            {
+                name: 'deploy_agent',
+                description: 'Deploy an agent to Kubernetes production environment. Creates an isolated pod per subscription with agent runtime + dashboard sidecar. Dashboard is accessible at https://{subscription_id}.agents.chatslytics.com. Deployment uses the agent graph and dashboard config created during setup.\n\nARCHITECTURE NOTES:\n- Each agent uses its OWN dedicated Facebook/Meta App — never share apps across agents. This gives each agent its own webhook callback URL, verify token, and app credentials, providing full isolation.\n- Webhook URL pattern per agent: https://{subscription_id}.agents.chatslytics.com/webhook/{provider} — registered directly in that agent\'s Meta App settings. The platform is NOT in the webhook path for new agents.\n- AGENT_GRAPH_CONFIG (LangGraph nodes/edges) is baked as a Kubernetes env var at deploy time. Changing graph topology (adding nodes, modifying LLM prompts in graph) requires a redeploy. Credentials and user configuration are managed in platform MongoDB (user_subscriptions.user_configuration) with platform-side Fernet AES encryption — the pod reads these live at runtime via _enrich_context_from_db() so config changes from the platform UI take effect without pod restart. Use RuntimeConfig (runtime_config_{sub_id}, pod-owned collection) only for agent-operational state such as onboarding completion status.\n- All agent storage is namespaced by subscription_id (e.g. invoices_{sub_id}, messages_{sub_id}) — one agent\'s data is never accessible to another.\n- Pod reports lifecycle to platform via PlatformClient: /api/v1/runtime/ready, /api/v1/runtime/stopped, /api/v1/runtime/metrics. These are fire-and-forget; platform downtime does not affect the agent.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Agent ID to deploy',
+                        },
+                        deployment_config: {
+                            type: 'object',
+                            description: 'Optional deployment configuration',
+                            properties: {
+                                replicas: {
+                                    type: 'number',
+                                    description: 'Number of pod replicas (default: 1)',
+                                },
+                                cpu_request: {
+                                    type: 'string',
+                                    description: 'CPU request per pod (default: "100m")',
+                                },
+                                cpu_limit: {
+                                    type: 'string',
+                                    description: 'CPU limit per pod (default: "500m")',
+                                },
+                                memory_request: {
+                                    type: 'string',
+                                    description: 'Memory request per pod (default: "128Mi")',
+                                },
+                                memory_limit: {
+                                    type: 'string',
+                                    description: 'Memory limit per pod (default: "512Mi")',
+                                },
+                                image: {
+                                    type: 'string',
+                                    description: 'Container image override. If omitted, the agent\'s runtime_image field in MongoDB is used automatically (e.g. acragentbuilder.azurecr.io/agent-runtime:ca-invoice-v1.0.0). Falls back to agent-runtime:latest only if no runtime_image is set on the agent doc.',
+                                },
+                            },
+                        },
+                    },
+                    required: ['agent_id'],
+                },
+            },
+            {
+                name: 'redeploy_agent',
+                description: 'Redeploy a running agent pod with the latest graph and/or image. Use this after set_agent_graph (graph changes require pod restart) or after pushing a new container image to ACR. Preserves all pod data (conversations, vectors, checkpoints). Triggers rolling restart — ~60s downtime.\n\nWORKFLOW:\n1. Make code changes in agent repo → build + push new image to ACR\n2. Call set_agent_graph if graph/node configs changed\n3. Call redeploy_agent — picks up latest graph from MongoDB + new image\n\nNOTE: Credential/config changes (via platform wizard UI) do NOT need redeploy — the pod reads them live from DB on every webhook.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Agent ID to redeploy',
+                        },
+                        runtime_image: {
+                            type: 'string',
+                            description: 'New container image to deploy (e.g. acragentbuilder.azurecr.io/instagram-dm-agent:v4.12.0). Omit to keep current image and only update the graph.',
+                        },
+                    },
+                    required: ['agent_id'],
+                },
+            },
+            // ==========================================
+            // AGENT MANAGEMENT TOOLS
+            // ==========================================
+            {
+                name: 'create_agent',
+                description: 'Create a new agent with complete configuration. Requires seller role. Agent will be created in draft status.\n\nAGENT ISOLATION MODEL:\n- Each agent is a fully isolated unit: its own K8s pod, its own Facebook/Meta App (for webhook providers), its own MongoDB namespace (collections prefixed with subscription_id), and its own dashboard URL.\n- Never reuse an existing agent\'s Facebook App or webhook credentials for a new agent. Create a fresh Meta App per agent type.\n- Full creation flow: create_agent → set_agent_wizard_config → set_agent_graph → create_agent_dashboard → validate_agent_configuration → publish_agent → deploy_agent.\n- After deploy_agent, the operator manually registers the webhook callback URL (https://{subscription_id}.agents.chatslytics.com/webhook/{provider}) in the new agent\'s Meta App settings.\n\nSHARED PLATFORM SERVICES (do not replicate in agent logic):\n- AUTH: Agent pods call AUTH_SERVICE_URL/verify for dashboard JWT validation. Requests forwarded by the platform carry X-Platform-Proxy: true and should be trusted without re-verification.\n- PAYMENT: All billing, Razorpay subscriptions, and payment lifecycle are handled by the platform (razorpay_service.py, seller_instance_billing_service.py). Agent pods never touch payment logic — they just run if SUBSCRIPTION_ID is present.\n- SUBSCRIPTION + CONFIGURATION: The platform\'s user_subscriptions.user_configuration is the source of truth for all credentials and wizard-collected config. The platform handles Fernet AES encryption/decryption. Agent pods read this via _enrich_context_from_db() at startup and per-webhook — this is correct and intentional, not a coupling violation. Config changes made via platform UI propagate to the pod without restart. Do NOT duplicate credentials into pod-owned storage. Use RuntimeConfig (runtime_config_{sub_id}, pod-owned collection) only for agent-operational state like onboarding completion flags.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string',
+                            description: 'Agent name (1-100 characters)',
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Short description (max 1000 characters)',
+                        },
+                        detailed_description: {
+                            type: 'string',
+                            description: 'Detailed description (max 5000 characters)',
+                        },
+                        type: {
+                            type: 'string',
+                            enum: ['conversational', 'workflow', 'analytical', 'creative', 'research', 'automation'],
+                            description: 'Agent type',
+                        },
+                        category: {
+                            type: 'string',
+                            description: 'Agent category (e.g., Sales, Customer Support, Analytics)',
+                        },
+                        tags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Tags for discoverability (max 20)',
+                        },
+                        wizard_configuration: {
+                            type: 'object',
+                            description: 'Configuration wizard schema for agent onboarding',
+                        },
+                        graph: {
+                            type: 'object',
+                            description: 'LangGraph workflow definition with nodes and edges',
+                        },
+                        pricing: {
+                            type: 'object',
+                            description: 'Pricing configuration',
+                        },
+                        icon_url: {
+                            type: 'string',
+                            description: 'Icon URL',
+                        },
+                        banner_url: {
+                            type: 'string',
+                            description: 'Banner URL',
+                        },
+                        screenshots: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Screenshot URLs (max 10)',
+                        },
+                        demo_url: {
+                            type: 'string',
+                            description: 'Demo video URL',
+                        },
+                        video_url: {
+                            type: 'string',
+                            description: 'Promotional video URL',
+                        },
+                        is_public: {
+                            type: 'boolean',
+                            description: 'Whether agent is publicly visible (default: false)',
+                        },
+                        runtime_image: {
+                            type: 'string',
+                            description: 'Container image for this agent\'s runtime pods (e.g. acragentbuilder.azurecr.io/instagram-dm-agent:latest). Each agent type should have its own dedicated image built from its own repo. Omit to fall back to the generic agent-runtime:latest.',
+                        },
+                    },
+                    required: ['name', 'description', 'type', 'category'],
+                },
+            },
+            {
+                name: 'update_agent',
+                description: 'Update an existing agent. Requires agent ownership or admin role.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Agent ID',
+                        },
+                        updates: {
+                            type: 'object',
+                            description: 'Fields to update (partial update)',
+                        },
+                    },
+                    required: ['agent_id', 'updates'],
+                },
+            },
+            {
+                name: 'set_agent_wizard_config',
+                description: 'Set or update wizard configuration for agent onboarding. Defines OAuth providers, credentials, platform config, and custom wizard steps.\n\nNOTE: For webhook-based agents (WhatsApp, Instagram, Telegram), the wizard should collect the provider app credentials specific to THIS agent\'s dedicated Meta/provider App — not shared platform credentials. Each agent has its own app, so WHATSAPP_PHONE_NUMBER_ID, WHATSAPP_ACCESS_TOKEN, app secret etc. are all per-agent. These get injected into the pod as env vars at deploy time and are also accessible via RuntimeConfig for hot updates.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Agent ID',
+                        },
+                        wizard_configuration: {
+                            type: 'object',
+                            description: 'Complete wizard configuration',
+                            properties: {
+                                required_oauth_providers: {
+                                    type: 'array',
+                                    items: { type: 'string' },
+                                    description: 'Required OAuth providers (e.g., facebook, instagram, whatsapp)',
+                                },
+                                required_credentials: {
+                                    type: 'array',
+                                    description: 'Required API credentials with field definitions',
+                                },
+                                required_platform_config: {
+                                    type: 'array',
+                                    description: 'Platform-specific configuration fields',
+                                },
+                                custom_wizard_steps: {
+                                    type: 'array',
+                                    description: 'Agent-specific custom wizard steps',
+                                },
+                                configuration_defaults: {
+                                    type: 'object',
+                                    description: 'Default values for optional fields',
+                                },
+                            },
+                        },
+                    },
+                    required: ['agent_id', 'wizard_configuration'],
+                },
+            },
+            {
+                name: 'set_agent_graph',
+                description: 'Set LangGraph workflow definition for agent. Defines nodes, edges, and entry point for agent execution.\n\nARCHITECTURE NOTES:\n- The graph JSON is injected as AGENT_GRAPH_CONFIG env var into the pod at deploy time. Topology changes require redeploy.\n- Node configs support {user_config.field_name} template variables resolved at runtime from the subscriber\'s user_configuration in MongoDB — use this for per-user LLM models, thresholds, etc.\n- The entry point node receives the raw webhook payload from the provider (WhatsApp, Instagram, Telegram, etc.).\n- Each new agent should have its own provider app (e.g. its own Facebook App for WhatsApp/Instagram). The webhook entry point in the graph receives events directly from that app\'s callback URL — no platform proxy involved for new agents.\n- Use node type "whatsapp_media_downloader", "gst_invoice_extractor", "phone_client_resolver", "invoice_storage", "whatsapp_confirmation_sender" for CA invoice flow. For other agents, define custom node types registered in the node handler registry.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Agent ID',
+                        },
+                        graph: {
+                            type: 'object',
+                            description: 'LangGraph workflow definition',
+                            properties: {
+                                nodes: {
+                                    type: 'array',
+                                    description: 'Array of workflow nodes',
+                                    items: {
+                                        type: 'object',
+                                        properties: {
+                                            id: { type: 'string', description: 'Unique node identifier' },
+                                            type: { type: 'string', description: 'Node type (webhook, llm_classifier, vector_search, etc.)' },
+                                            config: { type: 'object', description: 'Node-specific configuration' },
+                                        },
+                                        required: ['id', 'type'],
+                                    },
+                                },
+                                edges: {
+                                    type: 'array',
+                                    description: 'Array of connections between nodes',
+                                    items: {
+                                        type: 'object',
+                                        properties: {
+                                            from: { type: 'string', description: 'Source node ID' },
+                                            to: { type: 'string', description: 'Target node ID' },
+                                            condition: { type: 'string', description: 'Optional condition for edge' },
+                                        },
+                                        required: ['from', 'to'],
+                                    },
+                                },
+                                entry_point: {
+                                    type: 'string',
+                                    description: 'Entry point node ID',
+                                },
+                            },
+                            required: ['nodes', 'edges', 'entry_point'],
+                        },
+                    },
+                    required: ['agent_id', 'graph'],
+                },
+            },
+            {
+                name: 'validate_agent_configuration',
+                description: 'Validate agent before publishing. Checks wizard configuration, agent graph, pricing, and metadata completeness.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Agent ID to validate',
+                        },
+                    },
+                    required: ['agent_id'],
+                },
+            },
+            {
+                name: 'publish_agent',
+                description: 'Publish agent to marketplace. Runs validation and sets status to active (admins) or pending_review (sellers).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Agent ID to publish',
+                        },
+                    },
+                    required: ['agent_id'],
+                },
+            },
+            // ==========================================
+            // DASHBOARD TOOLS
+            // ==========================================
+            {
+                name: 'create_agent_dashboard',
+                description: 'Create or configure a dashboard for an agent. Dashboards deploy as independent pods alongside the agent runtime. Subscribers access dashboards via unique URLs with JWT auth. Supports white-labelling via branding config.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Agent ID to create dashboard for',
+                        },
+                        template_type: {
+                            type: 'string',
+                            description: 'Dashboard template type (e.g., instagram-dm-portal, customer-support, analytics)',
+                        },
+                        layout: {
+                            type: 'string',
+                            enum: ['minimal', 'standard', 'full'],
+                            description: 'Dashboard layout complexity (default: standard)',
+                        },
+                        navigation: {
+                            type: 'string',
+                            enum: ['sidebar', 'topbar'],
+                            description: 'Navigation style (default: sidebar)',
+                        },
+                        widgets: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Shorthand: list of widget type strings. Auto-wrapped into a single "main" tab. Available types: stats_card, data_table, chart, form, activity_feed, ca_invoice_table, ca_client_management, ca_export_panel, ca_dashboard_overview, ca_whatsapp_status, instagram_conversations, instagram_metrics',
+                        },
+                        tabs: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    id: { type: 'string', description: 'Unique tab ID' },
+                                    label: { type: 'string', description: 'Tab display label' },
+                                    icon: { type: 'string', description: 'Lucide icon name (e.g., file-text, users, settings)' },
+                                    widgets: {
+                                        type: 'array',
+                                        items: {
+                                            type: 'object',
+                                            properties: {
+                                                type: { type: 'string', description: 'Widget type from registry' },
+                                                config: { type: 'object', description: 'Widget-specific config (e.g., endpoint, columns)' },
+                                            },
+                                            required: ['type'],
+                                        },
+                                        description: 'Widgets to render in this tab',
+                                    },
+                                },
+                                required: ['id', 'label', 'widgets'],
+                            },
+                            description: 'Full tab structure with widgets per tab. Use this OR widgets (not both).',
+                        },
+                        theme: {
+                            type: 'object',
+                            description: 'Custom theme configuration (colors, fonts)',
+                        },
+                        branding: {
+                            type: 'object',
+                            description: 'Custom branding: { brand_name, logo_url, favicon_url, primary_color, secondary_color, background_color, text_color, font_family, custom_css, show_powered_by }',
+                        },
+                    },
+                    required: ['agent_id'],
+                },
+            },
+            {
+                name: 'get_agent_dashboard_config',
+                description: 'Get the current dashboard configuration for an agent',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Agent ID',
+                        },
+                    },
+                    required: ['agent_id'],
+                },
+            },
+            {
+                name: 'update_agent_dashboard',
+                description: 'Update dashboard configuration for an agent',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Agent ID',
+                        },
+                        updates: {
+                            type: 'object',
+                            description: 'Dashboard configuration updates',
+                        },
+                    },
+                    required: ['agent_id', 'updates'],
+                },
+            },
+            {
+                name: 'add_dashboard_widget',
+                description: 'Add a widget to an agent dashboard',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Agent ID',
+                        },
+                        widget_type: {
+                            type: 'string',
+                            enum: ['chart', 'list', 'stats', 'custom'],
+                            description: 'Type of widget to add',
+                        },
+                        title: {
+                            type: 'string',
+                            description: 'Widget title',
+                        },
+                        position: {
+                            type: 'object',
+                            properties: {
+                                x: { type: 'number' },
+                                y: { type: 'number' },
+                            },
+                            description: 'Widget position on dashboard grid',
+                        },
+                        size: {
+                            type: 'object',
+                            properties: {
+                                width: { type: 'number' },
+                                height: { type: 'number' },
+                            },
+                            description: 'Widget size',
+                        },
+                        config: {
+                            type: 'object',
+                            description: 'Widget-specific configuration',
+                        },
+                    },
+                    required: ['agent_id', 'widget_type', 'title'],
+                },
+            },
+            {
+                name: 'configure_agent_page',
+                description: 'Configure agent pages (landing page, configuration page, or dashboard page)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Agent ID',
+                        },
+                        page_type: {
+                            type: 'string',
+                            enum: ['landing', 'configuration', 'dashboard'],
+                            description: 'Type of page to configure',
+                        },
+                        content: {
+                            type: 'object',
+                            description: 'Page content and configuration',
+                        },
+                    },
+                    required: ['agent_id', 'page_type', 'content'],
+                },
+            },
+            // ==========================================
+            // WIDGET GENERATION TOOLS
+            // ==========================================
+            {
+                name: 'generate_dashboard_widget',
+                description: `Compile and deploy a custom React widget to an agent's dashboard. YOU (the connected LLM) write the TSX source code and pass it as source_code. The backend validates, compiles to ESM via esbuild, uploads to CDN, and auto-adds it to the dashboard. Use this for any UI the 11 built-in widgets cannot cover (Kanban boards, calendars, maps, custom forms, etc.).
+
+## Widget Contract — YOU must generate code following these rules:
+
+\`\`\`tsx
+import React from 'react';
+export default function Widget({ config }: { config: Record<string, unknown> }) { ... }
+\`\`\`
+
+**Available imports** (provided by host dashboard — do NOT use anything else):
+- \`react\` (useState, useEffect, useMemo, useCallback, useRef)
+- \`recharts\` (BarChart, LineChart, PieChart, AreaChart, ResponsiveContainer, etc.)
+- \`lucide-react\` (icons: Search, Plus, Trash, Edit, Check, X, etc.)
+- \`axios\` (for API calls — always use relative URLs like \`/api/...\`)
+
+**Styling**: TailwindCSS utility classes only. Use \`dark:\` variants for dark mode.
+
+**Rules**:
+1. Single default-exported function component
+2. Receives \`{ config }\` prop — use \`config.data_endpoint\`, \`config.title\`, etc.
+3. For data: \`axios.get(config.data_endpoint || '/api/data')\` inside useEffect
+4. Handle loading + error states
+5. FORBIDDEN: eval(), Function(), document.cookie, localStorage, sessionStorage, <script>
+6. Keep component self-contained (no external files)`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Agent ID to add the widget to',
+                        },
+                        widget_name: {
+                            type: 'string',
+                            description: 'Machine-friendly name for the widget (snake_case, e.g. "kanban_leads_board")',
+                        },
+                        source_code: {
+                            type: 'string',
+                            description: 'Complete React TSX source code for the widget. Must follow the widget contract: export default a function component that receives { config } prop. Use only react, recharts, lucide-react, axios imports. TailwindCSS for styling.',
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Human-readable description of what the widget does (stored as metadata)',
+                        },
+                    },
+                    required: ['agent_id', 'widget_name', 'source_code'],
+                },
+            },
+            {
+                name: 'list_generated_widgets',
+                description: 'List all custom-generated widgets for an agent. Shows widget name, CDN URL, version, build status, and description.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Agent ID to list widgets for',
+                        },
+                    },
+                    required: ['agent_id'],
+                },
+            },
+            {
+                name: 'regenerate_widget',
+                description: 'Replace a widget\'s source code and recompile. Creates a new version (old version retained on CDN). YOU (the connected LLM) write the updated TSX following the same widget contract as generate_dashboard_widget.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Agent ID that owns the widget',
+                        },
+                        widget_id: {
+                            type: 'string',
+                            description: 'Widget name/ID to regenerate',
+                        },
+                        source_code: {
+                            type: 'string',
+                            description: 'Updated React TSX source code (same contract as generate_dashboard_widget)',
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Updated description (omit to keep existing)',
+                        },
+                    },
+                    required: ['agent_id', 'widget_id', 'source_code'],
+                },
+            },
+            {
+                name: 'delete_generated_widget',
+                description: 'Delete a generated widget from the agent. Removes metadata from database. CDN bundles are retained (immutable).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Agent ID that owns the widget',
+                        },
+                        widget_id: {
+                            type: 'string',
+                            description: 'Widget name/ID to delete',
+                        },
+                    },
+                    required: ['agent_id', 'widget_id'],
+                },
+            },
+            // ==========================================
+            // AGENT COMPOSITION TOOLS
+            // ==========================================
+            {
+                name: 'compose_agents',
+                description: 'Combine 2-10 agents into a composite agent using composition patterns (sequential, parallel, router, map_reduce). Sequential runs A→B→C. Parallel runs all simultaneously. Router selects agent based on input. Map-reduce fans out, processes, and aggregates. Returns composed agent with bundle pricing (15% discount).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string',
+                            description: 'Name for the composed agent',
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Description of what the composed agent does',
+                        },
+                        sub_agent_ids: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Array of 2-10 agent IDs to compose together',
+                            minItems: 2,
+                            maxItems: 10,
+                        },
+                        composition_type: {
+                            type: 'string',
+                            enum: ['sequential', 'parallel', 'router', 'map_reduce'],
+                            description: 'How agents are combined: sequential (A→B→C), parallel (A+B+C), router (A|B|C based on input), map_reduce (fan-out→process→aggregate)',
+                        },
+                        routing_config: {
+                            type: 'object',
+                            description: 'Required for router type. Maps conditions to agent IDs. Example: {"rules": [{"condition": "intent==product_inquiry", "agent_id": "..."}]}',
+                        },
+                        state_mapping: {
+                            type: 'object',
+                            description: 'Optional. Maps output fields from one agent to input fields of the next (for sequential type)',
+                        },
+                        aggregation_strategy: {
+                            type: 'string',
+                            description: 'Optional. For parallel/map_reduce: how to combine results (merge, concat, first_success, majority_vote)',
+                        },
+                    },
+                    required: ['name', 'description', 'sub_agent_ids', 'composition_type'],
+                },
+            },
+            {
+                name: 'list_composed_agents',
+                description: 'List all composed/composite agents owned by the authenticated user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        page: {
+                            type: 'number',
+                            description: 'Page number (default: 1)',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Results per page (default: 20, max: 100)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'get_composed_agent',
+                description: 'Get detailed information about a composed agent including its sub-agents, composition type, pricing, and execution flow',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Composed agent ID',
+                        },
+                    },
+                    required: ['agent_id'],
+                },
+            },
+            {
+                name: 'preview_composition',
+                description: 'Preview a composition before creating it. Shows pricing breakdown (individual prices, bundle discount, final price) and execution flow diagram. Use this to validate a composition before committing.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        sub_agent_ids: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Array of 2-10 agent IDs to preview',
+                            minItems: 2,
+                            maxItems: 10,
+                        },
+                        composition_type: {
+                            type: 'string',
+                            enum: ['sequential', 'parallel', 'router', 'map_reduce'],
+                            description: 'How agents would be combined',
+                        },
+                    },
+                    required: ['sub_agent_ids', 'composition_type'],
+                },
+            },
+            {
+                name: 'execute_composed_agent',
+                description: 'Execute a composed agent with input data. Routes input through the composition pipeline (sequential/parallel/router/map_reduce) and returns aggregated results from all sub-agents.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'Composed agent ID to execute',
+                        },
+                        input_data: {
+                            type: 'object',
+                            description: 'Input data to pass to the composed agent pipeline',
+                        },
+                    },
+                    required: ['agent_id'],
+                },
+            },
+            {
+                name: 'list_agent_types',
+                description: 'List available agent type templates that serve as starting points for creating agents. Returns pre-seeded templates like instagram_dm_sales, whatsapp_business, email_marketing, telegram_support with their default configurations, pricing, and required integrations.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            {
+                name: 'get_mcp_plan_limits',
+                description: 'Show your current subscription plan limits for MCP agent operations — how many agents you can create, how many pods you can deploy, and current usage. Call this first if you are unsure whether an operation will be allowed.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            {
+                name: 'clone_agent',
+                description: 'Clone an existing agent as a starting point for a new one. Creates a deep copy with graph, wizard_configuration, and pricing copied over. New agent starts in draft status. Useful for creating variations of existing agents.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agent_id: {
+                            type: 'string',
+                            description: 'ID of the agent to clone',
+                        },
+                        new_name: {
+                            type: 'string',
+                            description: 'Name for the cloned agent',
+                        },
+                    },
+                    required: ['agent_id', 'new_name'],
+                },
+            },
+        ];
+    }
+    // Tool Handlers
+    /**
+     * Validate workflow structure before sending to API
+     */
+    validateWorkflowStructure(workflow) {
+        const errors = [];
+        // Validate name
+        if (!workflow.name || workflow.name.trim().length === 0) {
+            errors.push('Workflow name is required');
+        }
+        // Validate nodes
+        if (!workflow.nodes || workflow.nodes.length === 0) {
+            errors.push('At least one node is required');
+        }
+        else {
+            workflow.nodes.forEach((node, index) => {
+                if (!node.id)
+                    errors.push(`Node ${index}: missing required field 'id'`);
+                if (!node.type)
+                    errors.push(`Node ${index}: missing required field 'type'`);
+                if (!node.title)
+                    errors.push(`Node ${index}: missing required field 'title'`);
+            });
+        }
+        // Validate connections
+        if (workflow.connections && workflow.connections.length > 0) {
+            workflow.connections.forEach((conn, index) => {
+                if (!conn.id)
+                    errors.push(`Connection ${index}: missing required field 'id'`);
+                if (!conn.source)
+                    errors.push(`Connection ${index}: missing required field 'source'`);
+                if (!conn.target)
+                    errors.push(`Connection ${index}: missing required field 'target'`);
+                // Check if source/target nodes exist
+                const sourceExists = workflow.nodes.some((n) => n.id === conn.source);
+                const targetExists = workflow.nodes.some((n) => n.id === conn.target);
+                if (!sourceExists)
+                    errors.push(`Connection ${index}: source node '${conn.source}' not found`);
+                if (!targetExists)
+                    errors.push(`Connection ${index}: target node '${conn.target}' not found`);
+            });
+        }
+        return errors;
+    }
+    /**
+     * Format error messages for better user experience
+     */
+    formatErrorMessage(error) {
+        // Network errors
+        if (error.code === 'ECONNREFUSED') {
+            return `❌ Cannot connect to AgentBuilder API at ${this.client['apiBaseUrl']}\n\n` +
+                `Please ensure the backend is running and accessible.`;
+        }
+        // API errors with response
+        if (error.response) {
+            const status = error.response.status;
+            const message = error.response.data?.error?.message || error.response.data?.detail || error.message;
+            if (status === 401) {
+                return `🔒 Authentication failed\n\n${message}\n\n` +
+                    `Please run set_connection or set_auth_token first.`;
+            }
+            if (status === 400) {
+                return `⚠️ Validation error\n\n${message}\n\n` +
+                    `Please check your workflow structure matches the required format.`;
+            }
+            if (status === 404) {
+                return `❓ Not found\n\n${message}`;
+            }
+            return `❌ API Error (${status})\n\n${message}`;
+        }
+        // Generic errors
+        return `❌ Error: ${error.message}`;
+    }
+    async handleSetConnection(args) {
+        const { connection_id } = args;
+        try {
+            // Validate connection with backend
+            const response = await this.client.validateConnection(connection_id);
+            if (response.success) {
+                // Set connection ID in client
+                this.client.setConnection(connection_id);
+                const workspaceName = response.data.workspace_name;
+                const status = response.data.status;
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `✅ Successfully connected to AgentBuilder workspace: "${workspaceName}"\n\n` +
+                                `Connection Status: ${status}\n` +
+                                `Connection ID: ${connection_id}\n\n` +
+                                `You can now create workflows, and they will be saved to this workspace.`,
+                        },
+                    ],
+                };
+            }
+            else {
+                throw new Error(response.message || 'Connection validation failed');
+            }
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.error?.message || error.message;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Failed to connect with connection ID: ${connection_id}\n\n` +
+                            `Error: ${errorMessage}\n\n` +
+                            `Please ensure:\n` +
+                            `1. You've created an MCP connection in the AgentBuilder dashboard\n` +
+                            `2. The connection ID is correct (format: mcp_conn_xxx)\n` +
+                            `3. The connection is active and hasn't expired or been revoked\n` +
+                            `4. The backend API is accessible at ${this.client['apiBaseUrl']}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    async handleSetAuthToken(args) {
+        this.client.setAuthToken(args.token);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: 'Authentication token set successfully. You can now use workflow tools.',
+                },
+            ],
+        };
+    }
+    async handleCreateWorkflow(args) {
+        // Validate workflow structure
+        const validationErrors = this.validateWorkflowStructure({
+            name: args.name,
+            nodes: args.nodes || [],
+            connections: args.connections || []
+        });
+        if (validationErrors.length > 0) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `⚠️ Workflow validation failed:\n\n${validationErrors.map(err => `• ${err}`).join('\n')}\n\n` +
+                            `Please fix these issues and try again.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const result = await this.client.createWorkflow(args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleListWorkflows(args) {
+        const result = await this.client.listWorkflows(args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleGetWorkflow(args) {
+        const result = await this.client.getWorkflow(args.workflow_id);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleUpdateWorkflow(args) {
+        const result = await this.client.updateWorkflow(args.workflow_id, args.updates);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleExecuteWorkflow(args) {
+        const result = await this.client.executeWorkflow(args.workflow_id, args.input);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleGetExecutionStatus(args) {
+        const result = await this.client.getExecutionStatus(args.execution_id);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleListExecutions(args) {
+        const result = await this.client.listExecutions(args.workflow_id);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleDeleteWorkflow(args) {
+        const result = await this.client.deleteWorkflow(args.workflow_id);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleValidateWorkflow(args) {
+        const result = await this.client.validateWorkflow(args.workflow);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleCheckDeploymentReadiness(args) {
+        const result = await this.client.checkDeploymentReadiness(args.workflow_id);
+        const status = result.data;
+        let message = `## Deployment Readiness: ${args.workflow_id}\n\n`;
+        message += `**Status**: ${status.can_deploy ? '✅ Ready' : '⚠️ Not Ready'}\n\n`;
+        if (status.required_credentials && status.required_credentials.length > 0) {
+            message += `### Required Credentials:\n`;
+            status.required_credentials.forEach((cred) => {
+                const icon = cred.is_configured ? '✅' : '❌';
+                message += `${icon} **${cred.display_name}**\n`;
+                if (!cred.is_configured && cred.setup_url) {
+                    message += `   Setup: ${status.setup_base_url || ''}${cred.setup_url}\n`;
+                }
+            });
+        }
+        if (status.missing_credentials && status.missing_credentials.length > 0) {
+            message += `\n⚠️ **Missing**: ${status.missing_credentials.map((c) => c.display_name).join(', ')}\n`;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: message,
+                },
+            ],
+        };
+    }
+    async handleDeployWorkflow(args) {
+        const result = await this.client.deployWorkflow(args.workflow_id, {
+            instance_name: args.instance_name,
+            price_per_execution: args.price_per_execution,
+        });
+        const deployment = result.data;
+        let message = `## ✅ Deployment Successful!\n\n`;
+        message += `**Instance ID**: ${deployment.instance_id}\n`;
+        message += `**Status**: ${deployment.status}\n`;
+        message += `**Endpoint**: ${deployment.platform_endpoint}\n\n`;
+        if (deployment.demo_api_key) {
+            message += `**Demo API Key**: ${deployment.demo_api_key}\n`;
+            message += `Use this key to test your deployment.\n`;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: message,
+                },
+            ],
+        };
+    }
+    async handleListMCPWorkflows(args) {
+        const result = await this.client.listMCPWorkflows(args.filter);
+        let message = `## MCP Workflows\n\n`;
+        if (result.data && result.data.workflows && result.data.workflows.length > 0) {
+            result.data.workflows.forEach((workflow) => {
+                message += `### ${workflow.name}\n`;
+                message += `- **ID**: ${workflow.id}\n`;
+                message += `- **Status**: ${workflow.status}\n`;
+                message += `- **Deployment**: ${workflow.deployment_status || 'Not deployed'}\n`;
+                if (workflow.required_credentials) {
+                    message += `- **Required Credentials**: ${workflow.required_credentials.join(', ')}\n`;
+                }
+                message += `\n`;
+            });
+        }
+        else {
+            message += `No MCP workflows found.\n`;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: message,
+                },
+            ],
+        };
+    }
+    async handleListAgents(args) {
+        const result = await this.client.listAgents(args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleGetAgent(args) {
+        const result = await this.client.getAgent(args.agent_id);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleExecuteAgent(args) {
+        const result = await this.client.executeAgent(args.agent_id, args.input);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleDeployAgent(args) {
+        // Auto-populate runtime_image from the agent's MongoDB record so that new
+        // deployments always use the agent-type-pinned image rather than :latest.
+        // The caller may still pass an explicit image in deployment_config.image to
+        // override (e.g. for testing a canary build).
+        const deploymentConfig = { ...(args.deployment_config || {}) };
+        if (!deploymentConfig.image) {
+            try {
+                const agentDoc = await this.client.getAgent(args.agent_id);
+                const pinnedImage = agentDoc?.data?.runtime_image || agentDoc?.runtime_image;
+                if (pinnedImage) {
+                    deploymentConfig.image = pinnedImage;
+                }
+            }
+            catch {
+                // Non-fatal: provisioner will fall back to agent-runtime:latest
+            }
+        }
+        const result = await this.client.deployAgent(args.agent_id, deploymentConfig);
+        // Format response for better readability
+        let formattedMessage = `✅ Agent Deployment Initiated\n\n`;
+        formattedMessage += `📋 Deployment Details:\n`;
+        formattedMessage += `   Agent: ${result.agent_name}\n`;
+        formattedMessage += `   Deployment ID: ${result.deployment_id}\n`;
+        formattedMessage += `   Status: ${result.status}\n`;
+        formattedMessage += `   Namespace: ${result.namespace}\n`;
+        formattedMessage += `   Replicas: ${result.replicas}\n`;
+        formattedMessage += `   Created: ${result.created_at}\n\n`;
+        if (deploymentConfig.image) {
+            formattedMessage += `   Runtime Image: ${deploymentConfig.image}\n\n`;
+        }
+        formattedMessage += `⏱️  ${result.message}\n\n`;
+        if (result.endpoint_url) {
+            formattedMessage += `🌐 Endpoint: ${result.endpoint_url}\n\n`;
+        }
+        if (result.dashboard_url) {
+            formattedMessage += `📊 Dashboard: ${result.dashboard_url}\n\n`;
+        }
+        formattedMessage += `📋 Next Steps:\n`;
+        formattedMessage += `   1. Monitor deployment status in seller/admin dashboard\n`;
+        formattedMessage += `   2. Wait 2-3 minutes for pods to become ready\n`;
+        formattedMessage += `   3. Check endpoint health once deployed\n`;
+        formattedMessage += `   4. Configure custom domain (optional)\n\n`;
+        formattedMessage += `💡 View deployment in dashboard:\n`;
+        formattedMessage += `   https://agents.chatslytics.com/seller/instances\n\n`;
+        formattedMessage += `Raw Response:\n${JSON.stringify(result, null, 2)}`;
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: formattedMessage,
+                },
+            ],
+        };
+    }
+    async handleRedeployAgent(args) {
+        const body = args.runtime_image ? { runtime_image: args.runtime_image } : {};
+        const result = await this.client.redeployAgent(args.agent_id, body);
+        let msg = `🔄 Agent Redeployment Triggered\n\n`;
+        msg += `📋 Details:\n`;
+        msg += `   Agent: ${result.agent_name}\n`;
+        msg += `   Image: ${result.runtime_image || '(unchanged)'}\n`;
+        msg += `   Subscription: ${result.subscription_id}\n`;
+        msg += `   Dashboard: ${result.dashboard_url}\n\n`;
+        msg += `⏱️  ${result.message}\n\n`;
+        msg += `💡 What was updated:\n`;
+        msg += `   • ConfigMap patched with latest agent graph from MongoDB\n`;
+        msg += `   • Pod rolling restart triggered\n`;
+        if (args.runtime_image) {
+            msg += `   • Container image updated to: ${args.runtime_image}\n`;
+        }
+        msg += `\n📊 Monitor pod status:\n`;
+        msg += `   kubectl get pods -n default | grep ${result.subscription_id?.slice(-8) || 'agent'}\n`;
+        return { content: [{ type: 'text', text: msg }] };
+    }
+    async handleGetMcpPlanLimits() {
+        const result = await this.client.getMcpPlanLimits();
+        const agentBar = result.agents.limit === 'unlimited'
+            ? `${result.agents.used} used (unlimited)`
+            : `${result.agents.used}/${result.agents.limit} used (${result.agents.remaining} remaining)`;
+        const podBar = result.deployments.limit === 'unlimited'
+            ? `${result.deployments.used} active (unlimited)`
+            : `${result.deployments.used}/${result.deployments.limit} active (${result.deployments.remaining} remaining)`;
+        let msg = `📋 MCP Plan Limits — ${result.plan} Plan\n\n`;
+        msg += `🤖 Agents:       ${agentBar}\n`;
+        msg += `🚀 Active Pods:  ${podBar}\n`;
+        msg += `🔧 Deploy:       ${result.deployments.can_deploy ? '✅ Allowed' : '❌ Upgrade required'}\n\n`;
+        if (!result.deployments.can_deploy) {
+            msg += `⚠️  Deployment requires Basic plan or higher.\n`;
+            msg += `   Upgrade at: https://agents.chatslytics.com/settings/billing\n`;
+        }
+        else if (result.deployments.remaining === 0 && result.deployments.limit !== 'unlimited') {
+            msg += `⚠️  Active pod limit reached. Deprovision an agent or upgrade your plan.\n`;
+        }
+        else if (result.agents.remaining === 0 && result.agents.limit !== 'unlimited') {
+            msg += `⚠️  Agent creation limit reached. Upgrade your plan to create more agents.\n`;
+        }
+        return { content: [{ type: 'text', text: msg }] };
+    }
+    // ==========================================
+    // AGENT MANAGEMENT HANDLERS
+    // ==========================================
+    async handleCreateAgent(args) {
+        const result = await this.client.createAgent(args);
+        let message = `✅ Agent Created Successfully\n\n`;
+        message += `📋 Agent Details:\n`;
+        message += `   Name: ${result.name}\n`;
+        message += `   ID: ${result.id}\n`;
+        message += `   Slug: ${result.slug}\n`;
+        message += `   Type: ${result.type}\n`;
+        message += `   Category: ${result.category}\n`;
+        message += `   Status: ${result.status}\n\n`;
+        message += `📝 Next Steps:\n`;
+        message += `   1. Set wizard configuration: set_agent_wizard_config\n`;
+        message += `   2. Define agent graph: set_agent_graph\n`;
+        message += `   3. Validate agent: validate_agent_configuration\n`;
+        message += `   4. Publish agent: publish_agent\n\n`;
+        message += `Raw Response:\n${JSON.stringify(result, null, 2)}`;
+        return {
+            content: [{ type: 'text', text: message }],
+        };
+    }
+    async handleUpdateAgent(args) {
+        const result = await this.client.updateAgent(args.agent_id, args.updates);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `✅ Agent Updated Successfully\n\n${JSON.stringify(result, null, 2)}`
+                }],
+        };
+    }
+    async handleSetAgentWizardConfig(args) {
+        const result = await this.client.setAgentWizardConfig(args.agent_id, args.wizard_configuration);
+        let message = `✅ Wizard Configuration Set Successfully\n\n`;
+        message += `📋 Configuration Details:\n`;
+        message += `   Agent ID: ${args.agent_id}\n`;
+        const config = args.wizard_configuration;
+        if (config.required_oauth_providers?.length > 0) {
+            message += `   OAuth Providers: ${config.required_oauth_providers.join(', ')}\n`;
+        }
+        if (config.required_credentials?.length > 0) {
+            message += `   Credentials: ${config.required_credentials.map((c) => c.key).join(', ')}\n`;
+        }
+        if (config.required_platform_config?.length > 0) {
+            message += `   Platform Config Fields: ${config.required_platform_config.length}\n`;
+        }
+        if (config.custom_wizard_steps?.length > 0) {
+            message += `   Custom Steps: ${config.custom_wizard_steps.length}\n`;
+        }
+        message += `\n📝 Next Step: Define agent graph with set_agent_graph\n\n`;
+        message += `Raw Response:\n${JSON.stringify(result, null, 2)}`;
+        return {
+            content: [{ type: 'text', text: message }],
+        };
+    }
+    async handleSetAgentGraph(args) {
+        const result = await this.client.setAgentGraph(args.agent_id, args.graph);
+        let message = `✅ Agent Graph Set Successfully\n\n`;
+        message += `📋 Graph Details:\n`;
+        message += `   Agent ID: ${args.agent_id}\n`;
+        const graph = args.graph;
+        if (graph.nodes) {
+            message += `   Nodes: ${graph.nodes.length}\n`;
+            message += `   Node Types: ${graph.nodes.map((n) => n.type).join(', ')}\n`;
+        }
+        if (graph.edges) {
+            message += `   Edges: ${graph.edges.length}\n`;
+        }
+        if (graph.entry_point) {
+            message += `   Entry Point: ${graph.entry_point}\n`;
+        }
+        message += `\n📝 Next Steps:\n`;
+        message += `   1. Validate agent: validate_agent_configuration\n`;
+        message += `   2. Publish agent: publish_agent\n\n`;
+        message += `Raw Response:\n${JSON.stringify(result, null, 2)}`;
+        return {
+            content: [{ type: 'text', text: message }],
+        };
+    }
+    async handleValidateAgentConfiguration(args) {
+        const result = await this.client.validateAgentConfiguration(args.agent_id);
+        let message = result.valid
+            ? `✅ Agent Validation Passed\n\n`
+            : `❌ Agent Validation Failed\n\n`;
+        message += `📋 Validation Checklist:\n`;
+        for (const [check, passed] of Object.entries(result.checklist || {})) {
+            message += `   ${passed ? '✅' : '❌'} ${check}\n`;
+        }
+        if (result.errors && result.errors.length > 0) {
+            message += `\n🚨 Errors:\n`;
+            result.errors.forEach((error) => {
+                message += `   • ${error}\n`;
+            });
+        }
+        if (result.warnings && result.warnings.length > 0) {
+            message += `\n⚠️  Warnings:\n`;
+            result.warnings.forEach((warning) => {
+                message += `   • ${warning}\n`;
+            });
+        }
+        if (result.valid) {
+            message += `\n📝 Next Step: Publish agent with publish_agent\n`;
+        }
+        else {
+            message += `\n📝 Fix the errors above and run validation again\n`;
+        }
+        message += `\nRaw Response:\n${JSON.stringify(result, null, 2)}`;
+        return {
+            content: [{ type: 'text', text: message }],
+        };
+    }
+    async handlePublishAgent(args) {
+        const result = await this.client.publishAgent(args.agent_id);
+        let message = `✅ ${result.message}\n\n`;
+        message += `📋 Publication Details:\n`;
+        message += `   Agent: ${result.agent_name}\n`;
+        message += `   Agent ID: ${result.agent_id}\n`;
+        message += `   Status: ${result.status}\n`;
+        if (result.marketplace_url) {
+            message += `   Marketplace URL: ${result.marketplace_url}\n`;
+        }
+        if (result.status === 'pending_review') {
+            message += `\n⏳ Your agent is now pending review by admins.\n`;
+            message += `You'll be notified once it's approved and appears in the marketplace.\n`;
+        }
+        else {
+            message += `\n🎉 Your agent is now live in the marketplace!\n`;
+            message += `Users can now subscribe and deploy your agent.\n`;
+        }
+        message += `\nRaw Response:\n${JSON.stringify(result, null, 2)}`;
+        return {
+            content: [{ type: 'text', text: message }],
+        };
+    }
+    // ==========================================
+    // DASHBOARD HANDLERS
+    // ==========================================
+    async handleCreateAgentDashboard(args) {
+        const config = {};
+        if (args.template_type)
+            config.template_type = args.template_type;
+        if (args.layout)
+            config.layout = args.layout;
+        if (args.navigation)
+            config.navigation = args.navigation;
+        if (args.widgets)
+            config.widgets = args.widgets;
+        if (args.tabs)
+            config.tabs = args.tabs;
+        if (args.theme)
+            config.theme = args.theme;
+        if (args.branding)
+            config.branding = args.branding;
+        const result = await this.client.createAgentDashboard(args.agent_id, config);
+        let message = `✅ Dashboard Created for Agent: ${args.agent_id}\n\n`;
+        message += `📋 Configuration:\n`;
+        message += `   Template: ${args.template_type || 'default'}\n`;
+        message += `   Layout: ${args.layout || 'standard'}\n`;
+        message += `   Navigation: ${args.navigation || 'sidebar'}\n`;
+        if (args.tabs) {
+            message += `   Tabs: ${args.tabs.map((t) => t.label).join(', ')}\n`;
+        }
+        else {
+            message += `   Widgets: ${args.widgets?.join(', ') || 'default set'}\n`;
+        }
+        if (args.branding?.brand_name) {
+            message += `   Brand: ${args.branding.brand_name}\n`;
+        }
+        message += `\n🔗 Dashboard URL: Will be available after subscription deployment\n`;
+        message += `   Format: https://{subscription_id}.agents.chatslytics.com\n\n`;
+        message += `Raw Response:\n${JSON.stringify(result, null, 2)}`;
+        return {
+            content: [{ type: 'text', text: message }],
+        };
+    }
+    async handleGetAgentDashboardConfig(args) {
+        const result = await this.client.getAgentDashboardConfig(args.agent_id);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    async handleUpdateAgentDashboard(args) {
+        const result = await this.client.updateAgentDashboard(args.agent_id, args.updates);
+        return {
+            content: [{ type: 'text', text: `✅ Dashboard updated successfully\n\n${JSON.stringify(result, null, 2)}` }],
+        };
+    }
+    async handleAddDashboardWidget(args) {
+        const result = await this.client.addDashboardWidget(args.agent_id, {
+            widget_type: args.widget_type,
+            title: args.title,
+            position: args.position,
+            size: args.size,
+            config: args.config,
+        });
+        let message = `✅ Widget Added: ${args.title}\n\n`;
+        message += `📊 Widget Details:\n`;
+        message += `   Type: ${args.widget_type}\n`;
+        message += `   Position: ${args.position ? `(${args.position.x}, ${args.position.y})` : 'auto'}\n`;
+        message += `   Size: ${args.size ? `${args.size.width}x${args.size.height}` : 'default'}\n\n`;
+        message += `Raw Response:\n${JSON.stringify(result, null, 2)}`;
+        return {
+            content: [{ type: 'text', text: message }],
+        };
+    }
+    async handleConfigureAgentPage(args) {
+        const result = await this.client.configureAgentPage(args.agent_id, {
+            page_type: args.page_type,
+            content: args.content,
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `✅ ${args.page_type.charAt(0).toUpperCase() + args.page_type.slice(1)} page configured successfully\n\n${JSON.stringify(result, null, 2)}`,
+                },
+            ],
+        };
+    }
+    // ==========================================
+    // WIDGET GENERATION HANDLERS
+    // ==========================================
+    async handleGenerateDashboardWidget(args) {
+        const result = await this.client.generateWidget({
+            agent_id: args.agent_id,
+            widget_name: args.widget_name,
+            source_code: args.source_code,
+            description: args.description,
+        });
+        // Auto-add the generated widget to the agent's dashboard config
+        const widgetData = result.data || result;
+        if (widgetData.build_status === 'success' && widgetData.cdn_url) {
+            try {
+                await this.client.addDashboardWidget(args.agent_id, {
+                    widget_type: 'custom',
+                    title: args.widget_name.replace(/_/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase()),
+                    config: {
+                        type: `dynamic:${args.widget_name}`,
+                        cdn_url: widgetData.cdn_url,
+                        widget_name: args.widget_name,
+                    },
+                });
+            }
+            catch (e) {
+                // Non-fatal: widget is compiled but dashboard auto-add failed
+                console.warn(`Auto-add to dashboard failed: ${e.message}`);
+            }
+        }
+        let message = `✅ Custom Widget Compiled & Deployed: ${args.widget_name}\n\n`;
+        message += `📦 Build Details:\n`;
+        message += `   Status: ${widgetData.build_status}\n`;
+        message += `   CDN URL: ${widgetData.cdn_url || 'N/A'}\n`;
+        message += `   Bundle Size: ${widgetData.bundle_size_bytes ? `${(widgetData.bundle_size_bytes / 1024).toFixed(1)} KB` : 'N/A'}\n`;
+        message += `   Version: ${widgetData.version || 1}\n\n`;
+        message += `📋 Dashboard Integration:\n`;
+        message += `   Widget type: dynamic:${args.widget_name}\n`;
+        message += `   The widget has been automatically added to the agent's dashboard.\n\n`;
+        message += `Raw Response:\n${JSON.stringify(widgetData, null, 2)}`;
+        return {
+            content: [{ type: 'text', text: message }],
+        };
+    }
+    async handleListGeneratedWidgets(args) {
+        const result = await this.client.listGeneratedWidgets(args.agent_id);
+        const widgets = result.widgets || result.data?.widgets || [];
+        if (widgets.length === 0) {
+            return {
+                content: [{ type: 'text', text: `No generated widgets found for agent ${args.agent_id}` }],
+            };
+        }
+        let message = `📦 Generated Widgets for Agent ${args.agent_id}:\n\n`;
+        for (const w of widgets) {
+            message += `  • ${w.widget_id} (v${w.version}) — ${w.build_status}\n`;
+            message += `    CDN: ${w.cdn_url || 'N/A'}\n`;
+            message += `    Prompt: "${(w.prompt || '').substring(0, 80)}${(w.prompt || '').length > 80 ? '...' : ''}"\n\n`;
+        }
+        return {
+            content: [{ type: 'text', text: message }],
+        };
+    }
+    async handleRegenerateWidget(args) {
+        const result = await this.client.regenerateWidget(args.widget_id, args.agent_id, {
+            source_code: args.source_code,
+            description: args.description,
+        });
+        const widgetData = result.data || result;
+        let message = `🔄 Widget Regenerated: ${args.widget_id}\n\n`;
+        message += `   New Version: ${widgetData.version}\n`;
+        message += `   CDN URL: ${widgetData.cdn_url || 'N/A'}\n`;
+        message += `   Bundle Size: ${widgetData.bundle_size_bytes ? `${(widgetData.bundle_size_bytes / 1024).toFixed(1)} KB` : 'N/A'}\n`;
+        message += `   Status: ${widgetData.build_status}\n\n`;
+        message += `Raw Response:\n${JSON.stringify(widgetData, null, 2)}`;
+        return {
+            content: [{ type: 'text', text: message }],
+        };
+    }
+    async handleDeleteGeneratedWidget(args) {
+        const result = await this.client.deleteGeneratedWidget(args.widget_id, args.agent_id);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `🗑️ Widget "${args.widget_id}" deleted successfully.\n\nNote: CDN bundles are retained (immutable). The widget will no longer appear in dashboard configurations.\n\n${JSON.stringify(result, null, 2)}`,
+                },
+            ],
+        };
+    }
+    // ==========================================
+    // AGENT COMPOSITION HANDLERS
+    // ==========================================
+    async handleComposeAgents(args) {
+        // Validate sub_agent_ids count
+        const subAgentIds = args.sub_agent_ids || [];
+        if (subAgentIds.length < 2 || subAgentIds.length > 10) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: '⚠️ Composition requires between 2 and 10 sub-agents. ' +
+                            `You provided ${subAgentIds.length}.`,
+                    }],
+                isError: true,
+            };
+        }
+        const result = await this.client.composeAgents({
+            name: args.name,
+            description: args.description,
+            sub_agent_ids: subAgentIds,
+            composition_type: args.composition_type,
+            routing_config: args.routing_config,
+            state_mapping: args.state_mapping,
+            aggregation_strategy: args.aggregation_strategy,
+        });
+        let message = `✅ Composed Agent Created Successfully\n\n`;
+        message += `📋 Composition Details:\n`;
+        message += `   Name: ${args.name}\n`;
+        message += `   Type: ${args.composition_type}\n`;
+        message += `   Sub-Agents: ${subAgentIds.length}\n`;
+        if (result.data?.id) {
+            message += `   Composed Agent ID: ${result.data.id}\n`;
+        }
+        if (result.data?.pricing) {
+            const p = result.data.pricing;
+            message += `\n💰 Bundle Pricing:\n`;
+            if (p.base_price !== undefined)
+                message += `   Base Price: ${p.currency || 'INR'} ${p.base_price}\n`;
+            if (p.bundle_discount !== undefined)
+                message += `   Bundle Discount: ${p.bundle_discount}%\n`;
+            if (p.final_price !== undefined)
+                message += `   Final Price: ${p.currency || 'INR'} ${p.final_price}\n`;
+        }
+        message += `\n📝 Next Steps:\n`;
+        message += `   1. Execute: execute_composed_agent\n`;
+        message += `   2. Preview: get_composed_agent for full details\n`;
+        message += `\nRaw Response:\n${JSON.stringify(result, null, 2)}`;
+        return {
+            content: [{ type: 'text', text: message }],
+        };
+    }
+    async handleListComposedAgents(args) {
+        const result = await this.client.listComposedAgents({
+            page: args?.page,
+            limit: args?.limit,
+        });
+        let message = `## Composed Agents\n\n`;
+        const agents = result.data?.agents || result.data || [];
+        if (Array.isArray(agents) && agents.length > 0) {
+            agents.forEach((agent) => {
+                message += `### ${agent.name}\n`;
+                message += `- **ID**: ${agent.id || agent._id}\n`;
+                message += `- **Type**: ${agent.composition_type}\n`;
+                message += `- **Sub-Agents**: ${agent.sub_agent_ids?.length || 0}\n`;
+                message += `- **Status**: ${agent.status || 'active'}\n\n`;
+            });
+        }
+        else {
+            message += `No composed agents found.\n`;
+        }
+        message += `\nRaw Response:\n${JSON.stringify(result, null, 2)}`;
+        return {
+            content: [{ type: 'text', text: message }],
+        };
+    }
+    async handleGetComposedAgent(args) {
+        const result = await this.client.getComposedAgent(args.agent_id);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                }],
+        };
+    }
+    async handlePreviewComposition(args) {
+        const result = await this.client.previewComposition({
+            sub_agent_ids: args.sub_agent_ids,
+            composition_type: args.composition_type,
+        });
+        let message = `## Composition Preview\n\n`;
+        message += `**Type**: ${args.composition_type}\n`;
+        message += `**Sub-Agents**: ${args.sub_agent_ids.length}\n\n`;
+        const data = result.data || result;
+        // Pricing breakdown
+        if (data.pricing) {
+            const p = data.pricing;
+            message += `### 💰 Pricing Breakdown\n`;
+            if (p.individual_prices && Array.isArray(p.individual_prices)) {
+                p.individual_prices.forEach((ip) => {
+                    message += `- ${ip.name}: ${ip.currency || 'INR'} ${ip.price}\n`;
+                });
+            }
+            if (p.base_price !== undefined)
+                message += `\n**Base Total**: ${p.currency || 'INR'} ${p.base_price}\n`;
+            if (p.bundle_discount !== undefined)
+                message += `**Bundle Discount**: ${p.bundle_discount}%\n`;
+            if (p.final_price !== undefined)
+                message += `**Final Price**: ${p.currency || 'INR'} ${p.final_price}\n`;
+        }
+        // Execution flow
+        if (data.execution_flow) {
+            message += `\n### 🔄 Execution Flow\n`;
+            message += `${data.execution_flow}\n`;
+        }
+        message += `\n📝 To create this composition, use compose_agents with the same parameters.\n`;
+        message += `\nRaw Response:\n${JSON.stringify(result, null, 2)}`;
+        return {
+            content: [{ type: 'text', text: message }],
+        };
+    }
+    async handleExecuteComposedAgent(args) {
+        const result = await this.client.executeComposedAgent(args.agent_id, args.input_data);
+        let message = `## Composed Agent Execution\n\n`;
+        const data = result.data || result;
+        if (data.success !== undefined) {
+            message += `**Status**: ${data.success ? '✅ Success' : '❌ Failed'}\n`;
+        }
+        if (data.execution_id) {
+            message += `**Execution ID**: ${data.execution_id}\n`;
+        }
+        if (data.output) {
+            message += `\n### Output\n\`\`\`json\n${JSON.stringify(data.output, null, 2)}\n\`\`\`\n`;
+        }
+        if (data.metadata) {
+            message += `\n### Metadata\n\`\`\`json\n${JSON.stringify(data.metadata, null, 2)}\n\`\`\`\n`;
+        }
+        if (data.error) {
+            message += `\n### Error\n${data.error}\n`;
+        }
+        message += `\nRaw Response:\n${JSON.stringify(result, null, 2)}`;
+        return {
+            content: [{ type: 'text', text: message }],
+        };
+    }
+    async handleListAgentTypes(args) {
+        const result = await this.client.listAgentTypes();
+        let message = `## Available Agent Type Templates\n\n`;
+        message += `These are pre-built templates that can be used as starting points for creating agents.\n\n`;
+        const types = result.data?.agent_types || result.agent_types || result.data || [];
+        if (Array.isArray(types) && types.length > 0) {
+            types.forEach((t) => {
+                message += `### ${t.display_name || t.name}\n`;
+                message += `- **Slug**: ${t.type_slug || t.slug}\n`;
+                message += `- **Category**: ${t.category}\n`;
+                message += `- **Description**: ${t.description}\n`;
+                if (t.platform_requirements) {
+                    message += `- **Platforms**: ${JSON.stringify(t.platform_requirements)}\n`;
+                }
+                if (t.default_pricing) {
+                    message += `- **Default Pricing**: ${JSON.stringify(t.default_pricing)}\n`;
+                }
+                message += `\n`;
+            });
+        }
+        else {
+            message += `No agent type templates found.\n`;
+        }
+        message += `\n📝 Use create_agent or clone_agent to start from a template.\n`;
+        message += `\nRaw Response:\n${JSON.stringify(result, null, 2)}`;
+        return {
+            content: [{ type: 'text', text: message }],
+        };
+    }
+    async handleCloneAgent(args) {
+        const result = await this.client.cloneAgent(args.agent_id, args.new_name);
+        let message = `✅ Agent Cloned Successfully\n\n`;
+        message += `📋 Clone Details:\n`;
+        message += `   Original Agent: ${args.agent_id}\n`;
+        message += `   New Name: ${args.new_name}\n`;
+        const data = result.data || result;
+        if (data.id)
+            message += `   New Agent ID: ${data.id}\n`;
+        if (data.slug)
+            message += `   Slug: ${data.slug}\n`;
+        message += `   Status: draft\n\n`;
+        message += `📝 Next Steps:\n`;
+        message += `   1. Customize wizard: set_agent_wizard_config\n`;
+        message += `   2. Modify graph: set_agent_graph\n`;
+        message += `   3. Update pricing: update_agent\n`;
+        message += `   4. Validate: validate_agent_configuration\n`;
+        message += `   5. Publish: publish_agent\n\n`;
+        message += `Raw Response:\n${JSON.stringify(result, null, 2)}`;
+        return {
+            content: [{ type: 'text', text: message }],
+        };
+    }
+    async run() {
+        // If no auth, prompt browser login before starting
+        if (!this.client.isAuthenticated()) {
+            console.error('[MCP] No credentials found. Starting login flow...');
+            try {
+                const token = await promptLogin();
+                this.client.setAuthToken(token);
+                console.error('[MCP] Login successful. Starting server...');
+            }
+            catch (err) {
+                console.error(`[MCP] Login failed: ${err.message}`);
+                process.exit(1);
+            }
+        }
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        console.error('AgentBuilder MCP Server running on stdio');
+    }
+}
+// Start server
+const server = new AgentBuilderMCPServer();
+server.run().catch(console.error);
+//# sourceMappingURL=index.js.map