@posthog/mcp 0.10.4 → 0.10.5

package/dist/extensions/instrument-highlevel.mjs

@@ -2,7 +2,6 @@ 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";
@@ -12,31 +11,31 @@ 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,21 @@ 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)=>{
@@ -122,10 +121,10 @@ 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)) {
@@ -139,7 +138,7 @@ async function handleToolCallRequest(highLevelServer, server, originalCallToolHa
             explicitContextIntent: context,
             execute: async ()=>handleReportMissing({
                     context
-                })
+                }, data.logger)
         });
     }
     const toolName = request.params?.name;
@@ -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;AAiBxC;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,QAAQ,GAAG,IAAI,CAoBtF"}

package/dist/extensions/instrument-lowlevel.js

@@ -29,28 +29,27 @@ __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 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)
         };
         (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));
+        server.setRequestHandler(types_js_namespaceObject.CallToolRequestSchema, async (request, extra)=>await handleToolCallRequest(server, originalCallToolHandler, request, extra, logger));
     } 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)) {
@@ -64,7 +63,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,28 +1,27 @@
 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 { getContextArgument } from "./tracing-helpers.mjs";
-function instrumentLowLevelServer(server) {
+function instrumentLowLevelServer(server, logger) {
     try {
         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)
         };
         patchRequestHandlers(server, handlers);
         const originalCallToolHandler = server._requestHandlers.get('tools/call');
-        server.setRequestHandler(CallToolRequestSchema, async (request, extra)=>await handleToolCallRequest(server, originalCallToolHandler, request, extra));
+        server.setRequestHandler(CallToolRequestSchema, async (request, extra)=>await handleToolCallRequest(server, originalCallToolHandler, request, extra, logger));
     } 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)) {
@@ -36,7 +35,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
@@ -66,7 +67,7 @@ export declare function patchRequestHandlers(server: MCPServerLike, patches: Rec
  * 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":"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;AAIrD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAQxC;;;;;;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;AAuJD;;;;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,EAAE,6BAA6B,GAAG,SAAS,EAChD,MAAM,EAAE,QAAQ,GACf,OAAO,CAAC;IAAE,KAAK,EAAE,eAAe,CAAC,OAAO,CAAC,CAAA;CAAE,CAAC,CAyC9C;AAyED,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,EAAE,6BAA6B,GAAG,SAAS,EAChD,MAAM,EAAE,QAAQ,GACf,OAAO,CAAC,OAAO,CAAC,CA0ClB"}

package/dist/extensions/instrumentation.js

@@ -41,7 +41,6 @@ const external_event_types_js_namespaceObject = require("./event-types.js");
 const external_exceptions_js_namespaceObject = require("./exceptions.js");
 const external_intent_js_namespaceObject = require("./intent.js");
 const external_internal_js_namespaceObject = require("./internal.js");
-const external_logger_js_namespaceObject = require("./logger.js");
 const external_mcp_payloads_js_namespaceObject = require("./mcp-payloads.js");
 const external_mcp_sdk_compat_js_namespaceObject = require("./mcp-sdk-compat.js");
 const external_session_js_namespaceObject = require("./session.js");
@@ -60,11 +59,11 @@ async function captureToolCall(params) {
     try {
         result = await execute(downstreamRequest);
     } catch (error) {
-        publishFailedToolEvent(server, event, error, startTime, conversation);
+        publishFailedToolEvent(server, event, error, startTime, conversation, data.logger);
         throw error;
     }
     const finalResult = applyConversationPromptBack(event, result, conversation);
-    publishSuccessfulToolEvent(server, event, finalResult, startTime, takeCapturedError);
+    publishSuccessfulToolEvent(server, event, finalResult, startTime, data.logger, takeCapturedError);
     return finalResult;
 }
 function getActiveAnalyticsParameterOwnership(data, toolName, override) {
@@ -107,7 +106,7 @@ async function prepareToolCallEvent(server, data, request, downstreamRequest, ex
         (0, external_intent_js_namespaceObject.setEventIntent)(event, await (0, external_intent_js_namespaceObject.resolveToolCallIntent)(data, request, ownership.context, extra));
         return event;
     } catch (error) {
-        (0, external_logger_js_namespaceObject.log)(`Warning: PostHog MCP analytics instrumentation failed for tool ${request.params?.name}, the tool will still run - ${error}`);
+        data.logger(`Warning: PostHog MCP analytics instrumentation failed for tool ${request.params?.name}, the tool will still run - ${error}`);
         return null;
     }
 }
@@ -117,7 +116,7 @@ function applyConversationPromptBack(event, result, conversation) {
     if (event) event.conversationId = void 0;
     return result;
 }
-function publishSuccessfulToolEvent(server, event, result, startTime, takeCapturedError) {
+function publishSuccessfulToolEvent(server, event, result, startTime, logger, takeCapturedError) {
     if (!event) return;
     try {
         if ((0, external_tracing_helpers_js_namespaceObject.isToolResultError)(result)) {
@@ -127,21 +126,21 @@ function publishSuccessfulToolEvent(server, event, result, startTime, takeCaptur
         } else event.isError = false;
         event.response = result;
         event.duration = Date.now() - startTime.getTime();
-        (0, external_capture_js_namespaceObject.captureEvent)(server, event);
+        (0, external_capture_js_namespaceObject.captureEvent)(server, event, logger);
     } catch (error) {
-        (0, external_logger_js_namespaceObject.log)(`Warning: PostHog MCP analytics failed to publish tool event - ${error}`);
+        logger(`Warning: PostHog MCP analytics failed to publish tool event - ${error}`);
     }
 }
-function publishFailedToolEvent(server, event, error, startTime, conversation) {
+function publishFailedToolEvent(server, event, error, startTime, conversation, logger) {
     if (!event) return;
     try {
         if (conversation.minted) event.conversationId = void 0;
         event.isError = true;
         event.error = (0, external_exceptions_js_namespaceObject.captureException)(error);
         event.duration = Date.now() - startTime.getTime();
-        (0, external_capture_js_namespaceObject.captureEvent)(server, event);
+        (0, external_capture_js_namespaceObject.captureEvent)(server, event, logger);
     } catch (publishError) {
-        (0, external_logger_js_namespaceObject.log)(`Warning: PostHog MCP analytics failed to publish failed tool event - ${publishError}`);
+        logger(`Warning: PostHog MCP analytics failed to publish failed tool event - ${publishError}`);
     }
 }
 function patchRequestHandlers(server, patches) {
@@ -158,7 +157,7 @@ function patchRequestHandlers(server, patches) {
         return originalSetRequestHandler(requestSchema, (request, extra)=>patch(server, originalHandler, request, extra));
     };
 }
-async function handleListToolsRequest(server, originalListToolsHandler, request, extra) {
+async function handleListToolsRequest(server, originalListToolsHandler, request, extra, logger) {
     const data = (0, external_internal_js_namespaceObject.getServerTrackingData)(server);
     const startTime = new Date();
     const event = {
@@ -169,19 +168,19 @@ async function handleListToolsRequest(server, originalListToolsHandler, request,
     };
     (0, external_client_identity_js_namespaceObject.stampMetaClientInfo)(event, request);
     if (data) await (0, external_tracing_helpers_js_namespaceObject.applyResolvedMetadata)(event, data, request, extra);
-    const tools = await getTracedToolsList(server, originalListToolsHandler, request, extra, event);
+    const tools = await getTracedToolsList(server, originalListToolsHandler, request, extra, event, logger);
     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 {
             tools
         };
     }
     if (0 === tools.length) {
-        (0, external_logger_js_namespaceObject.log)('Warning: No tools found in the original list. This is likely due to the tools not being registered before PostHog MCP analytics.instrument().');
+        data.logger('Warning: No tools found in the original list. This is likely due to the tools not being registered before PostHog MCP analytics.instrument().');
         event.error = (0, external_exceptions_js_namespaceObject.captureException)('No tools were sent to MCP client.');
         event.isError = true;
         event.duration = Date.now() - startTime.getTime();
-        (0, external_capture_js_namespaceObject.captureEvent)(server, event);
+        (0, external_capture_js_namespaceObject.captureEvent)(server, event, data.logger);
         return {
             tools
         };
@@ -192,7 +191,7 @@ async function handleListToolsRequest(server, originalListToolsHandler, request,
     event.listedToolNames = collectListedToolNames(tools);
     event.isError = false;
     event.duration = Date.now() - startTime.getTime();
-    (0, external_capture_js_namespaceObject.captureEvent)(server, event);
+    (0, external_capture_js_namespaceObject.captureEvent)(server, event, data.logger);
     return {
         tools
     };
@@ -205,14 +204,14 @@ function collectListedToolNames(tools) {
     const names = tools.map((tool)=>tool?.name).filter((name)=>'string' == typeof name);
     return names.length > 0 ? names : void 0;
 }
-async function getTracedToolsList(server, originalListToolsHandler, request, extra, event) {
+async function getTracedToolsList(server, originalListToolsHandler, request, extra, event, logger) {
     try {
         const data = (0, external_internal_js_namespaceObject.getServerTrackingData)(server);
         const originalResponse = await originalListToolsHandler(request, extra);
         let tools = originalResponse.tools || [];
         if (data) cacheToolAnalyticsParameterOwnership(data.toolAnalyticsParameterOwnership, tools);
-        if (data && (0, external_context_parameters_js_namespaceObject.isContextEnabled)(data.options.context)) tools = (0, external_context_parameters_js_namespaceObject.addContextParameterToTools)(tools, (0, external_context_parameters_js_namespaceObject.getContextDescription)(data.options.context));
-        if (data?.options.enableConversationId) tools = (0, external_conversation_id_js_namespaceObject.addConversationIdToTools)(tools, (0, external_tools_js_namespaceObject.resolveMissingCapabilityToolName)(data.options));
+        if (data && (0, external_context_parameters_js_namespaceObject.isContextEnabled)(data.options.context)) tools = (0, external_context_parameters_js_namespaceObject.addContextParameterToTools)(tools, (0, external_context_parameters_js_namespaceObject.getContextDescription)(data.options.context), data.logger);
+        if (data?.options.enableConversationId) tools = (0, external_conversation_id_js_namespaceObject.addConversationIdToTools)(tools, (0, external_tools_js_namespaceObject.resolveMissingCapabilityToolName)(data.options), data.logger);
         if (data?.options.reportMissing) {
             const missingToolName = (0, external_tools_js_namespaceObject.resolveMissingCapabilityToolName)(data.options);
             const alreadyPresent = tools.some((tool)=>tool?.name === missingToolName);
@@ -224,11 +223,11 @@ async function getTracedToolsList(server, originalListToolsHandler, request, ext
         }
         return tools;
     } catch (error) {
-        (0, external_logger_js_namespaceObject.log)(`Warning: Original list tools handler failed, this suggests an error PostHog MCP analytics did not cause - ${error}`);
+        logger(`Warning: Original list tools handler failed, this suggests an error PostHog MCP analytics did not cause - ${error}`);
         event.error = (0, external_exceptions_js_namespaceObject.captureException)(error);
         event.isError = true;
         event.duration = event.timestamp ? Date.now() - event.timestamp.getTime() : 0;
-        (0, external_capture_js_namespaceObject.captureEvent)(server, event);
+        (0, external_capture_js_namespaceObject.captureEvent)(server, event, logger);
         throw error;
     }
 }
@@ -273,7 +272,7 @@ function mintStatelessSessionOnInitialize(server, data, request, extra) {
         (0, external_internal_js_namespaceObject.setServerTrackingData)(server, data);
         return sessionId;
     } catch (error) {
-        (0, external_logger_js_namespaceObject.log)(`Warning: PostHog MCP analytics failed to mint a stateless session id - ${error}`);
+        data.logger(`Warning: PostHog MCP analytics failed to mint a stateless session id - ${error}`);
         return;
     }
 }
@@ -289,7 +288,7 @@ function upgradeMintedTokenToNegotiated(server, data, mintedSessionId, negotiate
         });
         (0, external_session_token_js_namespaceObject.writeSessionIdToTransport)(transport, token);
     } catch (error) {
-        (0, external_logger_js_namespaceObject.log)(`Warning: PostHog MCP analytics failed to upgrade the stateless session token - ${error}`);
+        data.logger(`Warning: PostHog MCP analytics failed to upgrade the stateless session token - ${error}`);
     }
 }
 function readInitializeClientInfo(request) {
@@ -301,10 +300,10 @@ function readInitializeClientInfo(request) {
         version: 'string' == typeof version ? version : void 0
     };
 }
-async function handleInitializeRequest(server, originalInitializeHandler, request, extra) {
+async function handleInitializeRequest(server, originalInitializeHandler, 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 originalInitializeHandler(request, extra);
     }
     const mintedSessionId = mintStatelessSessionOnInitialize(server, data, request, extra);
@@ -326,7 +325,7 @@ async function handleInitializeRequest(server, originalInitializeHandler, reques
     data.sessionInfo.protocolVersion = negotiatedProtocolVersion;
     (0, external_internal_js_namespaceObject.setServerTrackingData)(server, data);
     if (mintedSessionId) upgradeMintedTokenToNegotiated(server, data, mintedSessionId, negotiatedProtocolVersion);
-    (0, external_capture_js_namespaceObject.captureEvent)(server, event);
+    (0, external_capture_js_namespaceObject.captureEvent)(server, event, data.logger);
     return result;
 }
 function readProtocolVersion(result, request) {