langmart-gateway-type3 3.0.45 → 3.0.46

package/dist/agent-tools.js

@@ -0,0 +1,813 @@
+"use strict";
+/**
+ * Agent Tools - MCP Tools for Agent Management
+ *
+ * Provides tools for:
+ * - Agent Definitions (templates)
+ * - Agent Instances (running deployments)
+ * - Agent Workflows (graphs with nodes and edges)
+ * - Workflow Executions (execution history and traces)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentTools = exports.agentToolDefinitions = void 0;
+const axios_1 = __importDefault(require("axios"));
+// ============= TOOL DEFINITIONS =============
+exports.agentToolDefinitions = [
+    // ===== DEFINITIONS =====
+    {
+        type: 'function',
+        function: {
+            name: 'agents_definitions_list',
+            description: 'List all available agent definitions (templates). These are reusable agent configurations that can be instantiated. Response contains definition IDs that can be used with agents_definitions_get for full details, or agents_instances_list to see running instances of each definition.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    category: {
+                        type: 'string',
+                        description: 'Filter by category (e.g., "general", "coding", "analysis")'
+                    }
+                },
+                required: []
+            }
+        },
+        metadata: {
+            category: 'automation',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/agents/definitions',
+            apiMethod: 'GET',
+            tags: ['agents', 'definitions', 'list']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'agents_definitions_get',
+            description: 'Get details of a specific agent definition including its system prompt, tools, and configuration.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    definition_id: {
+                        type: 'string',
+                        description: 'Agent definition ID. Use agents_definitions_list first to find available definition IDs.'
+                    }
+                },
+                required: ['definition_id']
+            }
+        },
+        metadata: {
+            category: 'automation',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/agents/definitions/:id',
+            apiMethod: 'GET',
+            tags: ['agents', 'definitions', 'get']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'agents_definitions_create',
+            description: 'Create a new agent definition (template).',
+            parameters: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'Agent name'
+                    },
+                    description: {
+                        type: 'string',
+                        description: 'Agent description'
+                    },
+                    category: {
+                        type: 'string',
+                        description: 'Category (e.g., "general", "coding", "analysis")'
+                    },
+                    system_prompt: {
+                        type: 'string',
+                        description: 'System prompt for the agent'
+                    },
+                    default_model: {
+                        type: 'string',
+                        description: 'Default model to use (e.g., "openai/gpt-4o")'
+                    },
+                    icon: {
+                        type: 'string',
+                        description: 'Emoji icon for the agent'
+                    }
+                },
+                required: ['name']
+            }
+        },
+        metadata: {
+            category: 'automation',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/agents/definitions',
+            apiMethod: 'POST',
+            tags: ['agents', 'definitions', 'create']
+        }
+    },
+    // ===== INSTANCES =====
+    {
+        type: 'function',
+        function: {
+            name: 'agents_instances_list',
+            description: 'List all agent instances (running or stopped deployments). Response includes: definition_id (use agents_definitions_get for template details), workflow_id (use agents_workflows_get for workflow details), node_id (position in workflow graph).',
+            parameters: {
+                type: 'object',
+                properties: {
+                    workflow_id: {
+                        type: 'string',
+                        description: 'Filter by workflow ID'
+                    },
+                    status: {
+                        type: 'string',
+                        description: 'Filter by status',
+                        enum: ['ACTIVE', 'STOPPED', 'FAILED', 'COMPLETED', 'all']
+                    }
+                },
+                required: []
+            }
+        },
+        metadata: {
+            category: 'automation',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/agents/instances',
+            apiMethod: 'GET',
+            tags: ['agents', 'instances', 'list']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'agents_instances_get',
+            description: 'Get details of a specific agent instance including its status and configuration.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    instance_id: {
+                        type: 'string',
+                        description: 'Agent instance ID. Use agents_instances_list first to find available instance IDs.'
+                    }
+                },
+                required: ['instance_id']
+            }
+        },
+        metadata: {
+            category: 'automation',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/agents/instances/:id',
+            apiMethod: 'GET',
+            tags: ['agents', 'instances', 'get']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'agents_instances_trace',
+            description: 'Get the execution trace for an agent instance, showing the flow and status of execution.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    instance_id: {
+                        type: 'string',
+                        description: 'Agent instance ID. Use agents_instances_list first to find available instance IDs.'
+                    }
+                },
+                required: ['instance_id']
+            }
+        },
+        metadata: {
+            category: 'automation',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/agents/instances/:id/trace',
+            apiMethod: 'GET',
+            tags: ['agents', 'instances', 'trace']
+        }
+    },
+    // ===== WORKFLOWS =====
+    {
+        type: 'function',
+        function: {
+            name: 'agents_workflows_list',
+            description: 'List all agent workflows. Workflows define how agents connect and orchestrate. Response contains workflow IDs - use agents_workflows_get for details, agents_workflows_graph for node/edge visualization, agents_executions_list to see execution history.',
+            parameters: {
+                type: 'object',
+                properties: {},
+                required: []
+            }
+        },
+        metadata: {
+            category: 'automation',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/agents/workflows',
+            apiMethod: 'GET',
+            tags: ['agents', 'workflows', 'list']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'agents_workflows_get',
+            description: 'Get details of a specific workflow.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    workflow_id: {
+                        type: 'string',
+                        description: 'Workflow ID. Use agents_workflows_list first to find available workflow IDs.'
+                    }
+                },
+                required: ['workflow_id']
+            }
+        },
+        metadata: {
+            category: 'automation',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/agents/workflows/:id',
+            apiMethod: 'GET',
+            tags: ['agents', 'workflows', 'get']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'agents_workflows_graph',
+            description: 'Get the full workflow graph with all nodes and edges for visualization.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    workflow_id: {
+                        type: 'string',
+                        description: 'Workflow ID. Use agents_workflows_list first to find available workflow IDs.'
+                    }
+                },
+                required: ['workflow_id']
+            }
+        },
+        metadata: {
+            category: 'automation',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/agents/workflows/:id/graph',
+            apiMethod: 'GET',
+            tags: ['agents', 'workflows', 'graph']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'agents_workflows_create',
+            description: 'Create a new workflow.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'Workflow name'
+                    },
+                    description: {
+                        type: 'string',
+                        description: 'Workflow description'
+                    }
+                },
+                required: ['name']
+            }
+        },
+        metadata: {
+            category: 'automation',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/agents/workflows',
+            apiMethod: 'POST',
+            tags: ['agents', 'workflows', 'create']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'agents_workflows_assign',
+            description: 'Assign an agent definition or instance to a workflow, adding it as a node.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    workflow_id: {
+                        type: 'string',
+                        description: 'Workflow ID. Use agents_workflows_list to find workflow IDs.'
+                    },
+                    definition_id: {
+                        type: 'string',
+                        description: 'Agent definition ID to assign. Use agents_definitions_list to find definition IDs.'
+                    },
+                    instance_id: {
+                        type: 'string',
+                        description: 'Agent instance ID to assign (alternative to definition_id). Use agents_instances_list to find instance IDs.'
+                    }
+                },
+                required: ['workflow_id']
+            }
+        },
+        metadata: {
+            category: 'automation',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/agents/workflows/:id/assign',
+            apiMethod: 'POST',
+            tags: ['agents', 'workflows', 'assign']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'agents_workflows_ready',
+            description: 'Check if a workflow is ready to execute (all required nodes connected).',
+            parameters: {
+                type: 'object',
+                properties: {
+                    workflow_id: {
+                        type: 'string',
+                        description: 'Workflow ID. Use agents_workflows_list first to find workflow IDs.'
+                    }
+                },
+                required: ['workflow_id']
+            }
+        },
+        metadata: {
+            category: 'automation',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/agents/workflows/:id/ready',
+            apiMethod: 'GET',
+            tags: ['agents', 'workflows', 'ready']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'agents_workflows_execute',
+            description: 'Execute a workflow with the given input. This starts all agents in the workflow.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    workflow_id: {
+                        type: 'string',
+                        description: 'Workflow ID to execute. Use agents_workflows_list to find IDs, then agents_workflows_ready to check if ready.'
+                    },
+                    prompt: {
+                        type: 'string',
+                        description: 'Input prompt to start the workflow'
+                    },
+                    variables: {
+                        type: 'object',
+                        description: 'Variables to pass to the workflow'
+                    }
+                },
+                required: ['workflow_id', 'prompt']
+            }
+        },
+        metadata: {
+            category: 'automation',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: true,
+            apiEndpoint: '/api/agents/workflows/:id/execute',
+            apiMethod: 'POST',
+            tags: ['agents', 'workflows', 'execute']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'agents_workflows_delete',
+            description: 'Delete a workflow and all its edges.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    workflow_id: {
+                        type: 'string',
+                        description: 'Workflow ID to delete. Use agents_workflows_list to find workflow IDs.'
+                    }
+                },
+                required: ['workflow_id']
+            }
+        },
+        metadata: {
+            category: 'automation',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: true,
+            requiresConfirmation: true,
+            apiEndpoint: '/api/agents/workflows/:id',
+            apiMethod: 'DELETE',
+            tags: ['agents', 'workflows', 'delete']
+        }
+    },
+    // ===== EXECUTIONS =====
+    {
+        type: 'function',
+        function: {
+            name: 'agents_executions_list',
+            description: 'List all workflow executions (past runs). Response includes: trace_id (use agents_executions_trace for step-by-step trace), workflow_id (use agents_workflows_get for workflow details). Each execution shows status, duration, and result.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum number of executions to return',
+                        default: 50
+                    }
+                },
+                required: []
+            }
+        },
+        metadata: {
+            category: 'automation',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/agents/executions',
+            apiMethod: 'GET',
+            tags: ['agents', 'executions', 'list']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'agents_executions_get',
+            description: 'Get details of a specific workflow execution.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    execution_id: {
+                        type: 'string',
+                        description: 'Execution ID (trace_id). Use agents_executions_list first to find execution IDs.'
+                    }
+                },
+                required: ['execution_id']
+            }
+        },
+        metadata: {
+            category: 'automation',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/agents/executions/:id',
+            apiMethod: 'GET',
+            tags: ['agents', 'executions', 'get']
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'agents_executions_trace',
+            description: 'Get the complete execution trace with all agent instances and their status.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    trace_id: {
+                        type: 'string',
+                        description: 'Trace ID of the execution. Use agents_executions_list first to find trace IDs.'
+                    }
+                },
+                required: ['trace_id']
+            }
+        },
+        metadata: {
+            category: 'automation',
+            defaultEnabled: true,
+            adminOnly: false,
+            destructive: false,
+            requiresConfirmation: false,
+            apiEndpoint: '/api/agents/executions/:traceId/trace',
+            apiMethod: 'GET',
+            tags: ['agents', 'executions', 'trace']
+        }
+    }
+];
+// ============= TOOL EXECUTOR =============
+class AgentTools {
+    constructor(registryUrl, apiKey) {
+        this.client = axios_1.default.create({
+            baseURL: registryUrl,
+            timeout: 60000,
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+    static getInstance(registryUrl, apiKey) {
+        if (!AgentTools.instance && registryUrl && apiKey) {
+            AgentTools.instance = new AgentTools(registryUrl, apiKey);
+        }
+        if (!AgentTools.instance) {
+            throw new Error('AgentTools not initialized.');
+        }
+        return AgentTools.instance;
+    }
+    getTools() {
+        return exports.agentToolDefinitions;
+    }
+    async executeTool(toolName, args) {
+        try {
+            switch (toolName) {
+                // Definitions
+                case 'agents_definitions_list':
+                    return await this.listDefinitions(args);
+                case 'agents_definitions_get':
+                    return await this.getDefinition(args.definition_id);
+                case 'agents_definitions_create':
+                    return await this.createDefinition(args);
+                // Instances
+                case 'agents_instances_list':
+                    return await this.listInstances(args);
+                case 'agents_instances_get':
+                    return await this.getInstance(args.instance_id);
+                case 'agents_instances_trace':
+                    return await this.getInstanceTrace(args.instance_id);
+                // Workflows
+                case 'agents_workflows_list':
+                    return await this.listWorkflows();
+                case 'agents_workflows_get':
+                    return await this.getWorkflow(args.workflow_id);
+                case 'agents_workflows_graph':
+                    return await this.getWorkflowGraph(args.workflow_id);
+                case 'agents_workflows_create':
+                    return await this.createWorkflow(args);
+                case 'agents_workflows_assign':
+                    return await this.assignToWorkflow(args);
+                case 'agents_workflows_ready':
+                    return await this.checkWorkflowReady(args.workflow_id);
+                case 'agents_workflows_execute':
+                    return await this.executeWorkflow(args);
+                case 'agents_workflows_delete':
+                    return await this.deleteWorkflow(args.workflow_id);
+                // Executions
+                case 'agents_executions_list':
+                    return await this.listExecutions(args);
+                case 'agents_executions_get':
+                    return await this.getExecution(args.execution_id);
+                case 'agents_executions_trace':
+                    return await this.getExecutionTrace(args.trace_id);
+                default:
+                    return { success: false, error: `Unknown agent tool: ${toolName}` };
+            }
+        }
+        catch (error) {
+            return { success: false, error: error.response?.data?.error?.message || error.message };
+        }
+    }
+    // ===== DEFINITIONS =====
+    async listDefinitions(args) {
+        const params = {};
+        if (args.category)
+            params.category = args.category;
+        const response = await this.client.get('/api/agents/definitions', { params });
+        const defs = response.data.definitions || response.data;
+        if (!defs || defs.length === 0) {
+            return { success: true, output: 'No agent definitions found.' };
+        }
+        const lines = ['**Agent Definitions:**', ''];
+        defs.forEach((d, i) => {
+            lines.push(`[${i + 1}] ${d.icon || '🤖'} ${d.name}`);
+            lines.push(`    ID: ${d.id}`);
+            if (d.description)
+                lines.push(`    Description: ${d.description}`);
+            lines.push(`    Category: ${d.category || 'general'}`);
+            lines.push('');
+        });
+        return { success: true, output: JSON.stringify(response.data, null, 2), data: response.data };
+    }
+    async getDefinition(definitionId) {
+        const response = await this.client.get(`/api/agents/definitions/${definitionId}`);
+        const d = response.data.definition || response.data;
+        const lines = [`**Agent: ${d.icon || '🤖'} ${d.name}**`, ''];
+        lines.push(`ID: ${d.id}`);
+        if (d.description)
+            lines.push(`Description: ${d.description}`);
+        lines.push(`Category: ${d.category || 'general'}`);
+        if (d.default_model)
+            lines.push(`Default Model: ${d.default_model}`);
+        if (d.system_prompt)
+            lines.push(`System Prompt: ${d.system_prompt.substring(0, 200)}...`);
+        return { success: true, output: JSON.stringify(response.data, null, 2), data: response.data };
+    }
+    async createDefinition(args) {
+        const response = await this.client.post('/api/agents/definitions', args);
+        const def = response.data.definition || response.data;
+        return { success: true, output: `✅ Agent definition "${args.name}" created (ID: ${def.id})`, data: response.data };
+    }
+    // ===== INSTANCES =====
+    async listInstances(args) {
+        const params = {};
+        if (args.workflow_id)
+            params.workflow_id = args.workflow_id;
+        const response = await this.client.get('/api/agents/instances', { params });
+        const instances = response.data;
+        if (!instances || instances.length === 0) {
+            return { success: true, output: 'No agent instances found.' };
+        }
+        const lines = ['**Agent Instances:**', ''];
+        instances.forEach((inst, i) => {
+            lines.push(`[${i + 1}] ${inst.icon || '🤖'} ${inst.definition_name || inst.name}`);
+            lines.push(`    ID: ${inst.id}`);
+            lines.push(`    Status: ${inst.status || 'UNKNOWN'}`);
+            if (inst.workflow_name)
+                lines.push(`    Workflow: ${inst.workflow_name}`);
+            lines.push('');
+        });
+        return { success: true, output: JSON.stringify(response.data, null, 2), data: response.data };
+    }
+    async getInstance(instanceId) {
+        const response = await this.client.get(`/api/agents/instances/${instanceId}`);
+        const inst = response.data;
+        const lines = [`**Instance: ${inst.icon || '🤖'} ${inst.definition_name || inst.name}**`, ''];
+        lines.push(`ID: ${inst.id}`);
+        lines.push(`Status: ${inst.status || 'UNKNOWN'}`);
+        if (inst.workflow_name)
+            lines.push(`Workflow: ${inst.workflow_name}`);
+        if (inst.created_at)
+            lines.push(`Created: ${new Date(inst.created_at).toLocaleString()}`);
+        return { success: true, output: JSON.stringify(response.data, null, 2), data: response.data };
+    }
+    async getInstanceTrace(instanceId) {
+        const response = await this.client.get(`/api/agents/instances/${instanceId}/trace`);
+        const data = response.data;
+        const lines = ['**Instance Trace:**', ''];
+        if (data.nodes) {
+            lines.push(`Nodes: ${data.nodes.length}`);
+            lines.push(`Edges: ${data.edges?.length || 0}`);
+        }
+        return { success: true, output: lines.join('\n'), data };
+    }
+    // ===== WORKFLOWS =====
+    async listWorkflows() {
+        const response = await this.client.get('/api/agents/workflows');
+        const workflows = response.data.workflows || response.data;
+        if (!workflows || workflows.length === 0) {
+            return { success: true, output: 'No workflows found.' };
+        }
+        const lines = ['**Workflows:**', ''];
+        workflows.forEach((w, i) => {
+            lines.push(`[${i + 1}] ${w.name}`);
+            lines.push(`    ID: ${w.id}`);
+            if (w.description)
+                lines.push(`    Description: ${w.description}`);
+            lines.push(`    Nodes: ${w.node_count || 0}, Edges: ${w.edge_count || 0}`);
+            lines.push('');
+        });
+        return { success: true, output: JSON.stringify(response.data, null, 2), data: response.data };
+    }
+    async getWorkflow(workflowId) {
+        const response = await this.client.get(`/api/agents/workflows/${workflowId}`);
+        const w = response.data.workflow || response.data;
+        const lines = [`**Workflow: ${w.name}**`, ''];
+        lines.push(`ID: ${w.id}`);
+        if (w.description)
+            lines.push(`Description: ${w.description}`);
+        lines.push(`Nodes: ${w.node_count || 0}, Edges: ${w.edge_count || 0}`);
+        return { success: true, output: JSON.stringify(response.data, null, 2), data: response.data };
+    }
+    async getWorkflowGraph(workflowId) {
+        const response = await this.client.get(`/api/agents/workflows/${workflowId}/graph`);
+        const data = response.data;
+        const lines = ['**Workflow Graph:**', ''];
+        lines.push(`Nodes: ${data.nodes?.length || 0}`);
+        lines.push(`Edges: ${data.edges?.length || 0}`);
+        if (data.nodes && data.nodes.length > 0) {
+            lines.push('', '**Nodes:**');
+            data.nodes.forEach((n) => {
+                lines.push(`  - ${n.data?.icon || '📍'} ${n.data?.label || n.id} (${n.type})`);
+            });
+        }
+        return { success: true, output: lines.join('\n'), data };
+    }
+    async createWorkflow(args) {
+        const response = await this.client.post('/api/agents/workflows', args);
+        const wf = response.data.workflow || response.data;
+        return { success: true, output: `✅ Workflow "${args.name}" created (ID: ${wf.id})` };
+    }
+    async assignToWorkflow(args) {
+        const response = await this.client.post(`/api/agents/workflows/${args.workflow_id}/assign`, {
+            definition_id: args.definition_id,
+            instance_id: args.instance_id
+        });
+        return { success: true, output: `✅ Agent assigned to workflow.`, data: response.data };
+    }
+    async checkWorkflowReady(workflowId) {
+        const response = await this.client.get(`/api/agents/workflows/${workflowId}/ready`);
+        const data = response.data;
+        if (data.ready) {
+            return { success: true, output: `✅ Workflow is ready to execute.` };
+        }
+        else {
+            return { success: true, output: `⚠️ Workflow not ready: ${data.reason || 'Missing required connections'}` };
+        }
+    }
+    async executeWorkflow(args) {
+        const response = await this.client.post(`/api/agents/workflows/${args.workflow_id}/execute`, {
+            prompt: args.prompt,
+            variables: args.variables
+        });
+        const data = response.data;
+        return {
+            success: true,
+            output: `✅ Workflow execution started!\n\nTrace ID: ${data.trace_id || data.id}`,
+            data
+        };
+    }
+    async deleteWorkflow(workflowId) {
+        await this.client.delete(`/api/agents/workflows/${workflowId}`);
+        return { success: true, output: `✅ Workflow deleted.` };
+    }
+    // ===== EXECUTIONS =====
+    async listExecutions(args) {
+        const response = await this.client.get('/api/agents/executions', {
+            params: { limit: args.limit || 50 }
+        });
+        const executions = response.data.executions || response.data;
+        if (!executions || executions.length === 0) {
+            return { success: true, output: 'No workflow executions found.' };
+        }
+        const lines = ['**Workflow Executions:**', ''];
+        executions.forEach((e, i) => {
+            lines.push(`[${i + 1}] ${e.name || 'Execution'}`);
+            lines.push(`    Trace ID: ${e.trace_id || e.id}`);
+            lines.push(`    Status: ${e.status || 'UNKNOWN'}`);
+            lines.push(`    Created: ${new Date(e.created_at).toLocaleString()}`);
+            lines.push('');
+        });
+        return { success: true, output: lines.join('\n') };
+    }
+    async getExecution(executionId) {
+        const response = await this.client.get(`/api/agents/executions/${executionId}`);
+        const e = response.data;
+        const lines = [`**Execution: ${e.name || 'Workflow Execution'}**`, ''];
+        lines.push(`Trace ID: ${e.trace_id || e.id}`);
+        lines.push(`Status: ${e.status || 'UNKNOWN'}`);
+        if (e.workflow_name)
+            lines.push(`Workflow: ${e.workflow_name}`);
+        if (e.created_at)
+            lines.push(`Started: ${new Date(e.created_at).toLocaleString()}`);
+        if (e.completed_at)
+            lines.push(`Completed: ${new Date(e.completed_at).toLocaleString()}`);
+        return { success: true, output: lines.join('\n') };
+    }
+    async getExecutionTrace(traceId) {
+        const response = await this.client.get(`/api/agents/executions/${traceId}/trace`);
+        const data = response.data;
+        const lines = ['**Execution Trace:**', ''];
+        lines.push(`Nodes: ${data.nodes?.length || 0}`);
+        lines.push(`Edges: ${data.edges?.length || 0}`);
+        if (data.nodes && data.nodes.length > 0) {
+            lines.push('', '**Agent Nodes:**');
+            data.nodes.forEach((n) => {
+                const status = n.data?.status || 'PENDING';
+                const icon = status === 'COMPLETED' ? '✅' : status === 'FAILED' ? '❌' : status === 'RUNNING' ? '🔄' : '⏳';
+                lines.push(`  ${icon} ${n.data?.label || n.id} - ${status}`);
+            });
+        }
+        return { success: true, output: lines.join('\n'), data };
+    }
+}
+exports.AgentTools = AgentTools;
+AgentTools.instance = null;
+exports.default = AgentTools;
+//# sourceMappingURL=agent-tools.js.map