@posthog/mcp 0.10.4 → 0.10.6

package/dist/extensions/instrument-highlevel.mjs

@@ -2,41 +2,40 @@ import { analyticsOwnsParameter, getAnalyticsParameterOwnership, stripOwnedAnaly
 import { isContextEnabled } from "./context-parameters.mjs";
 import { MCPAnalyticsEventType } from "./event-types.mjs";
 import { getServerTrackingData } from "./internal.mjs";
-import { log } from "./logger.mjs";
 import { createWrappedTool, getToolFunction, hasToolFunction } from "./mcp-sdk-compat.mjs";
 import { handleReportMissing, resolveMissingCapabilityToolName } from "./tools.mjs";
-import { captureToolCall, handleInitializeRequest, handleListToolsRequest, patchRequestHandlers, readToolMetaCategory } from "./instrumentation.mjs";
+import { captureToolCall, handleInitializeRequest, handleListToolsRequest, isToolAdvertised, patchRequestHandlers, readToolMetaCategory } from "./instrumentation.mjs";
 import { getContextArgument } from "./tracing-helpers.mjs";
 const wrappedCallbacks = new WeakMap();
 const MCP_ANALYTICS_PROCESSED = Symbol('__posthog_mcp_analytics_processed__');
 function isCallbackUpdate(value) {
     return !!value && 'object' == typeof value && 'callback' in value && 'function' == typeof value.callback;
 }
-function addTracingToToolRegistry(tools, server) {
+function addTracingToToolRegistry(tools, server, logger) {
     return Object.fromEntries(Object.entries(tools).map(([name, tool])=>[
             name,
-            addTracingToToolCallbackInternal(tool, name, server)
+            addTracingToToolCallbackInternal(tool, name, server, ()=>tool.inputSchema, logger)
         ]));
 }
-function setupListenerToRegisteredTools(server) {
+function setupListenerToRegisteredTools(server, logger) {
     try {
         const data = getServerTrackingData(server.server);
-        if (!data) return void log('Warning: Cannot setup listener - no tracking data found');
+        if (!data) return void logger('Warning: Cannot setup listener - no tracking data found');
         const handler = {
             set (target, property, value) {
                 try {
                     if ('string' == typeof property && value && 'object' == typeof value && hasToolFunction(value)) {
                         if ('string' == typeof value.description) data.toolDescriptions.set(property, value.description);
                         if (value[MCP_ANALYTICS_PROCESSED]) {
-                            log(`Tool ${String(property)} already processed, skipping proxy wrapping`);
+                            logger(`Tool ${String(property)} already processed, skipping proxy wrapping`);
                             return Reflect.set(target, property, value);
                         }
                         if (wrappedCallbacks.has(getToolFunction(value))) {
-                            log(`Tool ${String(property)} callback already wrapped, skipping proxy wrapping`);
+                            logger(`Tool ${String(property)} callback already wrapped, skipping proxy wrapping`);
                             return Reflect.set(target, property, value);
                         }
                         const getCurrentInputSchema = ()=>value.inputSchema;
-                        const nextValue = addTracingToToolCallbackInternal(value, property, server, getCurrentInputSchema);
+                        const nextValue = addTracingToToolCallbackInternal(value, property, server, getCurrentInputSchema, logger);
                         if ('function' == typeof nextValue.update) {
                             const originalUpdate = nextValue.update;
                             nextValue.update = function(...updateArgs) {
@@ -45,7 +44,7 @@ function setupListenerToRegisteredTools(server) {
                                     if (isCallbackUpdate(updateObj)) {
                                         const wrappedTool = addTracingToToolCallbackInternal({
                                             callback: updateObj.callback
-                                        }, property, server, getCurrentInputSchema);
+                                        }, property, server, getCurrentInputSchema, logger);
                                         updateObj.callback = getToolFunction(wrappedTool);
                                     }
                                 }
@@ -56,7 +55,7 @@ function setupListenerToRegisteredTools(server) {
                     }
                     return Reflect.set(target, property, value);
                 } catch (error) {
-                    log(`Warning: Error in proxy set handler for tool ${String(property)} - ${error}`);
+                    logger(`Warning: Error in proxy set handler for tool ${String(property)} - ${error}`);
                     return Reflect.set(target, property, value);
                 }
             },
@@ -72,21 +71,20 @@ function setupListenerToRegisteredTools(server) {
         };
         const originalTools = server._registeredTools || {};
         server._registeredTools = new Proxy(originalTools, handler);
-        log('Successfully set up listener for new tool registrations');
+        logger('Successfully set up listener for new tool registrations');
     } catch (error) {
-        log(`Warning: Failed to setup listener for registered tools - ${error}`);
+        logger(`Warning: Failed to setup listener for registered tools - ${error}`);
     }
 }
-function addTracingToToolCallbackInternal(tool, toolName, server, getCurrentInputSchema = ()=>tool.inputSchema) {
+function addTracingToToolCallbackInternal(tool, toolName, server, getCurrentInputSchema, logger) {
     const originalCallback = getToolFunction(tool);
     const options = getServerTrackingData(server.server)?.options;
-    const missingToolName = resolveMissingCapabilityToolName(options);
     if (wrappedCallbacks.has(originalCallback)) {
-        log(`Tool ${toolName} callback already wrapped, skipping re-wrap`);
+        logger(`Tool ${toolName} callback already wrapped, skipping re-wrap`);
         return tool;
     }
     if (tool[MCP_ANALYTICS_PROCESSED]) {
-        log(`Tool ${toolName} already processed, skipping re-wrap`);
+        logger(`Tool ${toolName} already processed, skipping re-wrap`);
         return tool;
     }
     const wrappedCallback = async (...params)=>{
@@ -101,8 +99,8 @@ function addTracingToToolCallbackInternal(tool, toolName, server, getCurrentInpu
         }
         const inputSchema = getCurrentInputSchema();
         const cleanedArgs = stripOwnedAnalyticsArguments(args, {
-            context: toolName !== missingToolName && isContextEnabled(options?.context) && analyticsOwnsParameter(inputSchema, 'context'),
-            conversationId: toolName !== missingToolName && options?.enableConversationId === true && analyticsOwnsParameter(inputSchema, 'conversation_id')
+            context: isContextEnabled(options?.context) && analyticsOwnsParameter(inputSchema, 'context'),
+            conversationId: options?.enableConversationId === true && analyticsOwnsParameter(inputSchema, 'conversation_id')
         });
         try {
             if (void 0 === cleanedArgs) {
@@ -122,13 +120,15 @@ function addTracingToToolCallbackInternal(tool, toolName, server, getCurrentInpu
     wrappedTool[MCP_ANALYTICS_PROCESSED] = true;
     return wrappedTool;
 }
-async function handleToolCallRequest(highLevelServer, server, originalCallToolHandler, request, extra) {
+async function handleToolCallRequest(highLevelServer, server, originalCallToolHandler, request, extra, logger) {
     const data = getServerTrackingData(server);
     if (!data) {
-        log('Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using tool calls.');
+        logger('Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using tool calls.');
         return await originalCallToolHandler(request, extra);
     }
-    if (request.params?.name === resolveMissingCapabilityToolName(data.options)) {
+    const toolName = request.params?.name;
+    const isMissingCapabilityCandidate = data.options.reportMissing && toolName === resolveMissingCapabilityToolName(data.options);
+    if (isMissingCapabilityCandidate && await isToolAdvertised(server, toolName, extra, data.logger) === false) {
         const context = getContextArgument(request) || '';
         return await captureToolCall({
             server,
@@ -139,10 +139,9 @@ async function handleToolCallRequest(highLevelServer, server, originalCallToolHa
             explicitContextIntent: context,
             execute: async ()=>handleReportMissing({
                     context
-                })
+                }, data.logger)
         });
     }
-    const toolName = request.params?.name;
     const registeredTool = toolName ? highLevelServer._registeredTools[toolName] : void 0;
     return await captureToolCall({
         server,
@@ -158,24 +157,24 @@ async function handleToolCallRequest(highLevelServer, server, originalCallToolHa
         }
     });
 }
-function instrumentHighLevelServer(server) {
+function instrumentHighLevelServer(server, logger) {
     try {
         const lowLevelServer = server.server;
         const mcpAnalyticsData = getServerTrackingData(lowLevelServer);
         const handlers = {
-            initialize: handleInitializeRequest,
-            'tools/list': handleListToolsRequest,
-            'tools/call': (trackedServer, originalHandler, request, extra)=>handleToolCallRequest(server, trackedServer, originalHandler, request, extra)
+            initialize: (trackedServer, originalHandler, request, extra)=>handleInitializeRequest(trackedServer, originalHandler, request, extra, logger),
+            'tools/list': (trackedServer, originalHandler, request, extra)=>handleListToolsRequest(trackedServer, originalHandler, request, extra, logger),
+            'tools/call': (trackedServer, originalHandler, request, extra)=>handleToolCallRequest(server, trackedServer, originalHandler, request, extra, logger)
         };
         patchRequestHandlers(lowLevelServer, handlers);
-        server._registeredTools = addTracingToToolRegistry(server._registeredTools, server);
+        server._registeredTools = addTracingToToolRegistry(server._registeredTools, server, logger);
         if (mcpAnalyticsData) {
             seedToolDescriptionsFromRegistry(mcpAnalyticsData.toolDescriptions, server._registeredTools);
             seedToolCategoriesFromRegistry(mcpAnalyticsData.toolCategories, server._registeredTools);
         }
-        setupListenerToRegisteredTools(server);
+        setupListenerToRegisteredTools(server, logger);
     } catch (error) {
-        log(`Warning: Failed to setup tool call instrumentation - ${error}`);
+        logger(`Warning: Failed to setup tool call instrumentation - ${error}`);
     }
 }
 function seedToolDescriptionsFromRegistry(cache, tools) {

package/dist/extensions/instrument-lowlevel.d.ts

@@ -1,8 +1,9 @@
 import type { MCPServerLike } from '../types';
+import type { LoggerFn } from './logger';
 /**
  * Instruments a low-level `Server`: wraps `initialize`, `tools/list`, and
  * `tools/call`. The tool-call lifecycle is delegated to {@link captureToolCall},
  * shared with the high-level wrapper.
  */
-export declare function instrumentLowLevelServer(server: MCPServerLike): void;
+export declare function instrumentLowLevelServer(server: MCPServerLike, logger: LoggerFn): void;
 //# sourceMappingURL=instrument-lowlevel.d.ts.map

package/dist/extensions/instrument-lowlevel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instrument-lowlevel.d.ts","sourceRoot":"","sources":["../../src/extensions/instrument-lowlevel.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAiD,aAAa,EAAE,MAAM,UAAU,CAAA;AAmB5F;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAkBpE"}
+{"version":3,"file":"instrument-lowlevel.d.ts","sourceRoot":"","sources":["../../src/extensions/instrument-lowlevel.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAiD,aAAa,EAAE,MAAM,UAAU,CAAA;AAG5F,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAkBxC;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,QAAQ,GAAG,IAAI,CA0BtF"}

package/dist/extensions/instrument-lowlevel.js

@@ -29,31 +29,35 @@ __webpack_require__.d(__webpack_exports__, {
 const types_js_namespaceObject = require("@modelcontextprotocol/sdk/types.js");
 const external_event_types_js_namespaceObject = require("./event-types.js");
 const external_internal_js_namespaceObject = require("./internal.js");
-const external_logger_js_namespaceObject = require("./logger.js");
 const external_tools_js_namespaceObject = require("./tools.js");
 const external_instrumentation_js_namespaceObject = require("./instrumentation.js");
 const external_tracing_helpers_js_namespaceObject = require("./tracing-helpers.js");
-function instrumentLowLevelServer(server) {
+function instrumentLowLevelServer(server, logger) {
     try {
+        const hadCallToolHandler = server._requestHandlers.has('tools/call');
         const handlers = {
-            initialize: external_instrumentation_js_namespaceObject.handleInitializeRequest,
-            'tools/list': external_instrumentation_js_namespaceObject.handleListToolsRequest
+            initialize: (server, originalHandler, request, extra)=>(0, external_instrumentation_js_namespaceObject.handleInitializeRequest)(server, originalHandler, request, extra, logger),
+            'tools/list': (server, originalHandler, request, extra)=>(0, external_instrumentation_js_namespaceObject.handleListToolsRequest)(server, originalHandler, request, extra, logger),
+            'tools/call': (server, originalHandler, request, extra)=>handleToolCallRequest(server, originalHandler, request, extra, logger)
         };
         (0, external_instrumentation_js_namespaceObject.patchRequestHandlers)(server, handlers);
-        const originalCallToolHandler = server._requestHandlers.get('tools/call');
-        server.setRequestHandler(types_js_namespaceObject.CallToolRequestSchema, async (request, extra)=>await handleToolCallRequest(server, originalCallToolHandler, request, extra));
+        if (!hadCallToolHandler) server.setRequestHandler(types_js_namespaceObject.CallToolRequestSchema, async (request)=>{
+            throw new Error(`Unknown tool: ${request.params?.name || 'unknown'}`);
+        });
     } catch (error) {
-        (0, external_logger_js_namespaceObject.log)(`Warning: Failed to setup tool call instrumentation - ${error}`);
+        logger(`Warning: Failed to setup tool call instrumentation - ${error}`);
         throw error;
     }
 }
-async function handleToolCallRequest(server, originalCallToolHandler, request, extra) {
+async function handleToolCallRequest(server, originalCallToolHandler, request, extra, logger) {
     const data = (0, external_internal_js_namespaceObject.getServerTrackingData)(server);
     if (!data) {
-        (0, external_logger_js_namespaceObject.log)('Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using tool calls.');
+        logger('Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using tool calls.');
         return await originalCallToolHandler?.(request, extra);
     }
-    if (request.params?.name === (0, external_tools_js_namespaceObject.resolveMissingCapabilityToolName)(data.options)) {
+    const toolName = request.params?.name;
+    const isMissingCapabilityCandidate = data.options.reportMissing && toolName === (0, external_tools_js_namespaceObject.resolveMissingCapabilityToolName)(data.options);
+    if (isMissingCapabilityCandidate && await (0, external_instrumentation_js_namespaceObject.isToolAdvertised)(server, toolName, extra, data.logger) === false) {
         const context = (0, external_tracing_helpers_js_namespaceObject.getContextArgument)(request) || '';
         return await (0, external_instrumentation_js_namespaceObject.captureToolCall)({
             server,
@@ -64,7 +68,7 @@ async function handleToolCallRequest(server, originalCallToolHandler, request, e
             explicitContextIntent: context,
             execute: async ()=>(0, external_tools_js_namespaceObject.handleReportMissing)({
                     context
-                })
+                }, data.logger)
         });
     }
     return await (0, external_instrumentation_js_namespaceObject.captureToolCall)({

package/dist/extensions/instrument-lowlevel.mjs

@@ -1,31 +1,35 @@
 import { CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { MCPAnalyticsEventType } from "./event-types.mjs";
 import { getServerTrackingData } from "./internal.mjs";
-import { log } from "./logger.mjs";
 import { handleReportMissing, resolveMissingCapabilityToolName } from "./tools.mjs";
-import { captureToolCall, handleInitializeRequest, handleListToolsRequest, patchRequestHandlers } from "./instrumentation.mjs";
+import { captureToolCall, handleInitializeRequest, handleListToolsRequest, isToolAdvertised, patchRequestHandlers } from "./instrumentation.mjs";
 import { getContextArgument } from "./tracing-helpers.mjs";
-function instrumentLowLevelServer(server) {
+function instrumentLowLevelServer(server, logger) {
     try {
+        const hadCallToolHandler = server._requestHandlers.has('tools/call');
         const handlers = {
-            initialize: handleInitializeRequest,
-            'tools/list': handleListToolsRequest
+            initialize: (server, originalHandler, request, extra)=>handleInitializeRequest(server, originalHandler, request, extra, logger),
+            'tools/list': (server, originalHandler, request, extra)=>handleListToolsRequest(server, originalHandler, request, extra, logger),
+            'tools/call': (server, originalHandler, request, extra)=>handleToolCallRequest(server, originalHandler, request, extra, logger)
         };
         patchRequestHandlers(server, handlers);
-        const originalCallToolHandler = server._requestHandlers.get('tools/call');
-        server.setRequestHandler(CallToolRequestSchema, async (request, extra)=>await handleToolCallRequest(server, originalCallToolHandler, request, extra));
+        if (!hadCallToolHandler) server.setRequestHandler(CallToolRequestSchema, async (request)=>{
+            throw new Error(`Unknown tool: ${request.params?.name || 'unknown'}`);
+        });
     } catch (error) {
-        log(`Warning: Failed to setup tool call instrumentation - ${error}`);
+        logger(`Warning: Failed to setup tool call instrumentation - ${error}`);
         throw error;
     }
 }
-async function handleToolCallRequest(server, originalCallToolHandler, request, extra) {
+async function handleToolCallRequest(server, originalCallToolHandler, request, extra, logger) {
     const data = getServerTrackingData(server);
     if (!data) {
-        log('Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using tool calls.');
+        logger('Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using tool calls.');
         return await originalCallToolHandler?.(request, extra);
     }
-    if (request.params?.name === resolveMissingCapabilityToolName(data.options)) {
+    const toolName = request.params?.name;
+    const isMissingCapabilityCandidate = data.options.reportMissing && toolName === resolveMissingCapabilityToolName(data.options);
+    if (isMissingCapabilityCandidate && await isToolAdvertised(server, toolName, extra, data.logger) === false) {
         const context = getContextArgument(request) || '';
         return await captureToolCall({
             server,
@@ -36,7 +40,7 @@ async function handleToolCallRequest(server, originalCallToolHandler, request, e
             explicitContextIntent: context,
             execute: async ()=>handleReportMissing({
                     context
-                })
+                }, data.logger)
         });
     }
     return await captureToolCall({

package/dist/extensions/instrumentation.d.ts

@@ -1,6 +1,7 @@
 import type { ListToolsResult } from '@modelcontextprotocol/sdk/types.js';
 import type { AnalyticsParameterOwnership, CompatibleRequestHandlerExtra, MCPAnalyticsData, MCPRequestLike, MCPServerLike } from '../types';
 import { MCPAnalyticsEventType } from './event-types';
+import type { LoggerFn } from './logger';
 /**
  * Single instrumentation core shared by the low-level (`Server`) and high-level
  * (`McpServer`) wrappers. The two entrypoints differ only in how they reach the
@@ -54,19 +55,19 @@ export declare function captureToolCall(params: TraceToolCallParams): Promise<un
  * supplies `request` and `extra` per call.
  */
 export type HandlerPatch = (server: MCPServerLike, originalHandler: MCPRequestHandler, request: MCPRequestLike, extra: CompatibleRequestHandlerExtra | undefined) => Promise<unknown>;
+export declare function patchRequestHandlers(server: MCPServerLike, patches: Record<string, HandlerPatch>): void;
 /**
- * Applies the `patches` (keyed by method, e.g. `initialize`, `tools/list`) to the
- * handlers already registered, and patches `setRequestHandler` so matching
- * handlers registered later are patched too. The latter is what makes adapters
- * that register handlers post-construction work — e.g. `@rekog/mcp-nest` hands a
- * bare server to instrument() and only then registers its handlers.
+ * Checks the server's raw listing for a real owner of a candidate virtual tool.
+ * This does not depend on a previous client request and does not call the
+ * instrumented list wrapper, so it neither injects PostHog tools nor captures a
+ * synthetic tools/list event. `undefined` fails open to the real dispatcher.
  */
-export declare function patchRequestHandlers(server: MCPServerLike, patches: Record<string, HandlerPatch>): void;
+export declare function isToolAdvertised(server: MCPServerLike, toolName: string, extra: CompatibleRequestHandlerExtra | undefined, logger: LoggerFn): Promise<boolean | undefined>;
 /**
  * Captures each `tools/list` and injects the SDK-managed tools (context
  * parameter, conversation id, `get_more_tools`) into the returned list.
  */
-export declare function handleListToolsRequest(server: MCPServerLike, originalListToolsHandler: MCPRequestHandler, request: MCPRequestLike, extra?: CompatibleRequestHandlerExtra): Promise<{
+export declare function handleListToolsRequest(server: MCPServerLike, originalListToolsHandler: MCPRequestHandler, request: MCPRequestLike, extra: CompatibleRequestHandlerExtra | undefined, logger: LoggerFn): Promise<{
     tools: ListToolsResult['tools'];
 }>;
 export declare function cacheToolDescriptions(cache: Map<string, string>, tools: ListToolsResult['tools'] | undefined): void;
@@ -81,6 +82,6 @@ export declare function cacheToolCategories(cache: Map<string, string>, tools: L
  * Captures the connection handshake (and resolves identity) on `initialize`
  * before the original handler runs.
  */
-export declare function handleInitializeRequest(server: MCPServerLike, originalInitializeHandler: MCPRequestHandler, request: MCPRequestLike, extra?: CompatibleRequestHandlerExtra): Promise<unknown>;
+export declare function handleInitializeRequest(server: MCPServerLike, originalInitializeHandler: MCPRequestHandler, request: MCPRequestLike, extra: CompatibleRequestHandlerExtra | undefined, logger: LoggerFn): Promise<unknown>;
 export {};
 //# sourceMappingURL=instrumentation.d.ts.map

package/dist/extensions/instrumentation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/extensions/instrumentation.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAA;AACzE,OAAO,KAAK,EACV,2BAA2B,EAC3B,6BAA6B,EAC7B,gBAAgB,EAChB,cAAc,EACd,aAAa,EAGd,MAAM,UAAU,CAAA;AAYjB,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAYrD;;;;;;GAMG;AAEH,KAAK,iBAAiB,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,CAAC,EAAE,6BAA6B,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAE7G,2EAA2E;AAC3E,KAAK,YAAY,GAAG,CAAC,iBAAiB,EAAE,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAE3E,UAAU,mBAAmB;IAC3B,MAAM,EAAE,aAAa,CAAA;IACrB,IAAI,EAAE,gBAAgB,CAAA;IACtB,OAAO,EAAE,cAAc,CAAA;IACvB,KAAK,CAAC,EAAE,6BAA6B,CAAA;IACrC,OAAO,EAAE,YAAY,CAAA;IACrB,2FAA2F;IAC3F,kBAAkB,CAAC,EAAE,2BAA2B,CAAA;IAChD;;;;OAIG;IACH,SAAS,CAAC,EAAE,qBAAqB,CAAA;IACjC;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,OAAO,CAAA;CAClC;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC,CAmDnF;AAqJD;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,CACzB,MAAM,EAAE,aAAa,EACrB,eAAe,EAAE,iBAAiB,EAClC,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,6BAA6B,GAAG,SAAS,KAC7C,OAAO,CAAC,OAAO,CAAC,CAAA;AAErB;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,IAAI,CAqBvG;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,aAAa,EACrB,wBAAwB,EAAE,iBAAiB,EAC3C,OAAO,EAAE,cAAc,EACvB,KAAK,CAAC,EAAE,6BAA6B,GACpC,OAAO,CAAC;IAAE,KAAK,EAAE,eAAe,CAAC,OAAO,CAAC,CAAA;CAAE,CAAC,CAyC9C;AAwED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,eAAe,CAAC,OAAO,CAAC,GAAG,SAAS,GAAG,IAAI,CASnH;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAGtE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,eAAe,CAAC,OAAO,CAAC,GAAG,SAAS,GAAG,IAAI,CAUjH;AA8GD;;;GAGG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,aAAa,EACrB,yBAAyB,EAAE,iBAAiB,EAC5C,OAAO,EAAE,cAAc,EACvB,KAAK,CAAC,EAAE,6BAA6B,GACpC,OAAO,CAAC,OAAO,CAAC,CA0ClB"}
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/extensions/instrumentation.ts"],"names":[],"mappings":"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"}