toad-eye 2.7.0 → 2.9.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/span-end-processor.d.ts

@@ -0,0 +1,30 @@
+/**
+ * SpanProcessor that calls user's onSpanEnd callback with structured span data.
+ *
+ * Extracts LLM/MCP-relevant attributes from ReadableSpan into a clean
+ * SpanEndData object — user never touches OTel SDK internals.
+ */
+import type { SpanProcessor, ReadableSpan } from "@opentelemetry/sdk-trace-base";
+/** Structured span data passed to the onSpanEnd callback. */
+export interface SpanEndData {
+    readonly traceId: string;
+    readonly spanId: string;
+    readonly parentSpanId: string | undefined;
+    readonly name: string;
+    readonly kind: "client" | "server" | "internal" | "producer" | "consumer";
+    readonly status: "ok" | "error" | "unset";
+    readonly durationMs: number;
+    readonly startTime: Date;
+    readonly endTime: Date;
+    readonly attributes: Readonly<Record<string, string | number | boolean>>;
+    readonly error: string | undefined;
+}
+export type OnSpanEndCallback = (data: SpanEndData) => void | Promise<void>;
+export declare class ToadEyeSpanEndProcessor implements SpanProcessor {
+    private readonly callback;
+    constructor(callback: OnSpanEndCallback);
+    onStart(): void;
+    onEnd(span: ReadableSpan): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}

package/dist/core/span-end-processor.js

@@ -0,0 +1,78 @@
+/**
+ * SpanProcessor that calls user's onSpanEnd callback with structured span data.
+ *
+ * Extracts LLM/MCP-relevant attributes from ReadableSpan into a clean
+ * SpanEndData object — user never touches OTel SDK internals.
+ */
+import { SpanKind, SpanStatusCode } from "@opentelemetry/api";
+const SPAN_KIND_MAP = {
+    [SpanKind.CLIENT]: "client",
+    [SpanKind.SERVER]: "server",
+    [SpanKind.INTERNAL]: "internal",
+    [SpanKind.PRODUCER]: "producer",
+    [SpanKind.CONSUMER]: "consumer",
+};
+function hrtimeToDate(hrtime) {
+    return new Date(hrtime[0] * 1000 + hrtime[1] / 1_000_000);
+}
+function hrtimeDurationMs(start, end) {
+    return (end[0] - start[0]) * 1000 + (end[1] - start[1]) / 1_000_000;
+}
+function flattenAttributes(attrs) {
+    const result = {};
+    for (const [key, value] of Object.entries(attrs)) {
+        if (typeof value === "string" ||
+            typeof value === "number" ||
+            typeof value === "boolean") {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function toSpanEndData(span) {
+    const ctx = span.spanContext();
+    return {
+        traceId: ctx.traceId,
+        spanId: ctx.spanId,
+        parentSpanId: span.parentSpanId || undefined,
+        name: span.name,
+        kind: SPAN_KIND_MAP[span.kind] ?? "internal",
+        status: span.status.code === SpanStatusCode.ERROR
+            ? "error"
+            : span.status.code === SpanStatusCode.OK
+                ? "ok"
+                : "unset",
+        durationMs: hrtimeDurationMs(span.startTime, span.endTime),
+        startTime: hrtimeToDate(span.startTime),
+        endTime: hrtimeToDate(span.endTime),
+        attributes: flattenAttributes(span.attributes),
+        error: span.status.message || undefined,
+    };
+}
+export class ToadEyeSpanEndProcessor {
+    callback;
+    constructor(callback) {
+        this.callback = callback;
+    }
+    onStart() { }
+    onEnd(span) {
+        try {
+            const result = this.callback(toSpanEndData(span));
+            // If callback returns a promise, don't block — fire and forget
+            if (result instanceof Promise) {
+                result.catch((err) => {
+                    console.warn(`toad-eye: onSpanEnd callback failed: ${err instanceof Error ? err.message : err}`);
+                });
+            }
+        }
+        catch (err) {
+            console.warn(`toad-eye: onSpanEnd callback failed: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    forceFlush() {
+        return Promise.resolve();
+    }
+    shutdown() {
+        return Promise.resolve();
+    }
+}

package/dist/core/tracer.js

@@ -8,8 +8,12 @@ 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";
+import { ToadEyeSpanEndProcessor } from "./span-end-processor.js";
 const DEFAULT_ENDPOINT = "http://localhost:4318";
 const DEFAULT_CLOUD_ENDPOINT = "https://cloud.toad-eye.dev";
 let sdk = null;
@@ -78,11 +82,20 @@ export function initObservability(config) {
         exporter: metricExporter,
         exportIntervalMillis: isCloudMode ? 10_000 : 5_000,
     });
-    // When custom SpanProcessors are needed (e.g., Vercel AI SDK),
+    // When custom SpanProcessors are needed (e.g., Vercel AI SDK, onSpanEnd),
     // we must also include a BatchSpanProcessor for trace export —
     // NodeSDK won't create one automatically when spanProcessors is provided.
-    const spanProcessors = config.instrument?.includes("ai")
-        ? [new BatchSpanProcessor(traceExporter), new ToadEyeAISpanProcessor()]
+    const needsCustomProcessors = config.instrument?.includes("ai") || config.onSpanEnd !== undefined;
+    const spanProcessors = needsCustomProcessors
+        ? [
+            new BatchSpanProcessor(traceExporter),
+            ...(config.instrument?.includes("ai")
+                ? [new ToadEyeAISpanProcessor()]
+                : []),
+            ...(config.onSpanEnd !== undefined
+                ? [new ToadEyeSpanEndProcessor(config.onSpanEnd)]
+                : []),
+        ]
         : [];
     // SDK-side head sampling (default: 1.0 = send everything to Collector)
     const sdkRate = config.sampling?.sdkRate ?? 1.0;
@@ -122,8 +135,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 +164,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/index.d.ts

@@ -20,3 +20,4 @@ export { LLM_METRICS } from "./types/index.js";
 /** @deprecated Use GEN_AI_ATTRS instead */
 export { LLM_ATTRS } from "./types/index.js";
 export { ToadEyeAISpanProcessor, withToadEye } from "./vercel.js";
+export type { SpanEndData, OnSpanEndCallback, } from "./core/span-end-processor.js";

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,