toad-eye 2.5.0 → 2.6.1

package/README.md

@@ -124,6 +124,39 @@ const result = await traceLLMCall(
 
 </details>
 
+<details>
+<summary>MCP Server observability</summary>
+
+Drop-in middleware for MCP servers — one line for full tracing of every tool call, resource read, and prompt request.
+
+```typescript
+import { McpServer } from "@modelcontextprotocol/sdk/server/index.js";
+import { toadEyeMiddleware } from "toad-eye/mcp";
+
+const server = new McpServer({ name: "my-server", version: "1.0.0" });
+toadEyeMiddleware(server);
+
+// All handlers are now instrumented — spans appear in Jaeger
+server.tool("calculate", { expression: z.string() }, async ({ expression }) => {
+  return { content: [{ type: "text", text: String(eval(expression)) }] };
+});
+```
+
+Spans follow OTel GenAI semconv: `execute_tool calculate`, `retrieval file:///docs`, `prompt greeting`.
+
+Privacy by default — tool arguments and results are NOT recorded unless you opt in:
+
+```typescript
+toadEyeMiddleware(server, {
+  recordInputs: true,
+  redactKeys: ["apiKey", "token"],
+});
+```
+
+> Safe for stdio transport — OTel diagnostics are redirected to stderr.
+
+</details>
+
 ## Budget guards
 
 Prevent cost overruns at runtime. Three modes: warn, block, or auto-downgrade to a cheaper model.

package/dist/cli.js

@@ -207,7 +207,14 @@ async function exportTraceCommand() {
             i++;
         }
         else if (args[i] === "--jaeger-url" && args[i + 1]) {
-            jaegerUrl = args[i + 1];
+            try {
+                new URL(args[i + 1]);
+                jaegerUrl = args[i + 1];
+            }
+            catch {
+                console.error(`❌ Invalid --jaeger-url: ${args[i + 1]}`);
+                process.exit(1);
+            }
             i++;
         }
     }

package/dist/context/index.d.ts

@@ -1,2 +1 @@
-export { ToadContextExceededError } from "./error.js";
-export { checkContextGuard, resetContextGuardState } from "./guard.js";
+export {};

package/dist/context/index.js

@@ -1,2 +1,4 @@
-export { ToadContextExceededError } from "./error.js";
-export { checkContextGuard, resetContextGuardState } from "./guard.js";
+export {};
+// Context module — post-call utilization monitoring only.
+// Pre-call blocking was removed (see #198) — API providers handle
+// context overflow natively, and pre-call token estimation is unreliable.

package/dist/core/metrics.js

