@chandshantanu/agentbuilder-mcp-server 0.2.0

package/src/index.ts

@@ -0,0 +1,3104 @@
+#!/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,
+  Tool,
+} from '@modelcontextprotocol/sdk/types.js';
+import axios, { AxiosInstance } 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(): string | null {
+  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: string, expiresIn: number = 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(): Promise<string> {
+  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() as any).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 {
+  private client: AxiosInstance;
+  private apiBaseUrl: string;
+  private authToken: string | null = null;  // DEPRECATED: Use connectionId instead
+  private connectionId: string | null = 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(): boolean {
+    return !!(this.connectionId || this.authToken);
+  }
+
+  /**
+   * Set MCP connection ID (Production OAuth)
+   * Obtains connection ID from dashboard after OAuth flow
+   */
+  setConnection(connectionId: string) {
+    this.connectionId = connectionId;
+    console.log(`[MCP] Connected with connection ID: ${connectionId}`);
+  }
+
+  /**
+   * Get connection ID from backend to validate connection
+   */
+  async validateConnection(connectionId: string): Promise<any> {
+    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: string) {
+    console.warn('⚠️  setAuthToken is deprecated for production use. Use setConnection() instead.');
+    this.authToken = token;
+  }
+
+  /**
+   * Create a new workflow
+   */
+  async createWorkflow(params: {
+    name: string;
+    description?: string;
+    nodes?: any[];
+    connections?: any[];
+    triggers?: any[];
+    max_execution_time?: number;
+    retry_attempts?: number;
+  }) {
+    const payload: any = {
+      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?: {
+    limit?: number;
+    offset?: number;
+    status?: string;
+  }) {
+    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: string) {
+    const response = await this.client.get(`/api/v1/workflows/${workflowId}`);
+    return response.data;
+  }
+
+  /**
+   * Update workflow
+   */
+  async updateWorkflow(workflowId: string, updates: any) {
+    const response = await this.client.put(`/api/v1/workflows/${workflowId}`, updates);
+    return response.data;
+  }
+
+  /**
+   * Execute workflow
+   */
+  async executeWorkflow(workflowId: string, input?: any) {
+    const response = await this.client.post(`/api/v1/workflows/${workflowId}/execute`, {
+      input: input || {},
+    });
+    return response.data;
+  }
+
+  /**
+   * Get workflow execution status
+   */
+  async getExecutionStatus(executionId: string) {
+    const response = await this.client.get(`/api/v1/executions/${executionId}`);
+    return response.data;
+  }
+
+  /**
+   * List workflow executions
+   */
+  async listExecutions(workflowId?: string) {
+    const params: any = {};
+    if (workflowId) {
+      params.workflow_id = workflowId;
+    }
+
+    const response = await this.client.get('/api/v1/executions', { params });
+    return response.data;
+  }
+
+  /**
+   * Delete workflow
+   */
+  async deleteWorkflow(workflowId: string) {
+    const response = await this.client.delete(`/api/v1/workflows/${workflowId}`);
+    return response.data;
+  }
+
+  /**
+   * Validate workflow
+   */
+  async validateWorkflow(workflow: any) {
+    const response = await this.client.post('/api/v1/workflows/validate', workflow);
+    return response.data;
+  }
+
+  /**
+   * Check if workflow is ready for deployment
+   */
+  async checkDeploymentReadiness(workflowId: string) {
+    const response = await this.client.get(
+      `/api/v1/workflows/${workflowId}/deployment-readiness`
+    );
+    return response.data;
+  }
+
+  /**
+   * Deploy workflow to production
+   */
+  async deployWorkflow(workflowId: string, config: {
+    instance_name: string;
+    price_per_execution?: number;
+  }) {
+    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?: string) {
+    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?: {
+    page?: number;
+    page_size?: number;
+    search?: string;
+    category?: string;
+    agent_type?: string;
+    pricing_model?: string;
+    agent_status?: string;
+    creator_id?: string;
+    is_featured?: boolean;
+    sort_by?: string;
+    sort_order?: string;
+  }) {
+    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: string) {
+    const response = await this.client.get(`/api/v1/agents/${agentId}`);
+    return response.data;
+  }
+
+  /**
+   * Execute an agent
+   */
+  async executeAgent(agentId: string, input?: any) {
+    const response = await this.client.post(`/api/v1/agents/${agentId}/execute`, {
+      input: input || {},
+    });
+    return response.data;
+  }
+
+  /**
+   * Deploy an agent to Kubernetes
+   */
+  async deployAgent(agentId: string, deploymentConfig?: any) {
+    const response = await this.client.post(`/api/v1/agents/${agentId}/deploy`, deploymentConfig || {});
+    return response.data;
+  }
+
+  async redeployAgent(agentId: string, body?: { runtime_image?: string }) {
+    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: {
+    name: string;
+    description: string;
+    type: string;
+    category: string;
+    wizard_configuration?: any;
+    graph?: any;
+    pricing?: any;
+    tags?: string[];
+    capabilities?: any[];
+    icon_url?: string;
+    banner_url?: string;
+    screenshots?: string[];
+    demo_url?: string;
+    video_url?: string;
+    detailed_description?: string;
+    is_public?: boolean;
+  }) {
+    const response = await this.client.post('/api/v1/agents', params);
+    return response.data;
+  }
+
+  /**
+   * Update an existing agent
+   */
+  async updateAgent(agentId: string, updates: any) {
+    const response = await this.client.put(`/api/v1/agents/${agentId}`, updates);
+    return response.data;
+  }
+
+  /**
+   * Set wizard configuration for an agent
+   */
+  async setAgentWizardConfig(agentId: string, wizardConfiguration: any) {
+    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: string, graph: any) {
+    const response = await this.client.put(`/api/v1/agents/${agentId}/graph`, graph);
+    return response.data;
+  }
+
+  /**
+   * Validate agent configuration before publishing
+   */
+  async validateAgentConfiguration(agentId: string) {
+    const response = await this.client.get(`/api/v1/agents/${agentId}/validate`);
+    return response.data;
+  }
+
+  /**
+   * Publish agent to marketplace
+   */
+  async publishAgent(agentId: string) {
+    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: string, dashboardConfig: {
+    template_type?: string;
+    layout?: 'minimal' | 'standard' | 'full';
+    navigation?: 'sidebar' | 'topbar';
+    widgets?: string[];
+    tabs?: Array<{ id: string; label: string; icon?: string; widgets: Array<{ type: string; config?: any }> }>;
+    theme?: any;
+    branding?: any;
+  }) {
+    const response = await this.client.post(`/api/v1/agents/${agentId}/dashboard/config`, dashboardConfig);
+    return response.data;
+  }
+
+  /**
+   * Get agent dashboard configuration
+   */
+  async getAgentDashboardConfig(agentId: string) {
+    const response = await this.client.get(`/api/v1/agents/${agentId}/dashboard/config`);
+    return response.data;
+  }
+
+  /**
+   * Update agent dashboard
+   */
+  async updateAgentDashboard(agentId: string, updates: any) {
+    const response = await this.client.put(`/api/v1/agents/${agentId}/dashboard/config`, updates);
+    return response.data;
+  }
+
+  /**
+   * Add widget to agent dashboard
+   */
+  async addDashboardWidget(agentId: string, widgetConfig: {
+    widget_type: 'chart' | 'list' | 'stats' | 'custom';
+    title: string;
+    position?: { x: number; y: number };
+    size?: { width: number; height: number };
+    config?: any;
+  }) {
+    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: string, pageConfig: {
+    page_type: 'landing' | 'configuration' | 'dashboard';
+    content: any;
+  }) {
+    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: {
+    name: string;
+    description: string;
+    sub_agent_ids: string[];
+    composition_type: 'sequential' | 'parallel' | 'router' | 'map_reduce';
+    routing_config?: any;
+    state_mapping?: any;
+    aggregation_strategy?: string;
+  }) {
+    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?: { page?: number; limit?: number }) {
+    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: string) {
+    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: {
+    sub_agent_ids: string[];
+    composition_type: 'sequential' | 'parallel' | 'router' | 'map_reduce';
+  }) {
+    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: string, inputData?: any) {
+    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: string) {
+    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: string, newName: string) {
+    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: {
+    agent_id: string;
+    widget_name: string;
+    source_code: string;
+    description?: string;
+  }) {
+    const response = await this.client.post('/api/v1/widgets/generate', params);
+    return response.data;
+  }
+
+  /**
+   * List generated widgets for an agent
+   */
+  async listGeneratedWidgets(agentId: string) {
+    const response = await this.client.get(`/api/v1/widgets/agent/${agentId}`);
+    return response.data;
+  }
+
+  /**
+   * Regenerate a widget with new source code
+   */
+  async regenerateWidget(widgetId: string, agentId: string, params: {
+    source_code: string;
+    description?: string;
+  }) {
+    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: string, agentId: string) {
+    const response = await this.client.delete(
+      `/api/v1/widgets/${widgetId}?agent_id=${agentId}`,
+    );
+    return response.data;
+  }
+
+}
+
+// MCP Server
+class AgentBuilderMCPServer {
+  private server: Server;
+  private client: AgentBuilderClient;
+
+  constructor() {
+    this.server = new Server(
+      {
+        name: 'agentbuilder-mcp-server',
+        version: '0.0.1',
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    );
+
+    this.client = new AgentBuilderClient();
+    this.setupHandlers();
+    this.setupErrorHandling();
+  }
+
+  private setupErrorHandling() {
+    this.server.onerror = (error) => {
+      console.error('[MCP Error]', error);
+    };
+
+    process.on('SIGINT', async () => {
+      await this.server.close();
+      process.exit(0);
+    });
+  }
+
+  private 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: any) {
+        const errorMessage = this.formatErrorMessage(error);
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: errorMessage,
+            },
+          ],
+          isError: true,
+        };
+      }
+    });
+  }
+
+  private getTools(): Tool[] {
+    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
+   */
+  private validateWorkflowStructure(workflow: any): string[] {
+    const errors: string[] = [];
+
+    // 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: any, index: number) => {
+        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: any, index: number) => {
+        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: any) => n.id === conn.source);
+        const targetExists = workflow.nodes.some((n: any) => 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
+   */
+  private formatErrorMessage(error: any): string {
+    // 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}`;
+  }
+
+  private async handleSetConnection(args: any) {
+    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: any) {
+      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,
+      };
+    }
+  }
+
+  private async handleSetAuthToken(args: any) {
+    this.client.setAuthToken(args.token);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: 'Authentication token set successfully. You can now use workflow tools.',
+        },
+      ],
+    };
+  }
+
+  private async handleCreateWorkflow(args: any) {
+    // 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),
+        },
+      ],
+    };
+  }
+
+  private async handleListWorkflows(args: any) {
+    const result = await this.client.listWorkflows(args);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async handleGetWorkflow(args: any) {
+    const result = await this.client.getWorkflow(args.workflow_id);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async handleUpdateWorkflow(args: any) {
+    const result = await this.client.updateWorkflow(args.workflow_id, args.updates);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async handleExecuteWorkflow(args: any) {
+    const result = await this.client.executeWorkflow(args.workflow_id, args.input);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async handleGetExecutionStatus(args: any) {
+    const result = await this.client.getExecutionStatus(args.execution_id);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async handleListExecutions(args: any) {
+    const result = await this.client.listExecutions(args.workflow_id);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async handleDeleteWorkflow(args: any) {
+    const result = await this.client.deleteWorkflow(args.workflow_id);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async handleValidateWorkflow(args: any) {
+    const result = await this.client.validateWorkflow(args.workflow);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async handleCheckDeploymentReadiness(args: any) {
+    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: any) => {
+        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: any) => c.display_name).join(', ')}\n`;
+    }
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: message,
+        },
+      ],
+    };
+  }
+
+  private async handleDeployWorkflow(args: any) {
+    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,
+        },
+      ],
+    };
+  }
+
+  private async handleListMCPWorkflows(args: any) {
+    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: any) => {
+        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,
+        },
+      ],
+    };
+  }
+
+  private async handleListAgents(args: any) {
+    const result = await this.client.listAgents(args);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async handleGetAgent(args: any) {
+    const result = await this.client.getAgent(args.agent_id);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async handleExecuteAgent(args: any) {
+    const result = await this.client.executeAgent(args.agent_id, args.input);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async handleDeployAgent(args: any) {
+    // 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,
+        },
+      ],
+    };
+  }
+
+  private async handleRedeployAgent(args: any) {
+    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 }] };
+  }
+
+  private 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
+  // ==========================================
+
+  private async handleCreateAgent(args: any) {
+    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 }],
+    };
+  }
+
+  private async handleUpdateAgent(args: any) {
+    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)}`
+      }],
+    };
+  }
+
+  private async handleSetAgentWizardConfig(args: any) {
+    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: any) => 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 }],
+    };
+  }
+
+  private async handleSetAgentGraph(args: any) {
+    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: any) => 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 }],
+    };
+  }
+
+  private async handleValidateAgentConfiguration(args: any) {
+    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: string) => {
+        message += `   • ${error}\n`;
+      });
+    }
+
+    if (result.warnings && result.warnings.length > 0) {
+      message += `\n⚠️  Warnings:\n`;
+      result.warnings.forEach((warning: string) => {
+        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 }],
+    };
+  }
+
+  private async handlePublishAgent(args: any) {
+    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
+  // ==========================================
+
+  private async handleCreateAgentDashboard(args: any) {
+    const config: any = {};
+    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: any) => 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 }],
+    };
+  }
+
+  private async handleGetAgentDashboardConfig(args: any) {
+    const result = await this.client.getAgentDashboardConfig(args.agent_id);
+    return {
+      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+  }
+
+  private async handleUpdateAgentDashboard(args: any) {
+    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)}` }],
+    };
+  }
+
+  private async handleAddDashboardWidget(args: any) {
+    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 }],
+    };
+  }
+
+  private async handleConfigureAgentPage(args: any) {
+    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
+  // ==========================================
+
+  private async handleGenerateDashboardWidget(args: any) {
+    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: string) => c.toUpperCase()),
+          config: {
+            type: `dynamic:${args.widget_name}`,
+            cdn_url: widgetData.cdn_url,
+            widget_name: args.widget_name,
+          },
+        });
+      } catch (e: any) {
+        // 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 }],
+    };
+  }
+
+  private async handleListGeneratedWidgets(args: any) {
+    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 }],
+    };
+  }
+
+  private async handleRegenerateWidget(args: any) {
+    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 }],
+    };
+  }
+
+  private async handleDeleteGeneratedWidget(args: any) {
+    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
+  // ==========================================
+
+  private async handleComposeAgents(args: any) {
+    // 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 }],
+    };
+  }
+
+  private async handleListComposedAgents(args: any) {
+    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: any) => {
+        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 }],
+    };
+  }
+
+  private async handleGetComposedAgent(args: any) {
+    const result = await this.client.getComposedAgent(args.agent_id);
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify(result, null, 2),
+      }],
+    };
+  }
+
+  private async handlePreviewComposition(args: any) {
+    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: any) => {
+          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 }],
+    };
+  }
+
+  private async handleExecuteComposedAgent(args: any) {
+    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 }],
+    };
+  }
+
+  private async handleListAgentTypes(args: any) {
+    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: any) => {
+        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 }],
+    };
+  }
+
+  private async handleCloneAgent(args: any) {
+    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: any) {
+        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);