@jaypie/mcp 0.3.4 → 0.4.0

package/dist/index.js

@@ -1,183 +1,29 @@
 #!/usr/bin/env node
 import { realpathSync, readFileSync } from 'node:fs';
-import * as path from 'node:path';
 import { join } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+import { pathToFileURL } from 'node:url';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { z } from 'zod';
-import * as fs from 'node:fs/promises';
-import matter from 'gray-matter';
-import { gt } from 'semver';
-import { g as getDatadogCredentials, s as searchDatadogLogs, a as aggregateDatadogLogs, l as listDatadogMonitors, b as getDatadogSyntheticResults, c as listDatadogSynthetics, q as queryDatadogMetrics, d as searchDatadogRum, e as debugLlmCall, f as listLlmProviders, h as listAwsProfiles, i as listStepFunctionExecutions, j as stopStepFunctionExecution, k as listLambdaFunctions, m as getLambdaFunction, n as filterLogEvents, o as listS3Objects, p as describeStack, r as describeDynamoDBTable, t as scanDynamoDB, u as queryDynamoDB, v as getDynamoDBItem, w as listSQSQueues, x as getSQSQueueAttributes, y as receiveSQSMessage, z as purgeSQSQueue } from './aws-B3dW_-bD.js';
+import { createMcpServerFromSuite } from '@jaypie/fabric/mcp';
+import { suite } from './suite.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { randomUUID } from 'node:crypto';
+import '@jaypie/fabric';
+import 'node:fs/promises';
+import 'gray-matter';
+import 'semver';
 import 'node:https';
 import '@jaypie/llm';
 import 'node:child_process';
 import 'node:os';
 
-const BUILD_VERSION_STRING = "@jaypie/mcp@0.3.4#a6510094"
-    ;
-const __filename$1 = fileURLToPath(import.meta.url);
-const __dirname$1 = path.dirname(__filename$1);
-const PROMPTS_PATH = path.join(__dirname$1, "..", "prompts");
-const RELEASE_NOTES_PATH = path.join(__dirname$1, "..", "release-notes");
-const SKILLS_PATH = path.join(__dirname$1, "..", "skills");
-// Logger utility
-function createLogger(verbose) {
-    return {
-        info: (message, ...args) => {
-            if (verbose) {
-                console.error(`[jaypie-mcp] ${message}`, ...args);
-            }
-        },
-        error: (message, ...args) => {
-            console.error(`[jaypie-mcp ERROR] ${message}`, ...args);
-        },
-    };
-}
-async function parseMarkdownFile(filePath) {
-    try {
-        const content = await fs.readFile(filePath, "utf-8");
-        const filename = path.basename(filePath);
-        if (content.startsWith("---")) {
-            const parsed = matter(content);
-            const frontMatter = parsed.data;
-            return {
-                filename,
-                description: frontMatter.description,
-                include: frontMatter.include || frontMatter.globs,
-            };
-        }
-        return { filename };
-    }
-    catch {
-        return { filename: path.basename(filePath) };
-    }
-}
-function formatPromptListItem(prompt) {
-    const { filename, description, include } = prompt;
-    if (description && include) {
-        return `* ${filename}: ${description} - Required for ${include}`;
-    }
-    else if (description) {
-        return `* ${filename}: ${description}`;
-    }
-    else if (include) {
-        return `* ${filename} - Required for ${include}`;
-    }
-    else {
-        return `* ${filename}`;
-    }
-}
-async function parseReleaseNoteFile(filePath) {
-    try {
-        const content = await fs.readFile(filePath, "utf-8");
-        const filename = path.basename(filePath, ".md");
-        if (content.startsWith("---")) {
-            const parsed = matter(content);
-            const frontMatter = parsed.data;
-            return {
-                date: frontMatter.date,
-                filename,
-                summary: frontMatter.summary,
-                version: frontMatter.version || filename,
-            };
-        }
-        return { filename, version: filename };
-    }
-    catch {
-        return { filename: path.basename(filePath, ".md") };
-    }
-}
-function formatReleaseNoteListItem(note) {
-    const { date, packageName, summary, version } = note;
-    const parts = [`* ${packageName}@${version}`];
-    if (date) {
-        parts.push(`(${date})`);
-    }
-    if (summary) {
-        parts.push(`- ${summary}`);
-    }
-    return parts.join(" ");
-}
-async function getPackageReleaseNotes(packageName) {
-    const packageDir = path.join(RELEASE_NOTES_PATH, packageName);
-    try {
-        const files = await fs.readdir(packageDir);
-        const mdFiles = files.filter((file) => file.endsWith(".md"));
-        const notes = await Promise.all(mdFiles.map(async (file) => {
-            const parsed = await parseReleaseNoteFile(path.join(packageDir, file));
-            return { ...parsed, packageName };
-        }));
-        // Sort by version descending (newest first)
-        return notes.sort((a, b) => {
-            if (!a.version || !b.version)
-                return 0;
-            try {
-                return gt(a.version, b.version) ? -1 : 1;
-            }
-            catch {
-                // If semver comparison fails, fall back to string comparison
-                return b.version.localeCompare(a.version);
-            }
-        });
-    }
-    catch {
-        return [];
-    }
-}
-function filterReleaseNotesSince(notes, sinceVersion) {
-    return notes.filter((note) => {
-        if (!note.version)
-            return false;
-        try {
-            return gt(note.version, sinceVersion);
-        }
-        catch {
-            return false;
-        }
-    });
-}
-function isValidSkillAlias(alias) {
-    const normalized = alias.toLowerCase().trim();
-    // Reject if contains path separators or traversal
-    if (normalized.includes("/") ||
-        normalized.includes("\\") ||
-        normalized.includes("..")) {
-        return false;
-    }
-    // Only allow alphanumeric, hyphens, underscores
-    return /^[a-z0-9_-]+$/.test(normalized);
-}
-async function parseSkillFile(filePath) {
-    try {
-        const content = await fs.readFile(filePath, "utf-8");
-        const alias = path.basename(filePath, ".md");
-        if (content.startsWith("---")) {
-            const parsed = matter(content);
-            const frontMatter = parsed.data;
-            return {
-                alias,
-                description: frontMatter.description,
-            };
-        }
-        return { alias };
-    }
-    catch {
-        return { alias: path.basename(filePath, ".md") };
-    }
-}
-function formatSkillListItem(skill) {
-    const { alias, description } = skill;
-    if (description) {
-        return `* ${alias} - ${description}`;
-    }
-    return `* ${alias}`;
-}
 /**
  * Creates and configures an MCP server instance with Jaypie tools
+ *
+ * Uses ServiceSuite to register all services as MCP tools automatically.
+ * Services are defined in suite.ts using fabricService and registered
+ * by category. The createMcpServerFromSuite bridge converts them to
+ * MCP tools with proper Zod schema validation.
+ *
  * @param options - Configuration options (or legacy version string)
  * @returns Configured MCP server instance
  */
