@jaypie/mcp 0.2.1 → 0.2.3

package/dist/index.js

@@ -1,13 +1,15 @@
 #!/usr/bin/env node
-import { realpathSync } from 'node:fs';
+import { realpathSync, readFileSync } from 'node:fs';
+import * as path from 'node:path';
+import { join } from 'node:path';
 import { fileURLToPath, 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 * as path from 'node:path';
 import matter from 'gray-matter';
 import * as https from 'node:https';
+import { Llm } from '@jaypie/llm';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { randomUUID } from 'node:crypto';
 
@@ -797,7 +799,93 @@ async function searchDatadogRum(credentials, options = {}, logger = nullLogger)
     });
 }
 
-const BUILD_VERSION_STRING = "@jaypie/mcp@0.2.1#22724b60"
+/**
+ * LLM debugging utilities for inspecting raw provider responses
+ */
+// Default models for each provider
+const DEFAULT_MODELS = {
+    anthropic: "claude-sonnet-4-20250514",
+    gemini: "gemini-2.0-flash",
+    openai: "gpt-4o-mini",
+    openrouter: "openai/gpt-4o-mini",
+};
+/**
+ * Make a debug LLM call and return the raw response data for inspection
+ */
+async function debugLlmCall(params, log) {
+    const { provider, message } = params;
+    const model = params.model || DEFAULT_MODELS[provider];
+    log.info(`Making debug LLM call to ${provider} with model ${model}`);
+    try {
+        const llm = new Llm(provider, { model });
+        const result = await llm.operate(message, {
+            user: "[jaypie-mcp] Debug LLM Call",
+        });
+        if (result.error) {
+            return {
+                success: false,
+                provider,
+                model,
+                error: `${result.error.title}: ${result.error.detail || "Unknown error"}`,
+            };
+        }
+        // Calculate total reasoning tokens
+        const reasoningTokens = result.usage.reduce((sum, u) => sum + (u.reasoning || 0), 0);
+        return {
+            success: true,
+            provider,
+            model,
+            content: typeof result.content === "string"
+                ? result.content
+                : JSON.stringify(result.content),
+            reasoning: result.reasoning,
+            reasoningTokens,
+            history: result.history,
+            rawResponses: result.responses,
+            usage: result.usage,
+        };
+    }
+    catch (error) {
+        log.error(`Error calling ${provider}:`, error);
+        return {
+            success: false,
+            provider,
+            model,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * List available providers and their default/reasoning models
+ */
+function listLlmProviders() {
+    return {
+        providers: [
+            {
+                name: "openai",
+                defaultModel: DEFAULT_MODELS.openai,
+                reasoningModels: ["o3-mini", "o1-preview", "o1-mini"],
+            },
+            {
+                name: "anthropic",
+                defaultModel: DEFAULT_MODELS.anthropic,
+                reasoningModels: [], // Anthropic doesn't expose reasoning the same way
+            },
+            {
+                name: "gemini",
+                defaultModel: DEFAULT_MODELS.gemini,
+                reasoningModels: [], // Gemini has thoughtsTokenCount but unclear on content
+            },
+            {
+                name: "openrouter",
+                defaultModel: DEFAULT_MODELS.openrouter,
+                reasoningModels: ["openai/o3-mini", "openai/o1-preview"],
+            },
+        ],
+    };
+}
+
+const BUILD_VERSION_STRING = "@jaypie/mcp@0.2.3#9c8eed7d"
     ;
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = path.dirname(__filename$1);
@@ -1610,6 +1698,88 @@ function createMcpServer(options = {}) {
         };
     });
     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");
     log.info("MCP server configuration complete");
     return server;
 }
@@ -1666,6 +1836,41 @@ async function mcpExpressHandler(options = {}) {
 
 // Version will be injected during build
 const version = "0.0.0";
+/**
+ * Load environment variables from .env file in current working directory
+ * Simple implementation that doesn't require external dependencies
+ */
+function loadEnvFile() {
+    try {
+        const envPath = join(process.cwd(), ".env");
+        const content = readFileSync(envPath, "utf-8");
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            // Skip comments and empty lines
+            if (!trimmed || trimmed.startsWith("#"))
+                continue;
+            const eqIndex = trimmed.indexOf("=");
+            if (eqIndex === -1)
+                continue;
+            const key = trimmed.slice(0, eqIndex).trim();
+            let value = trimmed.slice(eqIndex + 1).trim();
+            // Remove surrounding quotes if present
+            if ((value.startsWith('"') && value.endsWith('"')) ||
+                (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.slice(1, -1);
+            }
+            // Only set if not already defined (environment takes precedence)
+            if (!process.env[key]) {
+                process.env[key] = value;
+            }
+        }
+    }
+    catch {
+        // .env file not found or not readable - that's fine
+    }
+}
+// Load .env file before anything else
+loadEnvFile();
 // Parse command-line arguments
 const args = process.argv.slice(2);
 const verbose = args.includes("--verbose") || args.includes("-v");