@@ -92,6 +92,10 @@ export function initMetrics() {
 export function resetMetrics() {
     initialized = false;
 }
+/** Returns true if metrics are safe to record. Prevents crash if called before initMetrics(). */
+function isReady() {
+    return initialized;
+}
 /** Build metric labels: provider + model + optional FinOps attributes. */
 function baseLabels(provider, model, attrs) {
     return {
@@ -101,78 +105,116 @@ function baseLabels(provider, model, attrs) {
     };
 }
 export function recordRequestDuration(ms, provider, model, attrs) {
+    if (!isReady())
+        return;
     requestDuration.record(ms, baseLabels(provider, model, attrs));
 }
 export function recordRequestCost(usd, provider, model, attrs) {
+    if (!isReady())
+        return;
     requestCost.record(usd, baseLabels(provider, model, attrs));
 }
 export function recordTokens(count, provider, model, attrs) {
+    if (!isReady())
+        return;
     tokenUsage.add(count, baseLabels(provider, model, attrs));
 }
 export function recordRequest(provider, model, attrs) {
+    if (!isReady())
+        return;
     requestsTotal.add(1, baseLabels(provider, model, attrs));
 }
 export function recordError(provider, model, attrs) {
+    if (!isReady())
+        return;
     errorsTotal.add(1, baseLabels(provider, model, attrs));
 }
 export function recordAgentSteps(stepCount) {
+    if (!isReady())
+        return;
     agentStepsPerQuery.record(stepCount);
 }
 export function recordAgentToolUsage(toolName, status = "success") {
+    if (!isReady())
+        return;
     agentToolUsage.add(1, {
         [GEN_AI_ATTRS.TOOL_NAME]: toolName,
         "tool.status": status,
     });
 }
 export function recordAgentToolDuration(toolName, durationMs) {
+    if (!isReady())
+        return;
     agentToolDuration.record(durationMs, {
         [GEN_AI_ATTRS.TOOL_NAME]: toolName,
     });
 }
 export function recordGuardEvaluation(ruleName) {
+    if (!isReady())
+        return;
     guardEvaluations.add(1, {
         [GEN_AI_ATTRS.GUARD_RULE_NAME]: ruleName,
     });
 }
 export function recordGuardWouldBlock(ruleName) {
+    if (!isReady())
+        return;
     guardWouldBlock.add(1, {
         [GEN_AI_ATTRS.GUARD_RULE_NAME]: ruleName,
     });
 }
 export function recordSemanticDrift(drift, provider, model) {
+    if (!isReady())
+        return;
     semanticDrift.record(drift, {
         [GEN_AI_ATTRS.PROVIDER]: provider,
         [GEN_AI_ATTRS.REQUEST_MODEL]: model,
     });
 }
 export function recordTimeToFirstToken(ms, provider, model) {
+    if (!isReady())
+        return;
     timeToFirstToken.record(ms, {
         [GEN_AI_ATTRS.PROVIDER]: provider,
         [GEN_AI_ATTRS.REQUEST_MODEL]: model,
     });
 }
 export function recordBudgetExceeded(budgetType) {
+    if (!isReady())
+        return;
     budgetExceeded.add(1, { budget_type: budgetType });
 }
 export function recordBudgetBlocked(budgetType) {
+    if (!isReady())
+        return;
     budgetBlocked.add(1, { budget_type: budgetType });
 }
 export function recordBudgetDowngraded(budgetType) {
+    if (!isReady())
+        return;
     budgetDowngraded.add(1, { budget_type: budgetType });
 }
 export function recordResponseEmpty(provider, model, attrs) {
+    if (!isReady())
+        return;
     responseEmpty.add(1, baseLabels(provider, model, attrs));
 }
 export function recordResponseLatencyPerToken(msPerToken, provider, model, attrs) {
+    if (!isReady())
+        return;
     responseLatencyPerToken.record(msPerToken, baseLabels(provider, model, attrs));
 }
 export function recordContextUtilization(utilization, provider, model) {
+    if (!isReady())
+        return;
     contextUtilization.record(utilization, {
         [GEN_AI_ATTRS.PROVIDER]: provider,
         [GEN_AI_ATTRS.REQUEST_MODEL]: model,
     });
 }
 export function recordContextBlocked(model) {
+    if (!isReady())
+        return;
     contextBlocked.add(1, {
         [GEN_AI_ATTRS.REQUEST_MODEL]: model,
     });

package/dist/core/pricing.js

@@ -60,6 +60,7 @@ const BUILT_IN_PRICING = {
     },
 };
 let customPricing = {};
+const warnedModels = new Set();
 /**
  * Set custom pricing for models (overrides built-in prices).
  * Useful for enterprise contracts or custom/fine-tuned models.
@@ -70,6 +71,7 @@ export function setCustomPricing(pricing) {
 /** Reset custom pricing to empty. Called from shutdown() to avoid stale state across re-inits. */
 export function resetCustomPricing() {
     customPricing = {};
+    warnedModels.clear();
 }
 /**
  * Get pricing for a model. Custom pricing takes precedence.
@@ -86,8 +88,15 @@ export function calculateCost(model, inputTokens, outputTokens) {
     if (inputTokens < 0 || outputTokens < 0)
         return 0;
     const pricing = getModelPricing(model);
-    if (!pricing)
+    if (!pricing) {
+        if (inputTokens + outputTokens > 0 && !warnedModels.has(model)) {
+            if (warnedModels.size >= 100)
+                warnedModels.clear();
+            warnedModels.add(model);
+            console.warn(`toad-eye: unknown pricing for "${model}" — cost reported as $0. Use setCustomPricing() to set rates.`);
+        }
         return 0;
+    }
     const cost = (inputTokens / 1_000_000) * pricing.inputPer1M +
         (outputTokens / 1_000_000) * pricing.outputPer1M;
     return Math.round(cost * 1_000_000) / 1_000_000;

package/dist/core/spans.d.ts

@@ -5,6 +5,8 @@ export interface LLMCallInput {
     readonly model: string;
     readonly prompt: string;
     readonly temperature?: number | undefined;
+    /** OTel operation name for span naming. Default: "chat". */
+    readonly operationName?: string | undefined;
     /** Per-request FinOps attributes (team, userId, feature, etc). Merged with global attributes. */
     readonly attributes?: Readonly<Record<string, string>> | undefined;
 }

package/dist/core/spans.js

@@ -46,6 +46,11 @@ export function processContent(text) {
     const config = getConfig();
     if (config?.recordContent === false)
         return undefined;
+    // Content sampling — record only a fraction of calls
+    if (config?.contentSamplingRate !== undefined) {
+        if (Math.random() >= config.contentSamplingRate)
+            return undefined;
+    }
     let processed = text;
     let totalRedacted = 0;
     // Apply default PII patterns if enabled
@@ -59,9 +64,14 @@ export function processContent(text) {
     // Apply custom patterns
     if (config?.redactPatterns?.length) {
         for (const pattern of config.redactPatterns) {
-            const [result, count] = applyRedaction(processed, pattern);
-            processed = result;
-            totalRedacted += count;
+            try {
+                const [result, count] = applyRedaction(processed, pattern);
+                processed = result;
+                totalRedacted += count;
+            }
+            catch {
+                console.warn(`toad-eye: invalid redact pattern skipped: ${pattern.source}`);
+            }
         }
     }
     // Audit mode — log a summary only, never the original content (would re-expose PII)
@@ -93,7 +103,7 @@ function setBaseAttributes(span, input) {
         [GEN_AI_ATTRS.PROVIDER]: input.provider,
         [GEN_AI_ATTRS.REQUEST_MODEL]: input.model,
         [GEN_AI_ATTRS.TEMPERATURE]: input.temperature ?? 1.0,
-        [GEN_AI_ATTRS.OPERATION]: "chat",
+        [GEN_AI_ATTRS.OPERATION]: input.operationName ?? "chat",
         ...(prompt !== undefined && { [GEN_AI_ATTRS.PROMPT]: prompt }),
         ...(sessionId !== undefined && { [GEN_AI_ATTRS.SESSION_ID]: sessionId }),
         ...attrs,
@@ -153,7 +163,8 @@ export async function traceLLMCall(input, fn) {
             recordBudgetDowngraded(override.budget);
         }
     }
-    return tracer.startActiveSpan(`chat ${effectiveInput.model}`, async (span) => {
+    const op = effectiveInput.operationName ?? "chat";
+    return tracer.startActiveSpan(`${op} ${effectiveInput.model}`, async (span) => {
         const start = performance.now();
         setBaseAttributes(span, effectiveInput);
         try {
@@ -184,13 +195,13 @@ export async function traceLLMCall(input, fn) {
                 // can compress context before the NEXT call.
                 const guard = getConfig()?.contextGuard;
                 if (guard) {
-                    if (guard.blockAt !== undefined && utilization >= guard.blockAt) {
+                    if (guard.alertAt !== undefined && utilization >= guard.alertAt) {
                         recordContextBlocked(effectiveInput.model);
                         span.addEvent("gen_ai.context.limit_exceeded", {
                             "gen_ai.toad_eye.context_utilization": utilization,
-                            "gen_ai.toad_eye.context.threshold": guard.blockAt,
+                            "gen_ai.toad_eye.context.threshold": guard.alertAt,
                         });
-                        console.warn(`toad-eye: context window ${(utilization * 100).toFixed(0)}% full for ${effectiveInput.model} — exceeds blockAt threshold ${(guard.blockAt * 100).toFixed(0)}%. Compress context before next call.`);
+                        console.warn(`toad-eye: context window ${(utilization * 100).toFixed(0)}% full for ${effectiveInput.model} — exceeds alertAt threshold ${(guard.alertAt * 100).toFixed(0)}%. Compress context before next call.`);
                     }
                     else if (guard.warnAt !== undefined &&
                         utilization >= guard.warnAt) {
@@ -215,15 +226,18 @@ export async function traceLLMCall(input, fn) {
             const attrs = resolveAttributes(effectiveInput);
             setErrorAttributes(span, message);
             recordBaseMetrics(duration, effectiveInput.provider, effectiveInput.model, attrs);
-            recordError(effectiveInput.provider, effectiveInput.model, attrs);
             // Release cost reservation on any error (no cost was incurred)
             if (budget) {
                 budget.releaseReservation(estimatedCost);
             }
-            // If this was a budget block, record the metric with the correct budget type
             if (error instanceof ToadBudgetExceededError) {
+                // Budget blocks are intentional guardrails, not errors — record
+                // only the budget-specific metric to avoid inflating error rate
                 recordBudgetBlocked(error.budget);
             }
+            else {
+                recordError(effectiveInput.provider, effectiveInput.model, attrs);
+            }
             throw error;
         }
         finally {

package/dist/core/tracer.js

@@ -7,7 +7,6 @@ import { TraceIdRatioBasedSampler, ParentBasedSampler, BatchSpanProcessor, } fro
 import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
 import { initMetrics, resetMetrics } from "./metrics.js";
 import { resetCustomPricing } from "./pricing.js";
-import { resetContextGuardState } from "../context/guard.js";
 import { enableAll, disableAll } from "../instrumentations/registry.js";
 import { BudgetTracker } from "../budget/index.js";
 import { ToadEyeAISpanProcessor } from "../vercel.js";
@@ -41,6 +40,10 @@ function validateConfig(config) {
     if (config.apiKey !== undefined && !config.apiKey.startsWith("toad_")) {
         throw new Error('toad-eye: apiKey must start with "toad_" prefix');
     }
+    if (config.onBudgetExceeded === "downgrade" &&
+        config.downgradeCallback === undefined) {
+        throw new Error('toad-eye: downgradeCallback is required when onBudgetExceeded is "downgrade"');
+    }
 }
 /** Resolve endpoint and auth headers based on config mode (self-hosted vs cloud). */
 function resolveTransport(config) {
@@ -124,7 +127,9 @@ export function initObservability(config) {
         if (patchProviders.length > 0) {
             // enableAll is async (lazy-loads provider modules on first call).
             // Fire-and-forget: patching completes before any async SDK call.
-            void enableAll(patchProviders);
+            void enableAll(patchProviders).catch((err) => {
+                console.warn(`toad-eye: auto-instrumentation failed: ${err instanceof Error ? err.message : err}`);
+            });
         }
     }
 }
@@ -138,5 +143,4 @@ export async function shutdown() {
     budgetTracker = null;
     resetMetrics();
     resetCustomPricing();
-    resetContextGuardState();
 }

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 export { initObservability, shutdown, getConfig, getBudgetTracker, } from "./core/tracer.js";
 export { BudgetTracker, ToadBudgetExceededError } from "./budget/index.js";
-export { ToadContextExceededError } from "./context/index.js";
 export type { BudgetConfig, BudgetExceededMode, BudgetExceededInfo, DowngradeCallback, } from "./budget/index.js";
 export { AlertManager, startAlertsFromFile, parseCondition, } from "./alerts/index.js";
 export type { AlertsConfig, AlertRule, AlertChannelConfig, FiredAlert, } from "./alerts/index.js";

package/dist/index.js

@@ -1,6 +1,5 @@
 export { initObservability, shutdown, getConfig, getBudgetTracker, } from "./core/tracer.js";
 export { BudgetTracker, ToadBudgetExceededError } from "./budget/index.js";
-export { ToadContextExceededError } from "./context/index.js";
 export { AlertManager, startAlertsFromFile, parseCondition, } from "./alerts/index.js";
 export { traceLLMCall } from "./core/spans.js";
 export { traceAgentStep, traceAgentQuery } from "./agent.js";

package/dist/instrumentations/create.js

@@ -94,7 +94,8 @@ original, patch, providerName) {
                 recordBudgetDowngraded(override.budget);
             }
         }
-        const span = tracer.startSpan(`chat ${effectiveModel}`);
+        const op = patch.operationName ?? "chat";
+        const span = tracer.startSpan(`${op} ${effectiveModel}`);
         const ctx = trace.setSpan(context.active(), span);
         const sessionId = config?.sessionExtractor?.() ?? config?.sessionId;
         let ttftMs = 0;
@@ -102,7 +103,7 @@ original, patch, providerName) {
             [GEN_AI_ATTRS.PROVIDER]: effectiveProvider,
             [GEN_AI_ATTRS.REQUEST_MODEL]: effectiveModel,
             [GEN_AI_ATTRS.TEMPERATURE]: req.temperature ?? 1.0,
-            [GEN_AI_ATTRS.OPERATION]: "chat",
+            [GEN_AI_ATTRS.OPERATION]: op,
             ...(sessionId !== undefined && { [GEN_AI_ATTRS.SESSION_ID]: sessionId }),
         });
         let response;
@@ -167,10 +168,18 @@ original, patch, providerName) {
                 [GEN_AI_ATTRS.INPUT_TOKENS]: acc.inputTokens,
                 [GEN_AI_ATTRS.OUTPUT_TOKENS]: acc.outputTokens,
                 [GEN_AI_ATTRS.COST]: cost,
-                [GEN_AI_ATTRS.STATUS]: "success",
-                [GEN_AI_ATTRS.FINISH_REASONS]: ["stop"],
+                [GEN_AI_ATTRS.STATUS]: acc.finishReason === "SAFETY" ? "error" : "success",
+                [GEN_AI_ATTRS.FINISH_REASONS]: [acc.finishReason ?? "stop"],
             });
-            span.setStatus({ code: SpanStatusCode.OK });
+            if (acc.finishReason === "SAFETY") {
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: "Content blocked by safety filter",
+                });
+            }
+            else {
+                span.setStatus({ code: SpanStatusCode.OK });
+            }
             span.end();
             recordRequest(effectiveProvider, effectiveModel);
             recordRequestDuration(duration, effectiveProvider, effectiveModel);
@@ -192,13 +201,13 @@ original, patch, providerName) {
                 // Context guard — post-stream warning
                 const guard = config?.contextGuard;
                 if (guard) {
-                    if (guard.blockAt !== undefined && utilization >= guard.blockAt) {
+                    if (guard.alertAt !== undefined && utilization >= guard.alertAt) {
                         recordContextBlocked(effectiveModel);
                         span.addEvent("gen_ai.context.limit_exceeded", {
                             "gen_ai.toad_eye.context_utilization": utilization,
-                            "gen_ai.toad_eye.context.threshold": guard.blockAt,
+                            "gen_ai.toad_eye.context.threshold": guard.alertAt,
                         });
-                        console.warn(`toad-eye: context window ${(utilization * 100).toFixed(0)}% full for ${effectiveModel} — exceeds blockAt threshold ${(guard.blockAt * 100).toFixed(0)}%. Compress context before next call.`);
+                        console.warn(`toad-eye: context window ${(utilization * 100).toFixed(0)}% full for ${effectiveModel} — exceeds alertAt threshold ${(guard.alertAt * 100).toFixed(0)}%. Compress context before next call.`);
                     }
                     else if (guard.warnAt !== undefined &&
                         utilization >= guard.warnAt) {
@@ -269,6 +278,7 @@ original, patch, providerName) {
             model: req.model,
             prompt: req.prompt,
             temperature: req.temperature,
+            operationName: patch.operationName,
         }, async () => {
             const response = await original.call(this, body, ...rest);
             const res = patch.extractResponse(response, req.model);
@@ -301,6 +311,11 @@ export function createInstrumentation(config) {
                 return activePatches.length > 0;
             }
             catch (err) {
+                // Clean up any patches applied before the failure
+                for (const { proto, method, original } of activePatches) {
+                    proto[method] = original;
+                }
+                activePatches.length = 0;
                 diag.warn(`toad-eye: failed to patch ${config.name}: ${err}`);
                 return false;
             }

package/dist/instrumentations/gemini.js

@@ -17,6 +17,7 @@ function extractPrompt(request) {
 const generateContent = {
     getPrototype: (sdk) => sdk?.GenerativeModel?.prototype,
     method: "generateContent",
+    operationName: "chat",
     extractRequest(body, thisArg) {
         return {
             prompt: extractPrompt(body),
@@ -42,6 +43,7 @@ const generateContent = {
 const generateContentStream = {
     getPrototype: (sdk) => sdk?.GenerativeModel?.prototype,
     method: "generateContentStream",
+    operationName: "chat",
     extractRequest(body, thisArg) {
         return {
             prompt: extractPrompt(body),
@@ -78,6 +80,11 @@ const generateContentStream = {
                 }
             }
         }
+        // Track finish reason (especially SAFETY blocks)
+        const finishReason = c?.candidates?.[0]?.finishReason;
+        if (finishReason) {
+            acc.finishReason = finishReason;
+        }
         if (c?.usageMetadata) {
             acc.inputTokens = c.usageMetadata.promptTokenCount ?? acc.inputTokens;
             acc.outputTokens =

package/dist/instrumentations/openai.js

@@ -59,6 +59,10 @@ const chatCompletions = {
                         existing.arguments += tc.function.arguments;
                 }
                 else {
+                    // Fill gaps to avoid sparse array with non-contiguous indices
+                    while (acc.toolCalls.length < tc.index) {
+                        acc.toolCalls.push({ name: "", arguments: "" });
+                    }
                     acc.toolCalls[tc.index] = {
                         name: tc.function?.name ?? "",
                         arguments: tc.function?.arguments ?? "",
@@ -76,6 +80,7 @@ const chatCompletions = {
 const embeddings = {
     getPrototype: (sdk) => sdk?.Embeddings?.prototype,
     method: "create",
+    operationName: "embeddings",
     extractRequest: (body) => {
         const b = body;
         const input = b?.input;

package/dist/instrumentations/types.d.ts

@@ -20,13 +20,19 @@ export interface StreamAccumulator {
     inputTokens: number;
     outputTokens: number;
     toolCalls: AccumulatedToolCall[];
+    /** Finish reason from the final chunk (e.g., "stop", "SAFETY"). */
+    finishReason?: string | undefined;
 }
+/** OTel GenAI operation types. Default is "chat". */
+export type OperationName = "chat" | "text_completion" | "embeddings" | "generate_content";
 /** Describes a single method to monkey-patch on an SDK prototype. */
 export interface PatchTarget {
     /** How to find the prototype from the loaded SDK module */
     getPrototype: (sdk: any) => any | undefined;
     /** Method name on the prototype to patch */
     method: string;
+    /** OTel operation name for span naming. Default: "chat". */
+    operationName?: OperationName | undefined;
     /** Extract LLMCallInput fields from the request arguments.
      *  thisArg is the SDK object instance — use it when the model name is not in the request body
      *  (e.g., Gemini's GenerativeModel stores it as this.model). */

package/dist/mcp/context.d.ts

@@ -0,0 +1,12 @@
+/**
+ * W3C trace context extraction from MCP _meta field.
+ *
+ * In stdio transport, there are no HTTP headers. Context is passed
+ * via the _meta field in JSON-RPC params:
+ * { "params": { "_meta": { "traceparent": "00-..." } } }
+ *
+ * For SSE/HTTP transports, standard header propagation works too,
+ * but _meta is the universal path that works everywhere.
+ */
+import { type Context } from "@opentelemetry/api";
+export declare function extractContextFromMeta(meta?: Record<string, unknown>): Context;

package/dist/mcp/context.js

@@ -0,0 +1,22 @@
+/**
+ * W3C trace context extraction from MCP _meta field.
+ *
+ * In stdio transport, there are no HTTP headers. Context is passed
+ * via the _meta field in JSON-RPC params:
+ * { "params": { "_meta": { "traceparent": "00-..." } } }
+ *
+ * For SSE/HTTP transports, standard header propagation works too,
+ * but _meta is the universal path that works everywhere.
+ */
+import { context, propagation } from "@opentelemetry/api";
+export function extractContextFromMeta(meta) {
+    if (!meta?.["traceparent"])
+        return context.active();
+    const carrier = {
+        traceparent: String(meta["traceparent"]),
+    };
+    if (meta["tracestate"]) {
+        carrier["tracestate"] = String(meta["tracestate"]);
+    }
+    return propagation.extract(context.active(), carrier);
+}

package/dist/mcp/index.d.ts

@@ -0,0 +1,3 @@
+export { toadEyeMiddleware, traceSampling } from "./middleware.js";
+export type { TraceSamplingOptions } from "./middleware.js";
+export type { ToadMcpOptions, McpSpanAttributes } from "./types.js";

package/dist/mcp/index.js

@@ -0,0 +1 @@
+export { toadEyeMiddleware, traceSampling } from "./middleware.js";

package/dist/mcp/metrics.d.ts

@@ -0,0 +1,11 @@
+/**
+ * MCP-specific OTel metrics.
+ *
+ * Separate from core metrics (core/metrics.ts) — these only exist
+ * when MCP middleware is active. Initialized on first middleware call.
+ */
+export declare function recordMcpToolCall(toolName: string, durationMs: number, status: "success" | "error"): 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;

package/dist/mcp/metrics.js

@@ -0,0 +1,58 @@
+/**
+ * MCP-specific OTel metrics.
+ *
+ * Separate from core metrics (core/metrics.ts) — these only exist
+ * when MCP middleware is active. Initialized on first middleware call.
+ */
+import { metrics, } from "@opentelemetry/api";
+import { GEN_AI_METRICS } from "../types/metrics.js";
+const METER_NAME = "toad-eye-mcp";
+let toolDuration;
+let toolCalls;
+let toolErrors;
+let resourceReads;
+let sessionActive;
+let initialized = false;
+function ensureInit() {
+    if (initialized)
+        return;
+    initialized = true;
+    const meter = metrics.getMeter(METER_NAME);
+    toolDuration = meter.createHistogram(GEN_AI_METRICS.MCP_TOOL_DURATION, {
+        description: "MCP tool execution duration",
+        unit: "ms",
+    });
+    toolCalls = meter.createCounter(GEN_AI_METRICS.MCP_TOOL_CALLS, {
+        description: "MCP tool call count by tool name and status",
+    });
+    toolErrors = meter.createCounter(GEN_AI_METRICS.MCP_TOOL_ERRORS, {
+        description: "MCP tool errors by tool name and error type",
+    });
+    resourceReads = meter.createCounter(GEN_AI_METRICS.MCP_RESOURCE_READS, {
+        description: "MCP resource read count by URI",
+    });
+    sessionActive = meter.createUpDownCounter(GEN_AI_METRICS.MCP_SESSION_ACTIVE, {
+        description: "Number of active MCP sessions",
+    });
+}
+export function recordMcpToolCall(toolName, durationMs, status) {
+    ensureInit();
+    toolCalls.add(1, { "gen_ai.tool.name": toolName, status });
+    toolDuration.record(durationMs, { "gen_ai.tool.name": toolName });
+}
+export function recordMcpToolError(toolName, errorType) {
+    ensureInit();
+    toolErrors.add(1, { "gen_ai.tool.name": toolName, "error.type": errorType });
+}
+export function recordMcpResourceRead(uri) {
+    ensureInit();
+    resourceReads.add(1, { "gen_ai.data_source.id": uri });
+}
+export function recordMcpSessionStart() {
+    ensureInit();
+    sessionActive.add(1);
+}
+export function recordMcpSessionEnd() {
+    ensureInit();
+    sessionActive.add(-1);
+}