@@ -185,1929 +31,17 @@ function createMcpServer(options = {}) {
     // Support legacy signature: createMcpServer(version: string)
     const config = typeof options === "string" ? { version: options } : options;
     const { version = "0.0.0", verbose = false } = config;
-    const log = createLogger(verbose);
-    log.info("Creating MCP server instance");
-    log.info(`Prompts directory: ${PROMPTS_PATH}`);
-    const server = new McpServer({
-        name: "jaypie",
+    if (verbose) {
+        console.error("[jaypie-mcp] Creating MCP server instance from suite");
+    }
+    const server = createMcpServerFromSuite(suite, {
+        name: suite.name,
         version,
-    }, {
-        capabilities: {},
-    });
-    log.info("Registering tools...");
-    server.tool("list_prompts", "[DEPRECATED: Use skill('index') instead] List available Jaypie development prompts and guides. Use this FIRST when starting work on a Jaypie project to discover relevant documentation. Returns filenames, descriptions, and which file patterns each prompt applies to (e.g., 'Required for packages/express/**').", {}, async () => {
-        log.info("Tool called: list_prompts");
-        log.info(`Reading directory: ${PROMPTS_PATH}`);
-        try {
-            const files = await fs.readdir(PROMPTS_PATH);
-            const mdFiles = files.filter((file) => file.endsWith(".md"));
-            log.info(`Found ${mdFiles.length} .md files`);
-            const prompts = await Promise.all(mdFiles.map((file) => parseMarkdownFile(path.join(PROMPTS_PATH, file))));
-            const formattedList = prompts.map(formatPromptListItem).join("\n");
-            log.info("Successfully listed prompts");
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: formattedList || "No .md files found in the prompts directory.",
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            log.error("Error listing prompts:", error);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error listing prompts: ${error instanceof Error ? error.message : "Unknown error"}`,
-                    },
-                ],
-            };
-        }
-    });
-    log.info("Registered tool: list_prompts");
-    server.tool("read_prompt", "[DEPRECATED: Use skill(alias) instead] Read a Jaypie prompt/guide by filename. Call list_prompts first to see available prompts. These contain best practices, templates, code patterns, and step-by-step guides for Jaypie development tasks.", {
-        filename: z
-            .string()
-            .describe("The prompt filename from list_prompts (e.g., 'Jaypie_Express_Package.md', 'Development_Process.md')"),
-    }, async ({ filename }) => {
-        log.info(`Tool called: read_prompt (filename: ${filename})`);
-        try {
-            const filePath = path.join(PROMPTS_PATH, filename);
-            log.info(`Reading file: ${filePath}`);
-            const content = await fs.readFile(filePath, "utf-8");
-            log.info(`Successfully read ${filename} (${content.length} bytes)`);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: content,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                log.error(`File not found: ${filename}`);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Error: Prompt file "${filename}" not found in prompts directory`,
-                        },
-                    ],
-                };
-            }
-            log.error("Error reading prompt file:", error);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error reading prompt file: ${error instanceof Error ? error.message : "Unknown error"}`,
-                    },
-                ],
-            };
-        }
-    });
-    log.info("Registered tool: read_prompt");
-    // Skill tool - new unified documentation access
-    server.tool("skill", "Access Jaypie development documentation. Pass a skill alias (e.g., 'aws', 'tests', 'errors') to get that documentation. Pass 'index' or no argument to list all available skills.", {
-        alias: z
-            .string()
-            .optional()
-            .describe("Skill alias (e.g., 'aws', 'tests', 'errors'). Omit or use 'index' to list all skills."),
-    }, async ({ alias }) => {
-        const effectiveAlias = alias?.toLowerCase().trim() || "index";
-        log.info(`Tool called: skill (alias: ${effectiveAlias})`);
-        // Validate alias for path traversal
-        if (!isValidSkillAlias(effectiveAlias)) {
-            log.error(`Invalid skill alias: ${effectiveAlias}`);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: Invalid skill alias "${alias}". Aliases may only contain letters, numbers, hyphens, and underscores.`,
-                    },
-                ],
-            };
-        }
-        try {
-            // Handle index: return index.md content plus list of all skills
-            if (effectiveAlias === "index") {
-                let indexContent = "";
-                // Try to read index.md if it exists
-                try {
-                    const indexPath = path.join(SKILLS_PATH, "index.md");
-                    const rawContent = await fs.readFile(indexPath, "utf-8");
-                    // Strip frontmatter if present
-                    if (rawContent.startsWith("---")) {
-                        const parsed = matter(rawContent);
-                        indexContent = parsed.content.trim();
-                    }
-                    else {
-                        indexContent = rawContent;
-                    }
-                }
-                catch {
-                    // No index.md, that's fine
-                }
-                // Get list of all skills
-                const files = await fs.readdir(SKILLS_PATH);
-                const mdFiles = files.filter((file) => file.endsWith(".md") && file !== "index.md");
-                const skills = await Promise.all(mdFiles.map((file) => parseSkillFile(path.join(SKILLS_PATH, file))));
-                // Sort alphabetically
-                skills.sort((a, b) => a.alias.localeCompare(b.alias));
-                const skillList = skills.map(formatSkillListItem).join("\n");
-                const resultText = indexContent
-                    ? `${indexContent}\n\n## Available Skills\n\n${skillList}`
-                    : `# Jaypie Skills\n\n## Available Skills\n\n${skillList}`;
-                log.info("Successfully returned skill index");
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: resultText,
-                        },
-                    ],
-                };
-            }
-            // Read specific skill file
-            const skillPath = path.join(SKILLS_PATH, `${effectiveAlias}.md`);
-            log.info(`Reading skill file: ${skillPath}`);
-            const content = await fs.readFile(skillPath, "utf-8");
-            log.info(`Successfully read skill ${effectiveAlias} (${content.length} bytes)`);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: content,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                log.error(`Skill not found: ${effectiveAlias}`);
-                // Suggest available skills
-                try {
-                    const files = await fs.readdir(SKILLS_PATH);
-                    const available = files
-                        .filter((f) => f.endsWith(".md"))
-                        .map((f) => f.replace(".md", ""))
-                        .sort()
-                        .join(", ");
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Error: Skill "${effectiveAlias}" not found.\n\nAvailable skills: ${available}\n\nUse skill("index") to see all skills with descriptions.`,
-                            },
-                        ],
-                    };
-                }
-                catch {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Error: Skill "${effectiveAlias}" not found. Use skill("index") to list available skills.`,
-                            },
-                        ],
-                    };
-                }
-            }
-            log.error("Error reading skill:", error);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error reading skill: ${error instanceof Error ? error.message : "Unknown error"}`,
-                    },
-                ],
-            };
-        }
-    });
-    log.info("Registered tool: skill");
-    server.tool("version", `Prints the current version and hash, \`${BUILD_VERSION_STRING}\``, {}, async () => {
-        log.info("Tool called: version");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: BUILD_VERSION_STRING,
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: version");
-    // Release Notes Tools
-    server.tool("list_release_notes", "List available release notes for Jaypie packages. Filter by package name and/or get only versions newer than a specified version.", {
-        package: z
-            .string()
-            .optional()
-            .describe("Filter by package name (e.g., 'jaypie', 'mcp'). If not provided, lists release notes for all packages."),
-        since_version: z
-            .string()
-            .optional()
-            .describe("Only show versions newer than this (e.g., '1.0.0'). Uses semver comparison."),
-    }, async ({ package: packageFilter, since_version: sinceVersion }) => {
-        log.info("Tool called: list_release_notes");
-        log.info(`Release notes directory: ${RELEASE_NOTES_PATH}`);
-        try {
-            // Get list of package directories
-            const entries = await fs.readdir(RELEASE_NOTES_PATH, {
-                withFileTypes: true,
-            });
-            const packageDirs = entries
-                .filter((entry) => entry.isDirectory())
-                .map((entry) => entry.name);
-            log.info(`Found ${packageDirs.length} package directories`);
-            // Filter by package if specified
-            const packagesToList = packageFilter
-                ? packageDirs.filter((pkg) => pkg === packageFilter)
-                : packageDirs;
-            if (packagesToList.length === 0 && packageFilter) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `No release notes found for package "${packageFilter}".`,
-                        },
-                    ],
-                };
-            }
-            // Get release notes for each package
-            const allNotes = await Promise.all(packagesToList.map((pkg) => getPackageReleaseNotes(pkg)));
-            let flatNotes = allNotes.flat();
-            // Filter by since_version if specified
-            if (sinceVersion) {
-                flatNotes = filterReleaseNotesSince(flatNotes, sinceVersion);
-            }
-            if (flatNotes.length === 0) {
-                const filterDesc = sinceVersion ? ` newer than ${sinceVersion}` : "";
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `No release notes found${filterDesc}.`,
-                        },
-                    ],
-                };
-            }
-            const formattedList = flatNotes
-                .map(formatReleaseNoteListItem)
-                .join("\n");
-            log.info(`Successfully listed ${flatNotes.length} release notes`);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: formattedList,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            log.error("Error listing release notes:", error);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error listing release notes: ${error instanceof Error ? error.message : "Unknown error"}`,
-                    },
-                ],
-            };
-        }
     });
-    log.info("Registered tool: list_release_notes");
-    server.tool("read_release_note", "Read the full content of a specific release note. Call list_release_notes first to see available versions.", {
-        package: z.string().describe("Package name (e.g., 'jaypie', 'mcp')"),
-        version: z.string().describe("Version number (e.g., '1.2.3')"),
-    }, async ({ package: packageName, version }) => {
-        log.info(`Tool called: read_release_note (package: ${packageName}, version: ${version})`);
-        try {
-            const filePath = path.join(RELEASE_NOTES_PATH, packageName, `${version}.md`);
-            log.info(`Reading file: ${filePath}`);
-            const content = await fs.readFile(filePath, "utf-8");
-            log.info(`Successfully read release note for ${packageName}@${version} (${content.length} bytes)`);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: content,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                log.error(`Release note not found: ${packageName}@${version}`);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Error: Release note for "${packageName}@${version}" not found. Use list_release_notes to see available versions.`,
-                        },
-                    ],
-                };
-            }
-            log.error("Error reading release note:", error);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error reading release note: ${error instanceof Error ? error.message : "Unknown error"}`,
-                    },
-                ],
-            };
-        }
-    });
-    log.info("Registered tool: read_release_note");
-    // Datadog Logs Tool
-    server.tool("datadog_logs", "Search and retrieve individual Datadog log entries. Use this to view actual log messages and details. For aggregated counts/statistics (e.g., 'how many errors by service?'), use datadog_log_analytics instead. Requires DATADOG_API_KEY and DATADOG_APP_KEY environment variables.", {
-        query: z
-            .string()
-            .optional()
-            .describe("Search query to filter logs. Examples: 'status:error', '@http.status_code:500', '*timeout*', '@requestId:abc123'. Combined with DD_ENV, DD_SERVICE, DD_SOURCE env vars if set."),
-        source: z
-            .string()
-            .optional()
-            .describe("Override the log source (e.g., 'lambda', 'auth0', 'nginx'). If not provided, uses DD_SOURCE env var or defaults to 'lambda'."),
-        env: z
-            .string()
-            .optional()
-            .describe("Override the environment (e.g., 'sandbox', 'kitchen', 'lab', 'studio', 'production'). If not provided, uses DD_ENV env var."),
-        service: z
-            .string()
-            .optional()
-            .describe("Override the service name. If not provided, uses DD_SERVICE env var."),
-        from: z
-            .string()
-            .optional()
-            .describe("Start time. Formats: relative ('now-15m', 'now-1h', 'now-1d'), ISO 8601 ('2024-01-15T10:00:00Z'). Defaults to 'now-15m'."),
-        to: z
-            .string()
-            .optional()
-            .describe("End time. Formats: 'now', relative ('now-5m'), or ISO 8601. Defaults to 'now'."),
-        limit: z
-            .number()
-            .optional()
-            .describe("Max logs to return (1-1000). Defaults to 50."),
-        sort: z
-            .enum(["timestamp", "-timestamp"])
-            .optional()
-            .describe("Sort order: 'timestamp' (oldest first) or '-timestamp' (newest first, default)."),
-    }, async ({ query, source, env, service, from, to, limit, sort }) => {
-        log.info("Tool called: datadog_logs");
-        const credentials = getDatadogCredentials();
-        if (!credentials) {
-            const missingApiKey = !process.env.DATADOG_API_KEY && !process.env.DD_API_KEY;
-            const missingAppKey = !process.env.DATADOG_APP_KEY &&
-                !process.env.DATADOG_APPLICATION_KEY &&
-                !process.env.DD_APP_KEY &&
-                !process.env.DD_APPLICATION_KEY;
-            if (missingApiKey) {
-                log.error("No Datadog API key found in environment");
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "Error: No Datadog API key found. Please set DATADOG_API_KEY or DD_API_KEY environment variable.",
-                        },
-                    ],
-                };
-            }
-            if (missingAppKey) {
-                log.error("No Datadog Application key found in environment");
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "Error: No Datadog Application key found. Please set DATADOG_APP_KEY or DD_APP_KEY environment variable. The Logs Search API requires both an API key and an Application key.",
-                        },
-                    ],
-                };
-            }
-        }
-        // credentials is guaranteed to be non-null here
-        const result = await searchDatadogLogs(credentials, {
-            query,
-            source,
-            env,
-            service,
-            from,
-            to,
-            limit,
-            sort,
-        }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error from Datadog API: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        if (result.logs.length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `No logs found for query: ${result.query}\nTime range: ${result.timeRange.from} to ${result.timeRange.to}`,
-                    },
-                ],
-            };
-        }
-        const resultText = [
-            `Query: ${result.query}`,
-            `Time range: ${result.timeRange.from} to ${result.timeRange.to}`,
-            `Found ${result.logs.length} log entries:`,
-            "",
-            JSON.stringify(result.logs, null, 2),
-        ].join("\n");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: resultText,
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: datadog_logs");
-    // Datadog Log Analytics Tool
-    server.tool("datadog_log_analytics", "Aggregate and analyze Datadog logs by grouping them by fields. Use this for statistics and counts (e.g., 'errors by service', 'requests by status code'). For viewing individual log entries, use datadog_logs instead.", {
-        groupBy: z
-            .array(z.string())
-            .describe("Fields to group by. Examples: ['source'], ['service', 'status'], ['@http.status_code']. Common facets: source, service, status, host, @http.status_code, @env."),
-        query: z
-            .string()
-            .optional()
-            .describe("Filter query. Examples: 'status:error', '*timeout*', '@http.method:POST'. Use '*' for all logs."),
-        source: z
-            .string()
-            .optional()
-            .describe("Override the log source filter. Use '*' to include all sources. If not provided, uses DD_SOURCE env var or defaults to 'lambda'."),
-        env: z
-            .string()
-            .optional()
-            .describe("Override the environment filter. If not provided, uses DD_ENV env var."),
-        service: z
-            .string()
-            .optional()
-            .describe("Override the service name filter. If not provided, uses DD_SERVICE env var."),
-        from: z
-            .string()
-            .optional()
-            .describe("Start time. Formats: relative ('now-15m', 'now-1h', 'now-1d'), ISO 8601 ('2024-01-15T10:00:00Z'). Defaults to 'now-15m'."),
-        to: z
-            .string()
-            .optional()
-            .describe("End time. Formats: 'now', relative ('now-5m'), or ISO 8601. Defaults to 'now'."),
-        aggregation: z
-            .enum(["count", "avg", "sum", "min", "max", "cardinality"])
-            .optional()
-            .describe("Aggregation type. 'count' counts logs, others require a metric field. Defaults to 'count'."),
-        metric: z
-            .string()
-            .optional()
-            .describe("Metric field to aggregate when using avg, sum, min, max, or cardinality. E.g., '@duration', '@http.response_time'."),
-    }, async ({ groupBy, query, source, env, service, from, to, aggregation, metric, }) => {
-        log.info("Tool called: datadog_log_analytics");
-        const credentials = getDatadogCredentials();
-        if (!credentials) {
-            const missingApiKey = !process.env.DATADOG_API_KEY && !process.env.DD_API_KEY;
-            const missingAppKey = !process.env.DATADOG_APP_KEY &&
-                !process.env.DATADOG_APPLICATION_KEY &&
-                !process.env.DD_APP_KEY &&
-                !process.env.DD_APPLICATION_KEY;
-            if (missingApiKey) {
-                log.error("No Datadog API key found in environment");
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "Error: No Datadog API key found. Please set DATADOG_API_KEY or DD_API_KEY environment variable.",
-                        },
-                    ],
-                };
-            }
-            if (missingAppKey) {
-                log.error("No Datadog Application key found in environment");
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "Error: No Datadog Application key found. Please set DATADOG_APP_KEY or DD_APP_KEY environment variable.",
-                        },
-                    ],
-                };
-            }
-        }
-        const compute = aggregation
-            ? [{ aggregation, metric }]
-            : [{ aggregation: "count" }];
-        const result = await aggregateDatadogLogs(credentials, {
-            query,
-            source,
-            env,
-            service,
-            from,
-            to,
-            groupBy,
-            compute,
-        }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error from Datadog Analytics API: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        if (result.buckets.length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `No data found for query: ${result.query}\nTime range: ${result.timeRange.from} to ${result.timeRange.to}\nGrouped by: ${result.groupBy.join(", ")}`,
-                    },
-                ],
-            };
-        }
-        // Format buckets as a readable table
-        const formattedBuckets = result.buckets.map((bucket) => {
-            const byParts = Object.entries(bucket.by)
-                .map(([key, value]) => `${key}: ${value}`)
-                .join(", ");
-            const computeParts = Object.entries(bucket.computes)
-                .map(([key, value]) => `${key}: ${value}`)
-                .join(", ");
-            return `  ${byParts} => ${computeParts}`;
-        });
-        const resultText = [
-            `Query: ${result.query}`,
-            `Time range: ${result.timeRange.from} to ${result.timeRange.to}`,
-            `Grouped by: ${result.groupBy.join(", ")}`,
-            `Found ${result.buckets.length} groups:`,
-            "",
-            ...formattedBuckets,
-        ].join("\n");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: resultText,
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: datadog_log_analytics");
-    // Datadog Monitors Tool
-    server.tool("datadog_monitors", "List and check Datadog monitors. Shows monitor status (Alert, Warn, No Data, OK), name, type, and tags. Useful for quickly checking if any monitors are alerting.", {
-        status: z
-            .array(z.enum(["Alert", "Warn", "No Data", "OK"]))
-            .optional()
-            .describe("Filter monitors by status. E.g., ['Alert', 'Warn'] to see only alerting monitors."),
-        tags: z
-            .array(z.string())
-            .optional()
-            .describe("Filter monitors by resource tags (tags on the monitored resources)."),
-        monitorTags: z
-            .array(z.string())
-            .optional()
-            .describe("Filter monitors by monitor tags (tags on the monitor itself)."),
-        name: z
-            .string()
-            .optional()
-            .describe("Filter monitors by name (partial match supported)."),
-    }, async ({ status, tags, monitorTags, name }) => {
-        log.info("Tool called: datadog_monitors");
-        const credentials = getDatadogCredentials();
-        if (!credentials) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "Error: Datadog credentials not found. Please set DATADOG_API_KEY and DATADOG_APP_KEY environment variables.",
-                    },
-                ],
-            };
-        }
-        const result = await listDatadogMonitors(credentials, { status, tags, monitorTags, name }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error from Datadog Monitors API: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        if (result.monitors.length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "No monitors found matching the specified criteria.",
-                    },
-                ],
-            };
-        }
-        // Group monitors by status for better readability
-        const byStatus = {};
-        for (const monitor of result.monitors) {
-            const status = monitor.status;
-            if (!byStatus[status]) {
-                byStatus[status] = [];
-            }
-            byStatus[status].push(monitor);
-        }
-        const statusOrder = ["Alert", "Warn", "No Data", "OK", "Unknown"];
-        const formattedMonitors = [];
-        for (const status of statusOrder) {
-            const monitors = byStatus[status];
-            if (monitors && monitors.length > 0) {
-                formattedMonitors.push(`\n## ${status} (${monitors.length})`);
-                for (const m of monitors) {
-                    formattedMonitors.push(`  - [${m.id}] ${m.name} (${m.type})`);
-                }
-            }
-        }
-        const resultText = [
-            `Found ${result.monitors.length} monitors:`,
-            ...formattedMonitors,
-        ].join("\n");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: resultText,
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: datadog_monitors");
-    // Datadog Synthetics Tool
-    server.tool("datadog_synthetics", "List Datadog Synthetic tests and optionally get recent results for a specific test. Shows test status, type (api/browser), and locations.", {
-        type: z
-            .enum(["api", "browser"])
-            .optional()
-            .describe("Filter tests by type: 'api' or 'browser'."),
-        tags: z.array(z.string()).optional().describe("Filter tests by tags."),
-        testId: z
-            .string()
-            .optional()
-            .describe("If provided, fetches recent results for this specific test (public_id). Otherwise lists all tests."),
-    }, async ({ type, tags, testId }) => {
-        log.info("Tool called: datadog_synthetics");
-        const credentials = getDatadogCredentials();
-        if (!credentials) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "Error: Datadog credentials not found. Please set DATADOG_API_KEY and DATADOG_APP_KEY environment variables.",
-                    },
-                ],
-            };
-        }
-        // If testId is provided, get results for that specific test
-        if (testId) {
-            const result = await getDatadogSyntheticResults(credentials, testId, log);
-            if (!result.success) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Error from Datadog Synthetics API: ${result.error}`,
-                        },
-                    ],
-                };
-            }
-            if (result.results.length === 0) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `No recent results found for test: ${testId}`,
-                        },
-                    ],
-                };
-            }
-            const passedCount = result.results.filter((r) => r.passed).length;
-            const failedCount = result.results.length - passedCount;
-            const formattedResults = result.results.slice(0, 10).map((r) => {
-                const date = new Date(r.checkTime * 1000).toISOString();
-                const status = r.passed ? "✓ PASSED" : "✗ FAILED";
-                return `  ${date} - ${status}`;
-            });
-            const resultText = [
-                `Results for test: ${testId}`,
-                `Recent: ${passedCount} passed, ${failedCount} failed (showing last ${Math.min(10, result.results.length)})`,
-                "",
-                ...formattedResults,
-            ].join("\n");
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: resultText,
-                    },
-                ],
-            };
-        }
-        // Otherwise list all tests
-        const result = await listDatadogSynthetics(credentials, { type, tags }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error from Datadog Synthetics API: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        if (result.tests.length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "No synthetic tests found matching the specified criteria.",
-                    },
-                ],
-            };
-        }
-        // Group by status
-        const byStatus = {};
-        for (const test of result.tests) {
-            const status = test.status;
-            if (!byStatus[status]) {
-                byStatus[status] = [];
-            }
-            byStatus[status].push(test);
-        }
-        const formattedTests = [];
-        for (const [status, tests] of Object.entries(byStatus)) {
-            formattedTests.push(`\n## ${status} (${tests.length})`);
-            for (const t of tests) {
-                formattedTests.push(`  - [${t.publicId}] ${t.name} (${t.type})`);
-            }
-        }
-        const resultText = [
-            `Found ${result.tests.length} synthetic tests:`,
-            ...formattedTests,
-        ].join("\n");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: resultText,
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: datadog_synthetics");
-    // Datadog Metrics Tool
-    server.tool("datadog_metrics", "Query Datadog metrics. Returns timeseries data for the specified metric query. Useful for checking specific metric values.", {
-        query: z
-            .string()
-            .describe("Metric query. Format: 'aggregation:metric.name{tags}'. Examples: 'avg:system.cpu.user{*}', 'sum:aws.lambda.invocations{function:my-func}.as_count()', 'max:aws.lambda.duration{env:production}'."),
-        from: z
-            .string()
-            .optional()
-            .describe("Start time. Formats: relative ('1h', '30m', '1d'), or Unix timestamp. Defaults to '1h'."),
-        to: z
-            .string()
-            .optional()
-            .describe("End time. Formats: 'now' or Unix timestamp. Defaults to 'now'."),
-    }, async ({ query, from, to }) => {
-        log.info("Tool called: datadog_metrics");
-        const credentials = getDatadogCredentials();
-        if (!credentials) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "Error: Datadog credentials not found. Please set DATADOG_API_KEY and DATADOG_APP_KEY environment variables.",
-                    },
-                ],
-            };
-        }
-        // Parse time parameters
-        const now = Math.floor(Date.now() / 1000);
-        let fromTs;
-        let toTs;
-        // Parse 'from' parameter
-        const fromStr = from || "1h";
-        if (fromStr.match(/^\d+$/)) {
-            fromTs = parseInt(fromStr, 10);
-        }
-        else if (fromStr.match(/^(\d+)h$/)) {
-            const hours = parseInt(fromStr.match(/^(\d+)h$/)[1], 10);
-            fromTs = now - hours * 3600;
-        }
-        else if (fromStr.match(/^(\d+)m$/)) {
-            const minutes = parseInt(fromStr.match(/^(\d+)m$/)[1], 10);
-            fromTs = now - minutes * 60;
-        }
-        else if (fromStr.match(/^(\d+)d$/)) {
-            const days = parseInt(fromStr.match(/^(\d+)d$/)[1], 10);
-            fromTs = now - days * 86400;
-        }
-        else {
-            fromTs = now - 3600; // Default 1 hour
-        }
-        // Parse 'to' parameter
-        const toStr = to || "now";
-        if (toStr === "now") {
-            toTs = now;
-        }
-        else if (toStr.match(/^\d+$/)) {
-            toTs = parseInt(toStr, 10);
-        }
-        else {
-            toTs = now;
-        }
-        const result = await queryDatadogMetrics(credentials, { query, from: fromTs, to: toTs }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error from Datadog Metrics API: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        if (result.series.length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `No data found for query: ${query}\nTime range: ${new Date(fromTs * 1000).toISOString()} to ${new Date(toTs * 1000).toISOString()}`,
-                    },
-                ],
-            };
-        }
-        const formattedSeries = result.series.map((s) => {
-            const points = s.pointlist.slice(-5); // Last 5 points
-            const formattedPoints = points
-                .map(([ts, val]) => {
-                const date = new Date(ts).toISOString();
-                return `    ${date}: ${val !== null ? val.toFixed(4) : "null"}`;
-            })
-                .join("\n");
-            return `\n  ${s.metric} (${s.scope})${s.unit ? ` [${s.unit}]` : ""}:\n${formattedPoints}`;
-        });
-        const resultText = [
-            `Query: ${query}`,
-            `Time range: ${new Date(fromTs * 1000).toISOString()} to ${new Date(toTs * 1000).toISOString()}`,
-            `Found ${result.series.length} series (showing last 5 points each):`,
-            ...formattedSeries,
-        ].join("\n");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: resultText,
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: datadog_metrics");
-    // Datadog RUM Tool
-    server.tool("datadog_rum", "Search Datadog RUM (Real User Monitoring) events. Find user sessions, page views, errors, and actions. Useful for debugging frontend issues and understanding user behavior.", {
-        query: z
-            .string()
-            .optional()
-            .describe("RUM search query. E.g., '@type:error', '@session.id:abc123', '@view.url:*checkout*'. Defaults to '*' (all events)."),
-        from: z
-            .string()
-            .optional()
-            .describe("Start time. Formats: relative ('now-15m', 'now-1h', 'now-1d'), ISO 8601 ('2024-01-15T10:00:00Z'). Defaults to 'now-15m'."),
-        to: z
-            .string()
-            .optional()
-            .describe("End time. Formats: 'now', relative ('now-5m'), or ISO 8601. Defaults to 'now'."),
-        limit: z
-            .number()
-            .optional()
-            .describe("Max events to return (1-1000). Defaults to 50."),
-    }, async ({ query, from, to, limit }) => {
-        log.info("Tool called: datadog_rum");
-        const credentials = getDatadogCredentials();
-        if (!credentials) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "Error: Datadog credentials not found. Please set DATADOG_API_KEY and DATADOG_APP_KEY environment variables.",
-                    },
-                ],
-            };
-        }
-        const result = await searchDatadogRum(credentials, { query, from, to, limit }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error from Datadog RUM API: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        if (result.events.length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `No RUM events found for query: ${result.query}\nTime range: ${result.timeRange.from} to ${result.timeRange.to}`,
-                    },
-                ],
-            };
-        }
-        // Group events by type for better readability
-        const byType = {};
-        for (const event of result.events) {
-            const type = event.type;
-            if (!byType[type]) {
-                byType[type] = [];
-            }
-            byType[type].push(event);
-        }
-        const formattedEvents = [];
-        for (const [type, events] of Object.entries(byType)) {
-            formattedEvents.push(`\n## ${type} (${events.length})`);
-            for (const e of events.slice(0, 10)) {
-                // Limit per type
-                const parts = [e.timestamp];
-                if (e.viewName || e.viewUrl) {
-                    parts.push(e.viewName || e.viewUrl || "");
-                }
-                if (e.errorMessage) {
-                    parts.push(`Error: ${e.errorMessage}`);
-                }
-                if (e.sessionId) {
-                    parts.push(`Session: ${e.sessionId.substring(0, 8)}...`);
-                }
-                formattedEvents.push(`  - ${parts.join(" | ")}`);
-            }
-        }
-        const resultText = [
-            `Query: ${result.query}`,
-            `Time range: ${result.timeRange.from} to ${result.timeRange.to}`,
-            `Found ${result.events.length} RUM events:`,
-            ...formattedEvents,
-        ].join("\n");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: resultText,
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: datadog_rum");
-    // LLM Debug Tools
-    server.tool("llm_debug_call", "Make a debug LLM API call and inspect the raw response. Useful for understanding how each provider formats responses, especially for reasoning/thinking content. Returns full history, raw responses, and extracted reasoning.", {
-        provider: z
-            .enum(["anthropic", "gemini", "openai", "openrouter"])
-            .describe("LLM provider to call"),
-        model: z
-            .string()
-            .optional()
-            .describe("Model to use. If not provided, uses a sensible default. For reasoning tests, try 'o3-mini' with openai."),
-        message: z
-            .string()
-            .describe("Message to send to the LLM. For reasoning tests, try something that requires thinking like 'What is 15 * 17? Think step by step.'"),
-    }, async ({ provider, model, message }) => {
-        log.info(`Tool called: llm_debug_call (provider: ${provider})`);
-        const result = await debugLlmCall({ provider: provider, model, message }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error calling ${provider}: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        const sections = [
-            `## LLM Debug Call Result`,
-            `Provider: ${result.provider}`,
-            `Model: ${result.model}`,
-            ``,
-            `### Content`,
-            result.content || "(no content)",
-            ``,
-            `### Reasoning (${result.reasoning?.length || 0} items, ${result.reasoningTokens || 0} tokens)`,
-            result.reasoning && result.reasoning.length > 0
-                ? result.reasoning.map((r, i) => `[${i}] ${r}`).join("\n")
-                : "(no reasoning extracted)",
-            ``,
-            `### Usage`,
-            JSON.stringify(result.usage, null, 2),
-            ``,
-            `### History (${result.history?.length || 0} items)`,
-            JSON.stringify(result.history, null, 2),
-            ``,
-            `### Raw Responses (${result.rawResponses?.length || 0} items)`,
-            JSON.stringify(result.rawResponses, null, 2),
-        ];
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: sections.join("\n"),
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: llm_debug_call");
-    server.tool("llm_list_providers", "List available LLM providers with their default and reasoning-capable models.", {}, async () => {
-        log.info("Tool called: llm_list_providers");
-        const { providers } = listLlmProviders();
-        const formatted = providers.map((p) => {
-            const reasoningNote = p.reasoningModels.length > 0
-                ? `Reasoning models: ${p.reasoningModels.join(", ")}`
-                : "No known reasoning models";
-            return `- ${p.name}: default=${p.defaultModel}, ${reasoningNote}`;
-        });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: [
-                        "## Available LLM Providers",
-                        "",
-                        ...formatted,
-                        "",
-                        "Use llm_debug_call to test responses from any provider.",
-                    ].join("\n"),
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: llm_list_providers");
-    // AWS CLI Tools
-    // AWS List Profiles
-    server.tool("aws_list_profiles", "List available AWS profiles from ~/.aws/config and credentials.", {}, async () => {
-        log.info("Tool called: aws_list_profiles");
-        const result = await listAwsProfiles(log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error listing profiles: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        const profiles = result.data || [];
-        if (profiles.length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "No AWS profiles found. Configure profiles in ~/.aws/config or ~/.aws/credentials.",
-                    },
-                ],
-            };
-        }
-        const formatted = profiles
-            .map((p) => `- ${p.name} (${p.source})`)
-            .join("\n");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: [
-                        `Found ${profiles.length} AWS profiles:`,
-                        "",
-                        formatted,
-                        "",
-                        "Use the 'profile' parameter in other AWS tools to specify which profile to use.",
-                    ].join("\n"),
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: aws_list_profiles");
-    // Step Functions: List Executions
-    server.tool("aws_stepfunctions_list_executions", "List Step Function executions for a state machine. Useful for finding stuck or running executions.", {
-        stateMachineArn: z.string().describe("ARN of the state machine"),
-        statusFilter: z
-            .enum([
-            "RUNNING",
-            "SUCCEEDED",
-            "FAILED",
-            "TIMED_OUT",
-            "ABORTED",
-            "PENDING_REDRIVE",
-        ])
-            .optional()
-            .describe("Filter by execution status"),
-        profile: z.string().optional().describe("AWS profile to use"),
-        region: z.string().optional().describe("AWS region"),
-        maxResults: z
-            .number()
-            .optional()
-            .describe("Max results (1-1000, default 100)"),
-    }, async ({ stateMachineArn, statusFilter, profile, region, maxResults }) => {
-        log.info("Tool called: aws_stepfunctions_list_executions");
-        const result = await listStepFunctionExecutions({
-            stateMachineArn,
-            statusFilter,
-            profile,
-            region,
-            maxResults,
-        }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        const executions = result.data?.executions || [];
-        if (executions.length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `No ${statusFilter || ""} executions found for state machine.`,
-                    },
-                ],
-            };
-        }
-        const formatted = executions
-            .map((e) => `- ${e.name} (${e.status}) started ${e.startDate}`)
-            .join("\n");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: [
-                        `Found ${executions.length} executions:`,
-                        "",
-                        formatted,
-                        "",
-                        "Use aws_stepfunctions_stop_execution to stop running executions.",
-                    ].join("\n"),
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: aws_stepfunctions_list_executions");
-    // Step Functions: Stop Execution
-    server.tool("aws_stepfunctions_stop_execution", "Stop a running Step Function execution. Use with caution - this will abort the workflow.", {
-        executionArn: z.string().describe("ARN of the execution to stop"),
-        cause: z
-            .string()
-            .optional()
-            .describe("Description of why the execution was stopped"),
-        profile: z.string().optional().describe("AWS profile to use"),
-        region: z.string().optional().describe("AWS region"),
-    }, async ({ executionArn, cause, profile, region }) => {
-        log.info("Tool called: aws_stepfunctions_stop_execution");
-        const result = await stopStepFunctionExecution({
-            executionArn,
-            cause,
-            profile,
-            region,
-        }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error stopping execution: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Execution stopped successfully at ${result.data?.stopDate || "unknown time"}.`,
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: aws_stepfunctions_stop_execution");
-    // Lambda: List Functions
-    server.tool("aws_lambda_list_functions", "List Lambda functions in the account. Filter by function name prefix.", {
-        functionNamePrefix: z
-            .string()
-            .optional()
-            .describe("Filter by function name prefix"),
-        profile: z.string().optional().describe("AWS profile to use"),
-        region: z.string().optional().describe("AWS region"),
-        maxResults: z.number().optional().describe("Max results to return"),
-    }, async ({ functionNamePrefix, profile, region, maxResults }) => {
-        log.info("Tool called: aws_lambda_list_functions");
-        const result = await listLambdaFunctions({
-            functionNamePrefix,
-            profile,
-            region,
-            maxResults,
-        }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        const functions = result.data?.Functions || [];
-        if (functions.length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: functionNamePrefix
-                            ? `No functions found with prefix "${functionNamePrefix}".`
-                            : "No Lambda functions found in this account/region.",
-                    },
-                ],
-            };
-        }
-        const formatted = functions
-            .map((f) => `- ${f.FunctionName} (${f.Runtime || "unknown runtime"}, ${f.MemorySize}MB)`)
-            .join("\n");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: [
-                        `Found ${functions.length} Lambda functions:`,
-                        "",
-                        formatted,
-                        "",
-                        "Use aws_lambda_get_function for details on a specific function.",
-                    ].join("\n"),
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: aws_lambda_list_functions");
-    // Lambda: Get Function
-    server.tool("aws_lambda_get_function", "Get configuration and details for a specific Lambda function.", {
-        functionName: z.string().describe("Function name or ARN"),
-        profile: z.string().optional().describe("AWS profile to use"),
-        region: z.string().optional().describe("AWS region"),
-    }, async ({ functionName, profile, region }) => {
-        log.info("Tool called: aws_lambda_get_function");
-        const result = await getLambdaFunction({
-            functionName,
-            profile,
-            region,
-        }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(result.data, null, 2),
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: aws_lambda_get_function");
-    // CloudWatch Logs: Filter Log Events
-    server.tool("aws_logs_filter_log_events", "Search CloudWatch Logs for a log group. Filter by pattern and time range.", {
-        logGroupName: z
-            .string()
-            .describe("Log group name (e.g., /aws/lambda/my-function)"),
-        filterPattern: z
-            .string()
-            .optional()
-            .describe("CloudWatch filter pattern (e.g., 'ERROR', '{ $.level = \"error\" }')"),
-        startTime: z
-            .string()
-            .optional()
-            .describe("Start time (ISO 8601 or relative like 'now-1h'). Defaults to 'now-15m'."),
-        endTime: z
-            .string()
-            .optional()
-            .describe("End time (ISO 8601 or 'now'). Defaults to 'now'."),
-        profile: z.string().optional().describe("AWS profile to use"),
-        region: z.string().optional().describe("AWS region"),
-        limit: z
-            .number()
-            .optional()
-            .describe("Max events to return (default 100)"),
-    }, async ({ logGroupName, filterPattern, startTime, endTime, profile, region, limit, }) => {
-        log.info("Tool called: aws_logs_filter_log_events");
-        const result = await filterLogEvents({
-            logGroupName,
-            filterPattern,
-            startTime: startTime || "now-15m",
-            endTime: endTime || "now",
-            limit: limit || 100,
-            profile,
-            region,
-        }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        const events = result.data?.events || [];
-        if (events.length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `No log events found matching the filter in ${logGroupName}.`,
-                    },
-                ],
-            };
-        }
-        const formatted = events
-            .map((e) => {
-            const timestamp = new Date(e.timestamp).toISOString();
-            return `[${timestamp}] ${e.message}`;
-        })
-            .join("\n");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: [`Found ${events.length} log events:`, "", formatted].join("\n"),
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: aws_logs_filter_log_events");
-    // S3: List Objects
-    server.tool("aws_s3_list_objects", "List objects in an S3 bucket with optional prefix filtering.", {
-        bucket: z.string().describe("S3 bucket name"),
-        prefix: z.string().optional().describe("Object key prefix filter"),
-        profile: z.string().optional().describe("AWS profile to use"),
-        region: z.string().optional().describe("AWS region"),
-        maxResults: z.number().optional().describe("Max results to return"),
-    }, async ({ bucket, prefix, profile, region, maxResults }) => {
-        log.info("Tool called: aws_s3_list_objects");
-        const result = await listS3Objects({
-            bucket,
-            prefix,
-            profile,
-            region,
-            maxResults,
-        }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        const objects = result.data?.Contents || [];
-        if (objects.length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: prefix
-                            ? `No objects found with prefix "${prefix}" in bucket ${bucket}.`
-                            : `Bucket ${bucket} is empty.`,
-                    },
-                ],
-            };
-        }
-        const formatted = objects
-            .map((o) => {
-            const size = o.Size < 1024
-                ? `${o.Size}B`
-                : o.Size < 1024 * 1024
-                    ? `${(o.Size / 1024).toFixed(1)}KB`
-                    : `${(o.Size / (1024 * 1024)).toFixed(1)}MB`;
-            return `- ${o.Key} (${size}, ${o.LastModified})`;
-        })
-            .join("\n");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: [
-                        `Found ${objects.length} objects in ${bucket}:`,
-                        "",
-                        formatted,
-                    ].join("\n"),
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: aws_s3_list_objects");
-    // CloudFormation: Describe Stack
-    server.tool("aws_cloudformation_describe_stack", "Get details and status of a CloudFormation stack.", {
-        stackName: z.string().describe("Stack name or ARN"),
-        profile: z.string().optional().describe("AWS profile to use"),
-        region: z.string().optional().describe("AWS region"),
-    }, async ({ stackName, profile, region }) => {
-        log.info("Tool called: aws_cloudformation_describe_stack");
-        const result = await describeStack({
-            stackName,
-            profile,
-            region,
-        }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        const stack = result.data?.Stacks?.[0];
-        if (!stack) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Stack "${stackName}" not found.`,
-                    },
-                ],
-            };
-        }
-        const outputs = stack.Outputs?.map((o) => `  - ${o.OutputKey}: ${o.OutputValue}`).join("\n");
-        const params = stack.Parameters?.map((p) => `  - ${p.ParameterKey}: ${p.ParameterValue}`).join("\n");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: [
-                        `Stack: ${stack.StackName}`,
-                        `Status: ${stack.StackStatus}`,
-                        stack.StackStatusReason
-                            ? `Reason: ${stack.StackStatusReason}`
-                            : null,
-                        `Created: ${stack.CreationTime}`,
-                        stack.LastUpdatedTime
-                            ? `Last Updated: ${stack.LastUpdatedTime}`
-                            : null,
-                        stack.Description ? `Description: ${stack.Description}` : null,
-                        "",
-                        outputs ? `Outputs:\n${outputs}` : null,
-                        params ? `Parameters:\n${params}` : null,
-                    ]
-                        .filter(Boolean)
-                        .join("\n"),
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: aws_cloudformation_describe_stack");
-    // DynamoDB: Describe Table
-    server.tool("aws_dynamodb_describe_table", "Get metadata about a DynamoDB table including key schema, indexes, and provisioned capacity.", {
-        tableName: z.string().describe("DynamoDB table name"),
-        profile: z.string().optional().describe("AWS profile to use"),
-        region: z.string().optional().describe("AWS region"),
-    }, async ({ tableName, profile, region }) => {
-        log.info("Tool called: aws_dynamodb_describe_table");
-        const result = await describeDynamoDBTable({
-            tableName,
-            profile,
-            region,
-        }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(result.data?.Table, null, 2),
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: aws_dynamodb_describe_table");
-    // DynamoDB: Scan
-    server.tool("aws_dynamodb_scan", "Scan a DynamoDB table. Use sparingly on large tables - prefer query when possible.", {
-        tableName: z.string().describe("DynamoDB table name"),
-        filterExpression: z
-            .string()
-            .optional()
-            .describe("Filter expression (e.g., 'status = :s')"),
-        expressionAttributeValues: z
-            .string()
-            .optional()
-            .describe('JSON object of attribute values (e.g., \'{\\":s\\":{\\"S\\":\\"active\\"}}\')'),
-        limit: z.number().optional().describe("Max items to return (default 25)"),
-        profile: z.string().optional().describe("AWS profile to use"),
-        region: z.string().optional().describe("AWS region"),
-    }, async ({ tableName, filterExpression, expressionAttributeValues, limit, profile, region, }) => {
-        log.info("Tool called: aws_dynamodb_scan");
-        const result = await scanDynamoDB({
-            tableName,
-            filterExpression,
-            expressionAttributeValues,
-            limit: limit || 25,
-            profile,
-            region,
-        }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        const items = result.data?.Items || [];
-        if (items.length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `No items found in table ${tableName}.`,
-                    },
-                ],
-            };
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: [
-                        `Found ${items.length} items:`,
-                        "",
-                        JSON.stringify(items, null, 2),
-                    ].join("\n"),
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: aws_dynamodb_scan");
-    // DynamoDB: Query
-    server.tool("aws_dynamodb_query", "Query a DynamoDB table by partition key. More efficient than scan for targeted lookups.", {
-        tableName: z.string().describe("DynamoDB table name"),
-        keyConditionExpression: z
-            .string()
-            .describe("Key condition (e.g., 'pk = :pk')"),
-        expressionAttributeValues: z
-            .string()
-            .describe("JSON object of attribute values"),
-        indexName: z.string().optional().describe("GSI or LSI name to query"),
-        filterExpression: z
-            .string()
-            .optional()
-            .describe("Additional filter expression"),
-        limit: z.number().optional().describe("Max items to return"),
-        scanIndexForward: z
-            .boolean()
-            .optional()
-            .describe("Sort ascending (true) or descending (false)"),
-        profile: z.string().optional().describe("AWS profile to use"),
-        region: z.string().optional().describe("AWS region"),
-    }, async ({ tableName, keyConditionExpression, expressionAttributeValues, indexName, filterExpression, limit, scanIndexForward, profile, region, }) => {
-        log.info("Tool called: aws_dynamodb_query");
-        const result = await queryDynamoDB({
-            tableName,
-            keyConditionExpression,
-            expressionAttributeValues,
-            indexName,
-            filterExpression,
-            limit,
-            scanIndexForward,
-            profile,
-            region,
-        }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        const items = result.data?.Items || [];
-        if (items.length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `No items found matching the query.`,
-                    },
-                ],
-            };
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: [
-                        `Found ${items.length} items:`,
-                        "",
-                        JSON.stringify(items, null, 2),
-                    ].join("\n"),
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: aws_dynamodb_query");
-    // DynamoDB: Get Item
-    server.tool("aws_dynamodb_get_item", "Get a single item from a DynamoDB table by its primary key.", {
-        tableName: z.string().describe("DynamoDB table name"),
-        key: z
-            .string()
-            .describe('JSON object of the primary key (e.g., \'{\\"pk\\":{\\"S\\":\\"user#123\\"},\\"sk\\":{\\"S\\":\\"profile\\"}}\')'),
-        profile: z.string().optional().describe("AWS profile to use"),
-        region: z.string().optional().describe("AWS region"),
-    }, async ({ tableName, key, profile, region }) => {
-        log.info("Tool called: aws_dynamodb_get_item");
-        const result = await getDynamoDBItem({
-            tableName,
-            key,
-            profile,
-            region,
-        }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        if (!result.data?.Item) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Item not found with the specified key.`,
-                    },
-                ],
-            };
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(result.data.Item, null, 2),
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: aws_dynamodb_get_item");
-    // SQS: List Queues
-    server.tool("aws_sqs_list_queues", "List SQS queues in the account. Filter by queue name prefix.", {
-        queueNamePrefix: z
-            .string()
-            .optional()
-            .describe("Filter by queue name prefix"),
-        profile: z.string().optional().describe("AWS profile to use"),
-        region: z.string().optional().describe("AWS region"),
-    }, async ({ queueNamePrefix, profile, region }) => {
-        log.info("Tool called: aws_sqs_list_queues");
-        const result = await listSQSQueues({
-            queueNamePrefix,
-            profile,
-            region,
-        }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        const queues = result.data?.QueueUrls || [];
-        if (queues.length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: queueNamePrefix
-                            ? `No queues found with prefix "${queueNamePrefix}".`
-                            : "No SQS queues found in this account/region.",
-                    },
-                ],
-            };
-        }
-        const formatted = queues.map((url) => `- ${url}`).join("\n");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: [
-                        `Found ${queues.length} queues:`,
-                        "",
-                        formatted,
-                        "",
-                        "Use aws_sqs_get_queue_attributes for details on a specific queue.",
-                    ].join("\n"),
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: aws_sqs_list_queues");
-    // SQS: Get Queue Attributes
-    server.tool("aws_sqs_get_queue_attributes", "Get attributes for an SQS queue including approximate message count, visibility timeout, and dead-letter config.", {
-        queueUrl: z.string().describe("SQS queue URL"),
-        profile: z.string().optional().describe("AWS profile to use"),
-        region: z.string().optional().describe("AWS region"),
-    }, async ({ queueUrl, profile, region }) => {
-        log.info("Tool called: aws_sqs_get_queue_attributes");
-        const result = await getSQSQueueAttributes({
-            queueUrl,
-            profile,
-            region,
-        }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        const attrs = result.data?.Attributes;
-        if (!attrs) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `No attributes found for queue.`,
-                    },
-                ],
-            };
-        }
-        const formatted = Object.entries(attrs)
-            .map(([key, value]) => `- ${key}: ${value}`)
-            .join("\n");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: [`Queue Attributes:`, "", formatted].join("\n"),
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: aws_sqs_get_queue_attributes");
-    // SQS: Receive Message
-    server.tool("aws_sqs_receive_message", "Receive messages from an SQS queue for inspection. Messages are returned to the queue after visibility timeout.", {
-        queueUrl: z.string().describe("SQS queue URL"),
-        maxNumberOfMessages: z
-            .number()
-            .optional()
-            .describe("Max messages to receive (1-10, default 1)"),
-        visibilityTimeout: z
-            .number()
-            .optional()
-            .describe("Seconds to hide message (default 30)"),
-        profile: z.string().optional().describe("AWS profile to use"),
-        region: z.string().optional().describe("AWS region"),
-    }, async ({ queueUrl, maxNumberOfMessages, visibilityTimeout, profile, region, }) => {
-        log.info("Tool called: aws_sqs_receive_message");
-        const result = await receiveSQSMessage({
-            queueUrl,
-            maxNumberOfMessages: maxNumberOfMessages || 1,
-            visibilityTimeout: visibilityTimeout || 30,
-            profile,
-            region,
-        }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        const messages = result.data?.Messages || [];
-        if (messages.length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `No messages available in the queue.`,
-                    },
-                ],
-            };
-        }
-        const formatted = messages
-            .map((m, i) => {
-            return [
-                `Message ${i + 1}:`,
-                `  ID: ${m.MessageId}`,
-                `  Body: ${m.Body}`,
-                m.Attributes
-                    ? `  Attributes: ${JSON.stringify(m.Attributes)}`
-                    : null,
-            ]
-                .filter(Boolean)
-                .join("\n");
-        })
-            .join("\n\n");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: [
-                        `Received ${messages.length} messages (will be returned to queue after visibility timeout):`,
-                        "",
-                        formatted,
-                    ].join("\n"),
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: aws_sqs_receive_message");
-    // SQS: Purge Queue
-    server.tool("aws_sqs_purge_queue", "Delete all messages from an SQS queue. Use with caution - this is irreversible.", {
-        queueUrl: z.string().describe("SQS queue URL"),
-        profile: z.string().optional().describe("AWS profile to use"),
-        region: z.string().optional().describe("AWS region"),
-    }, async ({ queueUrl, profile, region }) => {
-        log.info("Tool called: aws_sqs_purge_queue");
-        const result = await purgeSQSQueue({
-            queueUrl,
-            profile,
-            region,
-        }, log);
-        if (!result.success) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${result.error}`,
-                    },
-                ],
-            };
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Queue purged successfully. All messages have been deleted.`,
-                },
-            ],
-        };
-    });
-    log.info("Registered tool: aws_sqs_purge_queue");
-    log.info("MCP server configuration complete");
+    if (verbose) {
+        console.error(`[jaypie-mcp] Registered ${suite.services.length} tools from suite`);
+        console.error(`[jaypie-mcp] Categories: ${suite.categories.join(", ")}`);
+    }
     return server;
 }