toad-eye 2.7.0 → 2.8.0

package/dist/alerts/grafana.js

@@ -2,8 +2,13 @@ export async function postGrafanaAnnotation(grafanaUrl, alert, apiKey) {
     const headers = {
         "Content-Type": "application/json",
     };
-    if (apiKey)
+    if (apiKey) {
         headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    else {
+        // Fall back to Basic Auth with default Grafana credentials
+        headers["Authorization"] = `Basic ${btoa("admin:admin")}`;
+    }
     const res = await fetch(`${grafanaUrl}/api/annotations`, {
         method: "POST",
         headers,

package/dist/core/tracer.js

@@ -8,6 +8,9 @@ import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
 import { initMetrics, resetMetrics } from "./metrics.js";
 import { resetCustomPricing } from "./pricing.js";
 import { enableAll, disableAll } from "../instrumentations/registry.js";
+import { enableMcpInstrumentation, disableMcpInstrumentation, } from "../instrumentations/mcp.js";
+import { enableMcpClientInstrumentation, disableMcpClientInstrumentation, } from "../mcp/client.js";
+import { resetMcpMetrics } from "../mcp/metrics.js";
 import { BudgetTracker } from "../budget/index.js";
 import { ToadEyeAISpanProcessor } from "../vercel.js";
 const DEFAULT_ENDPOINT = "http://localhost:4318";
@@ -122,8 +125,22 @@ export function initObservability(config) {
         budgetTracker = new BudgetTracker(config.budgets, config.onBudgetExceeded ?? "warn", config.downgradeCallback);
     }
     if (config.instrument?.length) {
-        // Filter out 'ai' — it uses SpanProcessor, not monkey-patching
-        const patchProviders = config.instrument.filter((i) => i !== "ai");
+        // Handle MCP server auto-instrumentation
+        if (config.instrument.includes("mcp")) {
+            const patched = enableMcpInstrumentation();
+            if (!patched) {
+                console.warn(`toad-eye: "@modelcontextprotocol/sdk" not found — install it to enable MCP server auto-instrumentation`);
+            }
+        }
+        // Handle MCP client auto-instrumentation
+        if (config.instrument.includes("mcp-client")) {
+            const patched = enableMcpClientInstrumentation();
+            if (!patched) {
+                console.warn(`toad-eye: "@modelcontextprotocol/sdk" not found — install it to enable MCP client auto-instrumentation`);
+            }
+        }
+        // Filter out special targets — they use separate mechanisms
+        const patchProviders = config.instrument.filter((i) => i !== "ai" && i !== "mcp" && i !== "mcp-client");
         if (patchProviders.length > 0) {
             // enableAll is async (lazy-loads provider modules on first call).
             // Fire-and-forget: patching completes before any async SDK call.
@@ -137,10 +154,13 @@ export async function shutdown() {
     if (!sdk)
         return;
     disableAll();
+    disableMcpInstrumentation();
+    disableMcpClientInstrumentation();
     await sdk.shutdown();
     sdk = null;
     currentConfig = null;
     budgetTracker = null;
     resetMetrics();
+    resetMcpMetrics();
     resetCustomPricing();
 }

package/dist/instrumentations/mcp.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Auto-instrumentation for MCP SDK.
+ *
+ * Patches McpServer.prototype so that any server instance created after
+ * enableMcpInstrumentation() is automatically instrumented — no need
+ * to call toadEyeMiddleware(server) manually.
+ *
+ * Uses __toad_eye_mcp_patched flag to prevent double-instrumentation
+ * when both auto and manual approaches are used.
+ */
+export declare function enableMcpInstrumentation(): boolean;
+export declare function disableMcpInstrumentation(): void;

package/dist/instrumentations/mcp.js

@@ -0,0 +1,85 @@
+/**
+ * Auto-instrumentation for MCP SDK.
+ *
+ * Patches McpServer.prototype so that any server instance created after
+ * enableMcpInstrumentation() is automatically instrumented — no need
+ * to call toadEyeMiddleware(server) manually.
+ *
+ * Uses __toad_eye_mcp_patched flag to prevent double-instrumentation
+ * when both auto and manual approaches are used.
+ */
+import { createRequire } from "node:module";
+import { toadEyeMiddleware } from "../mcp/middleware.js";
+const require = createRequire(import.meta.url);
+const PATCHED_FLAG = "__toad_eye_mcp_patched";
+const MODULE_NAME = "@modelcontextprotocol/sdk/server/mcp.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let mcpServerProto = null;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let originals = null;
+export function enableMcpInstrumentation() {
+    try {
+        require.resolve(MODULE_NAME);
+    }
+    catch {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const sdk = require(MODULE_NAME);
+    const McpServer = sdk.McpServer ?? sdk.default?.McpServer;
+    if (!McpServer?.prototype)
+        return false;
+    if (McpServer.prototype[PATCHED_FLAG])
+        return true;
+    const proto = McpServer.prototype;
+    mcpServerProto = proto;
+    originals = {
+        tool: proto.tool,
+        resource: proto.resource,
+        prompt: proto.prompt,
+    };
+    // WeakSet tracks which instances have been instrumented
+    const instrumented = new WeakSet();
+    function ensureInstrumented(instance) {
+        if (instrumented.has(instance))
+            return;
+        instrumented.add(instance);
+        // Restore original methods so middleware wraps the real ones
+        instance.tool = originals.tool.bind(instance);
+        if (originals.resource)
+            instance.resource = originals.resource.bind(instance);
+        if (originals.prompt)
+            instance.prompt = originals.prompt.bind(instance);
+        toadEyeMiddleware(instance);
+    }
+    proto.tool = function patchedTool(...args) {
+        ensureInstrumented(this);
+        return this.tool(...args);
+    };
+    if (originals.resource) {
+        proto.resource = function patchedResource(...args) {
+            ensureInstrumented(this);
+            return this.resource(...args);
+        };
+    }
+    if (originals.prompt) {
+        proto.prompt = function patchedPrompt(...args) {
+            ensureInstrumented(this);
+            return this.prompt(...args);
+        };
+    }
+    proto[PATCHED_FLAG] = true;
+    return true;
+}
+export function disableMcpInstrumentation() {
+    if (!mcpServerProto || !originals)
+        return;
+    mcpServerProto.tool = originals.tool;
+    if (originals.resource)
+        mcpServerProto.resource = originals.resource;
+    if (originals.prompt)
+        mcpServerProto.prompt = originals.prompt;
+    delete mcpServerProto[PATCHED_FLAG];
+    mcpServerProto = null;
+    originals = null;
+}

package/dist/mcp/client.d.ts

@@ -0,0 +1,9 @@
+/**
+ * MCP Client instrumentation — patches Client.prototype to create
+ * SpanKind.CLIENT spans for outgoing tool calls, resource reads, and prompt gets.
+ *
+ * Injects W3C traceparent into _meta field so server-side middleware
+ * can link client and server spans into one distributed trace.
+ */
+export declare function enableMcpClientInstrumentation(): boolean;
+export declare function disableMcpClientInstrumentation(): void;

package/dist/mcp/client.js

@@ -0,0 +1,137 @@
+/**
+ * MCP Client instrumentation — patches Client.prototype to create
+ * SpanKind.CLIENT spans for outgoing tool calls, resource reads, and prompt gets.
+ *
+ * Injects W3C traceparent into _meta field so server-side middleware
+ * can link client and server spans into one distributed trace.
+ */
+import { createRequire } from "node:module";
+import { trace, context, propagation, SpanKind } from "@opentelemetry/api";
+import { MCP_METHODS, endSpanSuccess, endSpanError } from "./spans.js";
+const require = createRequire(import.meta.url);
+const TRACER_NAME = "toad-eye-mcp-client";
+const PATCHED_FLAG = "__toad_eye_mcp_client_patched";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let clientProto = null;
+let originals = null;
+/**
+ * Inject W3C traceparent into MCP _meta field.
+ * This allows server-side middleware to extract parent context.
+ */
+function injectTraceContext(params) {
+    const meta = params._meta ?? {};
+    const carrier = {};
+    propagation.inject(context.active(), carrier);
+    if (carrier["traceparent"]) {
+        return {
+            ...params,
+            _meta: {
+                ...meta,
+                traceparent: carrier["traceparent"],
+                ...(carrier["tracestate"] ? { tracestate: carrier["tracestate"] } : {}),
+            },
+        };
+    }
+    return params;
+}
+export function enableMcpClientInstrumentation() {
+    try {
+        require.resolve("@modelcontextprotocol/sdk/client/index.js");
+    }
+    catch {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const sdk = require("@modelcontextprotocol/sdk/client/index.js");
+    const Client = sdk.Client ?? sdk.default?.Client;
+    if (!Client?.prototype)
+        return false;
+    if (Client.prototype[PATCHED_FLAG])
+        return true;
+    const proto = Client.prototype;
+    clientProto = proto;
+    originals = {
+        callTool: proto.callTool,
+        readResource: proto.readResource,
+        getPrompt: proto.getPrompt,
+    };
+    const tracer = trace.getTracer(TRACER_NAME);
+    // --- Patch callTool ---
+    proto.callTool = async function patchedCallTool(params, ...rest) {
+        const toolName = params.name ?? "unknown";
+        const span = tracer.startSpan(`${MCP_METHODS.TOOLS_CALL} ${toolName}`, {
+            kind: SpanKind.CLIENT,
+            attributes: {
+                "gen_ai.operation.name": MCP_METHODS.TOOLS_CALL,
+                "mcp.method.name": MCP_METHODS.TOOLS_CALL,
+                "gen_ai.tool.name": toolName,
+            },
+        });
+        const enrichedParams = injectTraceContext(params);
+        try {
+            const result = await context.with(trace.setSpan(context.active(), span), () => originals.callTool.call(this, enrichedParams, ...rest));
+            endSpanSuccess(span);
+            return result;
+        }
+        catch (error) {
+            endSpanError(span, error);
+            throw error;
+        }
+    };
+    // --- Patch readResource ---
+    proto.readResource = async function patchedReadResource(params, ...rest) {
+        const uri = params.uri ?? "unknown";
+        const span = tracer.startSpan(`${MCP_METHODS.RESOURCES_READ} ${uri}`, {
+            kind: SpanKind.CLIENT,
+            attributes: {
+                "gen_ai.operation.name": MCP_METHODS.RESOURCES_READ,
+                "mcp.method.name": MCP_METHODS.RESOURCES_READ,
+                "gen_ai.data_source.id": uri,
+            },
+        });
+        const enrichedParams = injectTraceContext(params);
+        try {
+            const result = await context.with(trace.setSpan(context.active(), span), () => originals.readResource.call(this, enrichedParams, ...rest));
+            endSpanSuccess(span);
+            return result;
+        }
+        catch (error) {
+            endSpanError(span, error);
+            throw error;
+        }
+    };
+    // --- Patch getPrompt ---
+    proto.getPrompt = async function patchedGetPrompt(params, ...rest) {
+        const promptName = params.name ?? "unknown";
+        const span = tracer.startSpan(`${MCP_METHODS.PROMPTS_GET} ${promptName}`, {
+            kind: SpanKind.CLIENT,
+            attributes: {
+                "gen_ai.operation.name": MCP_METHODS.PROMPTS_GET,
+                "mcp.method.name": MCP_METHODS.PROMPTS_GET,
+                "gen_ai.prompt.name": promptName,
+            },
+        });
+        const enrichedParams = injectTraceContext(params);
+        try {
+            const result = await context.with(trace.setSpan(context.active(), span), () => originals.getPrompt.call(this, enrichedParams, ...rest));
+            endSpanSuccess(span);
+            return result;
+        }
+        catch (error) {
+            endSpanError(span, error);
+            throw error;
+        }
+    };
+    proto[PATCHED_FLAG] = true;
+    return true;
+}
+export function disableMcpClientInstrumentation() {
+    if (!clientProto || !originals)
+        return;
+    clientProto.callTool = originals.callTool;
+    clientProto.readResource = originals.readResource;
+    clientProto.getPrompt = originals.getPrompt;
+    delete clientProto[PATCHED_FLAG];
+    clientProto = null;
+    originals = null;
+}

package/dist/mcp/index.d.ts

@@ -1,4 +1,5 @@
 export { toadEyeMiddleware, traceSampling } from "./middleware.js";
-export type { TraceSamplingOptions } from "./middleware.js";
-export type { ToadMcpOptions, McpSpanAttributes } from "./types.js";
+export type { TraceSamplingOptions, ToadEyeMiddlewareDispose, } from "./middleware.js";
+export type { ToadMcpOptions } from "./types.js";
 export { MCP_METHODS } from "./spans.js";
+export { enableMcpClientInstrumentation, disableMcpClientInstrumentation, } from "./client.js";

package/dist/mcp/index.js

@@ -1,2 +1,3 @@
 export { toadEyeMiddleware, traceSampling } from "./middleware.js";
 export { MCP_METHODS } from "./spans.js";
+export { enableMcpClientInstrumentation, disableMcpClientInstrumentation, } from "./client.js";

package/dist/mcp/metrics.d.ts

@@ -6,8 +6,10 @@
  *
  * All metrics include `mcp.method.name` dimension per OTel MCP semconv.
  */
-export declare function recordMcpToolCall(toolName: string, durationMs: number, status: "success" | "error"): void;
+export declare function recordMcpToolCall(toolName: string, durationMs: number, status: "success" | "error", sessionId?: string): void;
 export declare function recordMcpToolError(toolName: string, errorType: string): void;
 export declare function recordMcpResourceRead(uri: string): void;
 export declare function recordMcpSessionStart(): void;
 export declare function recordMcpSessionEnd(): void;
+/** Reset MCP metrics state — must be called from shutdown() alongside resetMetrics(). */
+export declare function resetMcpMetrics(): void;

package/dist/mcp/metrics.js

@@ -15,6 +15,7 @@ let toolCalls;
 let toolErrors;
 let resourceReads;
 let sessionActive;
+let toolCallers;
 let initialized = false;
 function ensureInit() {
     if (initialized)
@@ -37,8 +38,11 @@ function ensureInit() {
     sessionActive = meter.createUpDownCounter(GEN_AI_METRICS.MCP_SESSION_ACTIVE, {
         description: "Number of active MCP sessions",
     });
+    toolCallers = meter.createCounter(GEN_AI_METRICS.MCP_TOOL_CALLERS, {
+        description: "MCP tool calls by session — use count(distinct) for unique callers",
+    });
 }
-export function recordMcpToolCall(toolName, durationMs, status) {
+export function recordMcpToolCall(toolName, durationMs, status, sessionId) {
     ensureInit();
     toolCalls.add(1, {
         "gen_ai.tool.name": toolName,
@@ -49,6 +53,12 @@ export function recordMcpToolCall(toolName, durationMs, status) {
         "gen_ai.tool.name": toolName,
         "mcp.method.name": MCP_METHODS.TOOLS_CALL,
     });
+    if (sessionId) {
+        toolCallers.add(1, {
+            "gen_ai.tool.name": toolName,
+            "mcp.session.id": sessionId,
+        });
+    }
 }
 export function recordMcpToolError(toolName, errorType) {
     ensureInit();
@@ -73,3 +83,7 @@ export function recordMcpSessionEnd() {
     ensureInit();
     sessionActive.add(-1);
 }
+/** Reset MCP metrics state — must be called from shutdown() alongside resetMetrics(). */
+export function resetMcpMetrics() {
+    initialized = false;
+}

package/dist/mcp/middleware.d.ts

@@ -9,7 +9,11 @@
  * and strict TypeScript. Wrapping the public API is the stable path.
  */
 import type { ToadMcpOptions } from "./types.js";
-export declare function toadEyeMiddleware(server: any, options?: ToadMcpOptions): void;
+export interface ToadEyeMiddlewareDispose {
+    /** Call when the MCP server is shutting down to decrement the active session counter. */
+    (): void;
+}
+export declare function toadEyeMiddleware(server: any, options?: ToadMcpOptions): ToadEyeMiddlewareDispose;
 /**
  * Trace a sampling/createMessage call (server → client LLM request).
  *

package/dist/mcp/middleware.js

@@ -8,11 +8,11 @@
  * Why not monkey-patching: MCP SDK uses private class members (_requestHandlers)
  * and strict TypeScript. Wrapping the public API is the stable path.
  */
-import { context, diag, DiagConsoleLogger, DiagLogLevel, } from "@opentelemetry/api";
+import { context, trace, diag, DiagConsoleLogger, DiagLogLevel, } from "@opentelemetry/api";
 import { randomUUID } from "node:crypto";
 import { extractContextFromMeta } from "./context.js";
 import { startToolSpan, startResourceSpan, startPromptSpan, startSamplingSpan, endSpanSuccess, endSpanError, } from "./spans.js";
-import { recordMcpToolCall, recordMcpToolError, recordMcpResourceRead, recordMcpSessionStart, } from "./metrics.js";
+import { recordMcpToolCall, recordMcpToolError, recordMcpResourceRead, recordMcpSessionStart, recordMcpSessionEnd, } from "./metrics.js";
 const DEFAULT_MAX_PAYLOAD_SIZE = 4096;
 /** Detect MCP transport type from server internals. */
 function detectTransport(server) {
@@ -38,7 +38,15 @@ function redactObject(obj, keys) {
         return {};
     const result = {};
     for (const [k, v] of Object.entries(obj)) {
-        result[k] = keys.includes(k) ? "[REDACTED]" : v;
+        if (keys.includes(k)) {
+            result[k] = "[REDACTED]";
+        }
+        else if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+            result[k] = redactObject(v, keys);
+        }
+        else {
+            result[k] = v;
+        }
     }
     return result;
 }
@@ -137,7 +145,7 @@ server, options = {}) {
             }
             const start = performance.now();
             try {
-                const result = await context.with(context.active(), () => originalHandler(...handlerArgs));
+                const result = await context.with(trace.setSpan(parentCtx, span), () => originalHandler(...handlerArgs));
                 const durationMs = performance.now() - start;
                 // Record outputs if enabled
                 if (recordOutputs && result) {
@@ -145,14 +153,14 @@ server, options = {}) {
                     span.setAttribute("gen_ai.tool.call.result", serialized);
                 }
                 endSpanSuccess(span);
-                recordMcpToolCall(name, durationMs, "success");
+                recordMcpToolCall(name, durationMs, "success", sessionId);
                 return result;
             }
             catch (error) {
                 const durationMs = performance.now() - start;
                 const errorType = error instanceof Error ? error.constructor.name : "UnknownError";
                 endSpanError(span, error);
-                recordMcpToolCall(name, durationMs, "error");
+                recordMcpToolCall(name, durationMs, "error", sessionId);
                 recordMcpToolError(name, errorType);
                 throw error;
             }
@@ -181,7 +189,7 @@ server, options = {}) {
                     options.onResourceRead(span, uri);
                 }
                 try {
-                    const result = await originalHandler(...handlerArgs);
+                    const result = await context.with(trace.setSpan(parentCtx, span), () => originalHandler(...handlerArgs));
                     endSpanSuccess(span);
                     recordMcpResourceRead(uri);
                     return result;
@@ -212,7 +220,7 @@ server, options = {}) {
                     parentContext: parentCtx,
                 });
                 try {
-                    const result = await originalHandler(...handlerArgs);
+                    const result = await context.with(trace.setSpan(parentCtx, span), () => originalHandler(...handlerArgs));
                     endSpanSuccess(span);
                     return result;
                 }
@@ -224,6 +232,13 @@ server, options = {}) {
             return originalPrompt(name, ...rest);
         };
     }
+    let disposed = false;
+    return () => {
+        if (disposed)
+            return;
+        disposed = true;
+        recordMcpSessionEnd();
+    };
 }
 /**
  * Trace a sampling/createMessage call (server → client LLM request).

package/dist/mcp/spans.js

@@ -35,7 +35,7 @@ function baseAttrs(method, options) {
 }
 export function startToolSpan(toolName, options) {
     return tracer.startSpan(`${MCP_METHODS.TOOLS_CALL} ${toolName}`, {
-        kind: SpanKind.INTERNAL,
+        kind: SpanKind.SERVER,
         attributes: {
             ...baseAttrs(MCP_METHODS.TOOLS_CALL, options),
             "gen_ai.tool.name": toolName,
@@ -44,7 +44,7 @@ export function startToolSpan(toolName, options) {
 }
 export function startResourceSpan(uri, options) {
     return tracer.startSpan(`${MCP_METHODS.RESOURCES_READ} ${uri}`, {
-        kind: SpanKind.INTERNAL,
+        kind: SpanKind.SERVER,
         attributes: {
             ...baseAttrs(MCP_METHODS.RESOURCES_READ, options),
             "gen_ai.data_source.id": uri,
@@ -53,7 +53,7 @@ export function startResourceSpan(uri, options) {
 }
 export function startPromptSpan(promptName, options) {
     return tracer.startSpan(`${MCP_METHODS.PROMPTS_GET} ${promptName}`, {
-        kind: SpanKind.INTERNAL,
+        kind: SpanKind.SERVER,
         attributes: {
             ...baseAttrs(MCP_METHODS.PROMPTS_GET, options),
             "gen_ai.prompt.name": promptName,

package/dist/mcp/types.d.ts

@@ -1,17 +1,13 @@
 import type { Span } from "@opentelemetry/api";
 /** Configuration for toadEyeMiddleware(). */
 export interface ToadMcpOptions {
-    /** Service name for OTel resource. Defaults to MCP server name. */
-    readonly serviceName?: string | undefined;
-    /** OTLP endpoint. Uses existing OTel config if initObservability() was called. */
-    readonly endpoint?: string | undefined;
     /** Record tool call arguments in spans. Default: false (privacy). */
     readonly recordInputs?: boolean | undefined;
     /** Record tool call results in spans. Default: false (privacy). */
     readonly recordOutputs?: boolean | undefined;
-    /** Keys to redact from recorded arguments. */
+    /** Keys to redact from recorded arguments (recursive). */
     readonly redactKeys?: readonly string[] | undefined;
-    /** Max payload size in bytes before truncation. Default: 4096. */
+    /** Max payload size in characters before truncation. Default: 4096. */
     readonly maxPayloadSize?: number | undefined;
     /** Explicit session ID. Auto-generated if not provided. */
     readonly sessionId?: string | undefined;
@@ -22,18 +18,3 @@ export interface ToadMcpOptions {
     /** Hook called on each resource read span. */
     readonly onResourceRead?: ((span: Span, uri: string) => void) | undefined;
 }
-/** OTel attributes set on MCP spans. */
-export interface McpSpanAttributes {
-    readonly "gen_ai.operation.name": string;
-    readonly "mcp.method.name": string;
-    readonly "gen_ai.tool.name"?: string;
-    readonly "gen_ai.tool.call.id"?: string;
-    readonly "gen_ai.data_source.id"?: string;
-    readonly "gen_ai.prompt.name"?: string;
-    readonly "mcp.server.name": string;
-    readonly "mcp.server.version": string;
-    readonly "mcp.session.id"?: string;
-    readonly "mcp.protocol.version"?: string;
-    readonly "network.transport"?: "pipe" | "tcp";
-    readonly "rpc.response.status_code"?: number;
-}

package/dist/types/metrics.d.ts

@@ -31,6 +31,7 @@ export declare const GEN_AI_METRICS: {
     readonly MCP_TOOL_ERRORS: "gen_ai.mcp.tool.errors";
     readonly MCP_RESOURCE_READS: "gen_ai.mcp.resource.reads";
     readonly MCP_SESSION_ACTIVE: "gen_ai.mcp.session.active";
+    readonly MCP_TOOL_CALLERS: "gen_ai.mcp.tool.callers";
 };
 /** @deprecated Use GEN_AI_METRICS instead. Kept for backward compatibility. */
 export declare const LLM_METRICS: {

package/dist/types/metrics.js

@@ -39,6 +39,7 @@ export const GEN_AI_METRICS = {
     MCP_TOOL_ERRORS: "gen_ai.mcp.tool.errors",
     MCP_RESOURCE_READS: "gen_ai.mcp.resource.reads",
     MCP_SESSION_ACTIVE: "gen_ai.mcp.session.active",
+    MCP_TOOL_CALLERS: "gen_ai.mcp.tool.callers",
 };
 /** @deprecated Use GEN_AI_METRICS instead. Kept for backward compatibility. */
 export const LLM_METRICS = {

package/dist/types/providers.d.ts

@@ -6,5 +6,7 @@ export type LLMProvider = "anthropic" | "gemini" | "openai" | (string & {});
 /**
  * All instrumentable targets — includes LLM providers + framework SDKs.
  * 'ai' = Vercel AI SDK (uses SpanProcessor, not monkey-patching).
+ * 'mcp' = MCP SDK McpServer (patches prototype for auto-instrumentation).
+ * 'mcp-client' = MCP SDK Client (patches callTool/readResource/getPrompt for distributed tracing).
  */
-export type InstrumentTarget = LLMProvider | "ai";
+export type InstrumentTarget = LLMProvider | "ai" | "mcp" | "mcp-client";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toad-eye",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "description": "Observability for MCP servers and LLM applications — traces, metrics, dashboards. One-line instrumentation for OpenAI, Anthropic, Gemini, and MCP. Self-hosted with Grafana + Prometheus + Jaeger.",
   "type": "module",
   "main": "dist/index.js",

package/templates/alerts.example.yml

@@ -52,3 +52,24 @@ alerts:
     condition: ratio_5m > 0.2
     channels: [slack]
     cooldown: 15
+
+  # --- MCP Server alerts ---
+
+  # MCP tool error rate: >10% over 5 minutes
+  - name: mcp_tool_error_rate
+    metric: gen_ai.mcp.tool.errors
+    condition: ratio_5m > 0.1
+    channels: [slack]
+
+  # MCP tool latency spike: avg > 2 seconds over 5 minutes
+  - name: mcp_tool_latency
+    metric: gen_ai.mcp.tool.duration
+    condition: avg_5m > 2000
+    channels: [slack]
+
+  # MCP tool call spike: >100 calls in 5 minutes
+  - name: mcp_tool_call_spike
+    metric: gen_ai.mcp.tool.calls
+    condition: sum_5m > 100
+    channels: [slack]
+    cooldown: 15