qorrelate-mcp-server 0.3.1 → 0.4.1

package/dist/tools/agent-workflows.js

@@ -0,0 +1,701 @@
+"use strict";
+/**
+ * Agent-First Workflow Tools
+ *
+ * Advanced tools for AI-native observability management:
+ * - Webhook management (convenient wrapper around notification destinations)
+ * - AI investigation and runbooks
+ * - AI workflow generation
+ * - Dashboard folder organization
+ * - Drop filter toggle
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAgentWorkflowTools = registerAgentWorkflowTools;
+exports.handleAgentWorkflowTool = handleAgentWorkflowTool;
+const index_js_1 = require("../index.js");
+function registerAgentWorkflowTools() {
+    return [
+        // ==================== WEBHOOKS ====================
+        {
+            name: "list_webhooks",
+            description: "List all webhook notification destinations for an organization",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    organization_id: {
+                        type: "string",
+                        description: "Organization ID",
+                    },
+                },
+                required: ["organization_id"],
+            },
+        },
+        {
+            name: "create_webhook",
+            description: `Create a new webhook endpoint for notifications.
+      
+Example: Create a Slack webhook for alerts
+  name: "#alerts-channel"
+  url: "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXX"`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    organization_id: {
+                        type: "string",
+                        description: "Organization ID",
+                    },
+                    name: {
+                        type: "string",
+                        description: "Friendly name for this webhook (e.g., '#prod-alerts', 'PagerDuty')",
+                    },
+                    url: {
+                        type: "string",
+                        description: "Webhook URL to POST notifications to",
+                    },
+                    method: {
+                        type: "string",
+                        enum: ["GET", "POST", "PUT"],
+                        description: "HTTP method (default: POST)",
+                    },
+                    headers: {
+                        type: "object",
+                        description: "Optional HTTP headers to include",
+                    },
+                },
+                required: ["organization_id", "name", "url"],
+            },
+        },
+        {
+            name: "test_webhook",
+            description: "Send a test message to verify a webhook URL is working correctly",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    url: {
+                        type: "string",
+                        description: "Webhook URL to test",
+                    },
+                    method: {
+                        type: "string",
+                        enum: ["GET", "POST", "PUT"],
+                        description: "HTTP method (default: POST)",
+                    },
+                    headers: {
+                        type: "object",
+                        description: "Optional HTTP headers",
+                    },
+                    payload: {
+                        type: "object",
+                        description: "Optional custom test payload (defaults to a standard test message)",
+                    },
+                },
+                required: ["url"],
+            },
+        },
+        // ==================== DROP FILTER TOGGLE ====================
+        {
+            name: "toggle_drop_filter",
+            description: "Enable or disable a drop filter without deleting it. Useful for temporarily stopping filtering.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    organization_id: {
+                        type: "string",
+                        description: "Organization ID",
+                    },
+                    filter_id: {
+                        type: "string",
+                        description: "Drop filter ID to toggle",
+                    },
+                    enabled: {
+                        type: "boolean",
+                        description: "True to enable filtering, false to disable",
+                    },
+                },
+                required: ["organization_id", "filter_id", "enabled"],
+            },
+        },
+        // ==================== DASHBOARD FOLDERS ====================
+        {
+            name: "list_dashboard_folders",
+            description: "List all dashboard folders for organizing dashboards",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    organization_id: {
+                        type: "string",
+                        description: "Organization ID",
+                    },
+                },
+                required: ["organization_id"],
+            },
+        },
+        {
+            name: "create_dashboard_folder",
+            description: "Create a folder to organize dashboards",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    organization_id: {
+                        type: "string",
+                        description: "Organization ID",
+                    },
+                    name: {
+                        type: "string",
+                        description: "Folder name (e.g., 'Production', 'Team Dashboards')",
+                    },
+                    description: {
+                        type: "string",
+                        description: "Optional description",
+                    },
+                    parent_id: {
+                        type: "string",
+                        description: "Optional parent folder ID for nesting",
+                    },
+                },
+                required: ["organization_id", "name"],
+            },
+        },
+        {
+            name: "update_dashboard_folder",
+            description: "Update a dashboard folder's name or description",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    organization_id: {
+                        type: "string",
+                        description: "Organization ID",
+                    },
+                    folder_id: {
+                        type: "string",
+                        description: "Folder ID to update",
+                    },
+                    name: {
+                        type: "string",
+                        description: "New folder name",
+                    },
+                    description: {
+                        type: "string",
+                        description: "New description",
+                    },
+                },
+                required: ["organization_id", "folder_id"],
+            },
+        },
+        {
+            name: "delete_dashboard_folder",
+            description: "Delete a dashboard folder. Dashboards inside will be moved to root.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    organization_id: {
+                        type: "string",
+                        description: "Organization ID",
+                    },
+                    folder_id: {
+                        type: "string",
+                        description: "Folder ID to delete",
+                    },
+                },
+                required: ["organization_id", "folder_id"],
+            },
+        },
+        // ==================== AI AGENT WORKFLOWS ====================
+        {
+            name: "ai_investigate",
+            description: `Use AI to investigate an issue by gathering relevant logs, traces, and metrics.
+
+Provide a description of the problem and the AI will:
+1. Search for related logs and errors
+2. Find traces that match the issue
+3. Identify patterns and anomalies
+4. Suggest potential root causes
+
+Example: "High latency on checkout API in the last hour"`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "Description of the issue to investigate",
+                    },
+                    context: {
+                        type: "string",
+                        description: "Additional context (e.g., 'started after deploy', 'affecting EU users')",
+                    },
+                    include_logs: {
+                        type: "boolean",
+                        description: "Include log analysis (default: true)",
+                    },
+                    include_traces: {
+                        type: "boolean",
+                        description: "Include trace analysis (default: true)",
+                    },
+                    include_metrics: {
+                        type: "boolean",
+                        description: "Include metric analysis (default: true)",
+                    },
+                    time_range: {
+                        type: "string",
+                        description: "Time range (e.g., '1h', '24h', '7d'). Default: '1h'",
+                    },
+                },
+                required: ["query"],
+            },
+        },
+        {
+            name: "ai_generate_workflow",
+            description: `Have AI generate a workflow automation based on a description.
+
+Examples:
+- "When an alert fires, send Slack notification and create JIRA ticket"
+- "Every hour, check error rates and send report to email"
+- "When CPU > 80%, scale up the service and notify on-call"
+
+The AI will generate the complete workflow with nodes and connections.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    organization_id: {
+                        type: "string",
+                        description: "Organization ID",
+                    },
+                    description: {
+                        type: "string",
+                        description: "Natural language description of the workflow to create",
+                    },
+                    trigger_type: {
+                        type: "string",
+                        enum: ["alert", "schedule", "manual"],
+                        description: "What triggers this workflow (default: alert)",
+                    },
+                    services: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Services to scope this workflow to",
+                    },
+                },
+                required: ["organization_id", "description"],
+            },
+        },
+        {
+            name: "get_runbook",
+            description: `Get a runbook (pre-defined incident response procedure).
+
+Available runbooks:
+- high_error_rate: Steps for handling elevated error rates
+- high_latency: Steps for debugging latency issues
+- service_down: Steps for service outage response
+- memory_leak: Steps for investigating memory issues
+- deployment_failure: Steps for failed deployments`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    runbook_name: {
+                        type: "string",
+                        description: "Name of the runbook to retrieve",
+                    },
+                },
+                required: ["runbook_name"],
+            },
+        },
+        {
+            name: "get_agent_services_summary",
+            description: "Get a summary of all services optimized for AI agent consumption. Includes health status, error rates, and recent issues.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+        // ==================== OPEN IN BROWSER ====================
+        {
+            name: "open_session_replay",
+            description: `Get a URL to open a specific session replay in the browser.
+      
+Returns a direct link that opens the session replay player. Use this when:
+- User wants to SEE what happened in a session
+- You've identified an interesting session via list_sessions
+- Investigating a user-reported issue`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    session_id: {
+                        type: "string",
+                        description: "Session ID to open",
+                    },
+                    timestamp: {
+                        type: "number",
+                        description: "Optional: Jump to specific timestamp (milliseconds from start)",
+                    },
+                },
+                required: ["session_id"],
+            },
+        },
+        {
+            name: "open_dashboard",
+            description: `Get a URL to open a specific dashboard in the browser.
+      
+Returns a direct link to view the dashboard. Use this when:
+- User wants to SEE the visualizations
+- Sharing a dashboard with team members
+- You've created a dashboard and want to show it`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    dashboard_id: {
+                        type: "string",
+                        description: "Dashboard ID to open",
+                    },
+                    time_range: {
+                        type: "string",
+                        description: "Optional: Time range (e.g., '1h', '24h', '7d')",
+                    },
+                },
+                required: ["dashboard_id"],
+            },
+        },
+        {
+            name: "open_trace",
+            description: `Get a URL to open a specific trace in the browser.
+      
+Returns a direct link to the trace waterfall view. Use this when:
+- User wants to SEE the trace visualization
+- Debugging a specific request
+- Sharing trace details with team`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    trace_id: {
+                        type: "string",
+                        description: "Trace ID to open",
+                    },
+                },
+                required: ["trace_id"],
+            },
+        },
+        {
+            name: "open_logs",
+            description: `Get a URL to open the logs view with a specific query pre-filled.
+      
+Returns a direct link to the logs explorer. Use this when:
+- User wants to explore logs interactively
+- Sharing a log query with team members`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "Log query to pre-fill (e.g., 'level:ERROR service.name:backend')",
+                    },
+                    time_range: {
+                        type: "string",
+                        description: "Optional: Time range (e.g., '1h', '24h', '7d')",
+                    },
+                },
+                required: ["query"],
+            },
+        },
+        {
+            name: "open_alert",
+            description: `Get a URL to open a specific alert's details in the browser.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    alert_id: {
+                        type: "string",
+                        description: "Alert ID to open",
+                    },
+                },
+                required: ["alert_id"],
+            },
+        },
+        {
+            name: "open_service",
+            description: `Get a URL to open a service's overview page in the browser.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    service_name: {
+                        type: "string",
+                        description: "Service name to open",
+                    },
+                },
+                required: ["service_name"],
+            },
+        },
+    ];
+}
+async function handleAgentWorkflowTool(client, name, args) {
+    const orgId = args.organization_id || index_js_1.defaultOrgId;
+    switch (name) {
+        // Webhooks
+        case "list_webhooks": {
+            if (!orgId)
+                throw new Error("organization_id is required");
+            const result = await client.listWebhooks(orgId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        case "create_webhook": {
+            if (!orgId)
+                throw new Error("organization_id is required");
+            const params = {
+                name: args.name,
+                url: args.url,
+                method: args.method,
+                headers: args.headers,
+            };
+            if (!params.name || !params.url)
+                throw new Error("name and url are required");
+            const result = await client.createWebhook(orgId, params);
+            return {
+                content: [{ type: "text", text: `Webhook created!\n\n${JSON.stringify(result, null, 2)}` }],
+            };
+        }
+        case "test_webhook": {
+            const url = args.url;
+            if (!url)
+                throw new Error("url is required");
+            const result = await client.testWebhook(orgId || '', {
+                url,
+                method: args.method,
+                headers: args.headers,
+                payload: args.payload,
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        // Drop Filter Toggle
+        case "toggle_drop_filter": {
+            if (!orgId)
+                throw new Error("organization_id is required");
+            const filterId = args.filter_id;
+            const enabled = args.enabled;
+            if (!filterId)
+                throw new Error("filter_id is required");
+            if (typeof enabled !== 'boolean')
+                throw new Error("enabled must be true or false");
+            const result = await client.toggleDropFilter(orgId, filterId, enabled);
+            const action = enabled ? 'enabled' : 'disabled';
+            return {
+                content: [{ type: "text", text: `Drop filter ${action}!\n\n${JSON.stringify(result, null, 2)}` }],
+            };
+        }
+        // Dashboard Folders
+        case "list_dashboard_folders": {
+            if (!orgId)
+                throw new Error("organization_id is required");
+            const result = await client.listDashboardFolders(orgId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        case "create_dashboard_folder": {
+            if (!orgId)
+                throw new Error("organization_id is required");
+            const params = {
+                name: args.name,
+                description: args.description,
+                parent_id: args.parent_id,
+            };
+            if (!params.name)
+                throw new Error("name is required");
+            const result = await client.createDashboardFolder(orgId, params);
+            return {
+                content: [{ type: "text", text: `Dashboard folder created!\n\n${JSON.stringify(result, null, 2)}` }],
+            };
+        }
+        case "update_dashboard_folder": {
+            if (!orgId)
+                throw new Error("organization_id is required");
+            const folderId = args.folder_id;
+            if (!folderId)
+                throw new Error("folder_id is required");
+            const params = {};
+            if (args.name)
+                params.name = args.name;
+            if (args.description)
+                params.description = args.description;
+            const result = await client.updateDashboardFolder(orgId, folderId, params);
+            return {
+                content: [{ type: "text", text: `Dashboard folder updated!\n\n${JSON.stringify(result, null, 2)}` }],
+            };
+        }
+        case "delete_dashboard_folder": {
+            if (!orgId)
+                throw new Error("organization_id is required");
+            const folderId = args.folder_id;
+            if (!folderId)
+                throw new Error("folder_id is required");
+            const result = await client.deleteDashboardFolder(orgId, folderId);
+            return {
+                content: [{ type: "text", text: `Dashboard folder deleted.\n\n${JSON.stringify(result, null, 2)}` }],
+            };
+        }
+        // AI Agent Workflows
+        case "ai_investigate": {
+            const query = args.query;
+            if (!query)
+                throw new Error("query is required");
+            const result = await client.aiInvestigate({
+                query,
+                context: args.context,
+                include_logs: args.include_logs,
+                include_traces: args.include_traces,
+                include_metrics: args.include_metrics,
+                time_range: args.time_range,
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        case "ai_generate_workflow": {
+            if (!orgId)
+                throw new Error("organization_id is required");
+            const description = args.description;
+            if (!description)
+                throw new Error("description is required");
+            const result = await client.aiGenerateWorkflow(orgId, {
+                description,
+                trigger_type: args.trigger_type,
+                services: args.services,
+            });
+            return {
+                content: [{ type: "text", text: `Workflow generated!\n\n${JSON.stringify(result, null, 2)}` }],
+            };
+        }
+        case "get_runbook": {
+            const runbookName = args.runbook_name;
+            if (!runbookName)
+                throw new Error("runbook_name is required");
+            const result = await client.getRunbook(runbookName);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        case "get_agent_services_summary": {
+            const result = await client.getAgentServicesSummary();
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        // Open in Browser tools
+        case "open_session_replay": {
+            const sessionId = args.session_id;
+            if (!sessionId)
+                throw new Error("session_id is required");
+            const timestamp = args.timestamp;
+            const endpoint = process.env.QORRELATE_ENDPOINT || "https://qorrelate.io";
+            let url = `${endpoint}/app?view=session-replay&session=${sessionId}`;
+            if (timestamp)
+                url += `&t=${timestamp}`;
+            return {
+                content: [{
+                        type: "text",
+                        text: `## Session Replay
+
+**Open in browser:** ${url}
+
+Click the link above to watch the session replay.`,
+                    }],
+            };
+        }
+        case "open_dashboard": {
+            const dashboardId = args.dashboard_id;
+            if (!dashboardId)
+                throw new Error("dashboard_id is required");
+            const timeRange = args.time_range;
+            const endpoint = process.env.QORRELATE_ENDPOINT || "https://qorrelate.io";
+            let url = `${endpoint}/app?view=dashboards&dashboard=${dashboardId}`;
+            if (timeRange)
+                url += `&range=${timeRange}`;
+            return {
+                content: [{
+                        type: "text",
+                        text: `## Dashboard
+
+**Open in browser:** ${url}
+
+Click the link above to view the dashboard.`,
+                    }],
+            };
+        }
+        case "open_trace": {
+            const traceId = args.trace_id;
+            if (!traceId)
+                throw new Error("trace_id is required");
+            const endpoint = process.env.QORRELATE_ENDPOINT || "https://qorrelate.io";
+            const url = `${endpoint}/app?view=traces&trace=${traceId}`;
+            return {
+                content: [{
+                        type: "text",
+                        text: `## Trace Details
+
+**Open in browser:** ${url}
+
+Click the link above to view the trace waterfall.`,
+                    }],
+            };
+        }
+        case "open_logs": {
+            const query = args.query;
+            if (!query)
+                throw new Error("query is required");
+            const timeRange = args.time_range;
+            const endpoint = process.env.QORRELATE_ENDPOINT || "https://qorrelate.io";
+            const encodedQuery = encodeURIComponent(query);
+            let url = `${endpoint}/app?view=logs&q=${encodedQuery}`;
+            if (timeRange)
+                url += `&range=${timeRange}`;
+            return {
+                content: [{
+                        type: "text",
+                        text: `## Log Explorer
+
+**Open in browser:** ${url}
+
+Click the link above to explore logs with query: \`${query}\``,
+                    }],
+            };
+        }
+        case "open_alert": {
+            const alertId = args.alert_id;
+            if (!alertId)
+                throw new Error("alert_id is required");
+            const endpoint = process.env.QORRELATE_ENDPOINT || "https://qorrelate.io";
+            const url = `${endpoint}/app?view=alerts&alert=${alertId}`;
+            return {
+                content: [{
+                        type: "text",
+                        text: `## Alert Details
+
+**Open in browser:** ${url}
+
+Click the link above to view the alert details and history.`,
+                    }],
+            };
+        }
+        case "open_service": {
+            const serviceName = args.service_name;
+            if (!serviceName)
+                throw new Error("service_name is required");
+            const endpoint = process.env.QORRELATE_ENDPOINT || "https://qorrelate.io";
+            const url = `${endpoint}/app?view=services&service=${encodeURIComponent(serviceName)}`;
+            return {
+                content: [{
+                        type: "text",
+                        text: `## Service Overview
+
+**Open in browser:** ${url}
+
+Click the link above to view the service health and metrics.`,
+                    }],
+            };
+        }
+        default:
+            throw new Error(`Unknown agent workflow tool: ${name}`);
+    }
+}
+//# sourceMappingURL=agent-workflows.js.map