@posthog/mcp 0.4.2 → 0.4.4

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

@@ -1 +1 @@
-{"version":3,"file":"instrument-highlevel.d.ts","sourceRoot":"","sources":["../../src/extensions/instrument-highlevel.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAiC,sBAAsB,EAAiC,MAAM,UAAU,CAAA;AAmRpH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,sBAAsB,GAAG,IAAI,CAqB9E"}
+{"version":3,"file":"instrument-highlevel.d.ts","sourceRoot":"","sources":["../../src/extensions/instrument-highlevel.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAiC,sBAAsB,EAAiC,MAAM,UAAU,CAAA;AAqPpH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,sBAAsB,GAAG,IAAI,CAwB9E"}

package/dist/extensions/instrument-highlevel.js

@@ -63,7 +63,6 @@ function setupListenerToRegisteredTools(server) {
                             return Reflect.set(target, property, value);
                         }
                         const nextValue = addTracingToToolCallbackInternal(value, property, server);
-                        (0, external_instrumentation_js_namespaceObject.instrumentToolsListHandler)(server.server);
                         if ('function' == typeof nextValue.update) {
                             const originalUpdate = nextValue.update;
                             nextValue.update = function(...updateArgs) {
@@ -151,32 +150,11 @@ function addTracingToToolCallbackInternal(tool, toolName, server) {
     wrappedTool[MCP_ANALYTICS_PROCESSED] = true;
     return wrappedTool;
 }
-function setupToolsCallHandlerWrapping(server) {
-    const lowLevelServer = server.server;
-    const existingHandler = lowLevelServer._requestHandlers.get('tools/call');
-    if (existingHandler) {
-        const wrappedHandler = createToolsCallWrapper(existingHandler, lowLevelServer);
-        lowLevelServer._requestHandlers.set('tools/call', wrappedHandler);
-    }
-    const originalSetRequestHandler = lowLevelServer.setRequestHandler.bind(lowLevelServer);
-    lowLevelServer.setRequestHandler = (requestSchema, handler)=>{
-        const shape = (0, external_mcp_sdk_compat_js_namespaceObject.getObjectShape)(requestSchema);
-        const method = shape?.method ? (0, external_mcp_sdk_compat_js_namespaceObject.getLiteralValue)(shape.method) : void 0;
-        if ('tools/call' === method) {
-            const wrappedHandler = createToolsCallWrapper(handler, lowLevelServer);
-            return originalSetRequestHandler(requestSchema, wrappedHandler);
-        }
-        return originalSetRequestHandler(requestSchema, handler);
-    };
-}
-function createToolsCallWrapper(originalHandler, server) {
-    return async (request, extra)=>await handleWrappedToolsCall(originalHandler, server, request, extra);
-}
-async function handleWrappedToolsCall(originalHandler, server, request, extra) {
+async function handleToolCallRequest(server, originalCallToolHandler, request, extra) {
     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.');
-        return await originalHandler(request, extra);
+        return await originalCallToolHandler(request, extra);
     }
     if (request.params?.name === (0, external_tools_js_namespaceObject.resolveMissingCapabilityToolName)(data.options)) {
         const context = (0, external_tracing_helpers_js_namespaceObject.getContextArgument)(request) || '';
@@ -197,7 +175,7 @@ async function handleWrappedToolsCall(originalHandler, server, request, extra) {
         data,
         request,
         extra,
-        execute: ()=>originalHandler(request, extra),
+        execute: ()=>originalCallToolHandler(request, extra),
         takeCapturedError: ()=>{
             const captured = extra?.__mcp_analytics_error;
             if (extra) extra.__mcp_analytics_error = void 0;
@@ -207,15 +185,19 @@ async function handleWrappedToolsCall(originalHandler, server, request, extra) {
 }
 function instrumentHighLevelServer(server) {
     try {
-        const mcpAnalyticsData = (0, external_internal_js_namespaceObject.getServerTrackingData)(server.server);
-        setupToolsCallHandlerWrapping(server);
-        (0, external_instrumentation_js_namespaceObject.instrumentInitializeHandler)(server.server);
+        const lowLevelServer = server.server;
+        const mcpAnalyticsData = (0, external_internal_js_namespaceObject.getServerTrackingData)(lowLevelServer);
+        const handlers = {
+            initialize: external_instrumentation_js_namespaceObject.handleInitializeRequest,
+            'tools/list': external_instrumentation_js_namespaceObject.handleListToolsRequest,
+            'tools/call': handleToolCallRequest
+        };
+        (0, external_instrumentation_js_namespaceObject.patchRequestHandlers)(lowLevelServer, handlers);
         server._registeredTools = addTracingToToolRegistry(server._registeredTools, server);
         if (mcpAnalyticsData) {
             seedToolDescriptionsFromRegistry(mcpAnalyticsData.toolDescriptions, server._registeredTools);
             seedToolCategoriesFromRegistry(mcpAnalyticsData.toolCategories, server._registeredTools);
         }
-        (0, external_instrumentation_js_namespaceObject.instrumentToolsListHandler)(server.server);
         setupListenerToRegisteredTools(server);
     } catch (error) {
         (0, external_logger_js_namespaceObject.log)(`Warning: Failed to setup tool call instrumentation - ${error}`);

package/dist/extensions/instrument-highlevel.mjs

@@ -2,9 +2,9 @@ import { stripConversationId } from "./conversation-id.mjs";
 import { MCPAnalyticsEventType } from "./event-types.mjs";
 import { getServerTrackingData } from "./internal.mjs";
 import { log } from "./logger.mjs";
-import { createWrappedTool, getLiteralValue, getObjectShape, getToolFunction, hasToolFunction } from "./mcp-sdk-compat.mjs";
+import { createWrappedTool, getToolFunction, hasToolFunction } from "./mcp-sdk-compat.mjs";
 import { handleReportMissing, resolveMissingCapabilityToolName } from "./tools.mjs";
-import { captureToolCall, instrumentInitializeHandler, instrumentToolsListHandler, readToolMetaCategory } from "./instrumentation.mjs";
+import { captureToolCall, handleInitializeRequest, handleListToolsRequest, patchRequestHandlers, readToolMetaCategory } from "./instrumentation.mjs";
 import { getContextArgument } from "./tracing-helpers.mjs";
 const wrappedCallbacks = new WeakMap();
 const MCP_ANALYTICS_PROCESSED = Symbol('__posthog_mcp_analytics_processed__');
@@ -35,7 +35,6 @@ function setupListenerToRegisteredTools(server) {
                             return Reflect.set(target, property, value);
                         }
                         const nextValue = addTracingToToolCallbackInternal(value, property, server);
-                        instrumentToolsListHandler(server.server);
                         if ('function' == typeof nextValue.update) {
                             const originalUpdate = nextValue.update;
                             nextValue.update = function(...updateArgs) {
@@ -123,32 +122,11 @@ function addTracingToToolCallbackInternal(tool, toolName, server) {
     wrappedTool[MCP_ANALYTICS_PROCESSED] = true;
     return wrappedTool;
 }
-function setupToolsCallHandlerWrapping(server) {
-    const lowLevelServer = server.server;
-    const existingHandler = lowLevelServer._requestHandlers.get('tools/call');
-    if (existingHandler) {
-        const wrappedHandler = createToolsCallWrapper(existingHandler, lowLevelServer);
-        lowLevelServer._requestHandlers.set('tools/call', wrappedHandler);
-    }
-    const originalSetRequestHandler = lowLevelServer.setRequestHandler.bind(lowLevelServer);
-    lowLevelServer.setRequestHandler = (requestSchema, handler)=>{
-        const shape = getObjectShape(requestSchema);
-        const method = shape?.method ? getLiteralValue(shape.method) : void 0;
-        if ('tools/call' === method) {
-            const wrappedHandler = createToolsCallWrapper(handler, lowLevelServer);
-            return originalSetRequestHandler(requestSchema, wrappedHandler);
-        }
-        return originalSetRequestHandler(requestSchema, handler);
-    };
-}
-function createToolsCallWrapper(originalHandler, server) {
-    return async (request, extra)=>await handleWrappedToolsCall(originalHandler, server, request, extra);
-}
-async function handleWrappedToolsCall(originalHandler, server, request, extra) {
+async function handleToolCallRequest(server, originalCallToolHandler, request, extra) {
     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.');
-        return await originalHandler(request, extra);
+        return await originalCallToolHandler(request, extra);
     }
     if (request.params?.name === resolveMissingCapabilityToolName(data.options)) {
         const context = getContextArgument(request) || '';
@@ -169,7 +147,7 @@ async function handleWrappedToolsCall(originalHandler, server, request, extra) {
         data,
         request,
         extra,
-        execute: ()=>originalHandler(request, extra),
+        execute: ()=>originalCallToolHandler(request, extra),
         takeCapturedError: ()=>{
             const captured = extra?.__mcp_analytics_error;
             if (extra) extra.__mcp_analytics_error = void 0;
@@ -179,15 +157,19 @@ async function handleWrappedToolsCall(originalHandler, server, request, extra) {
 }
 function instrumentHighLevelServer(server) {
     try {
-        const mcpAnalyticsData = getServerTrackingData(server.server);
-        setupToolsCallHandlerWrapping(server);
-        instrumentInitializeHandler(server.server);
+        const lowLevelServer = server.server;
+        const mcpAnalyticsData = getServerTrackingData(lowLevelServer);
+        const handlers = {
+            initialize: handleInitializeRequest,
+            'tools/list': handleListToolsRequest,
+            'tools/call': handleToolCallRequest
+        };
+        patchRequestHandlers(lowLevelServer, handlers);
         server._registeredTools = addTracingToToolRegistry(server._registeredTools, server);
         if (mcpAnalyticsData) {
             seedToolDescriptionsFromRegistry(mcpAnalyticsData.toolDescriptions, server._registeredTools);
             seedToolCategoriesFromRegistry(mcpAnalyticsData.toolCategories, server._registeredTools);
         }
-        instrumentToolsListHandler(server.server);
         setupListenerToRegisteredTools(server);
     } catch (error) {
         log(`Warning: Failed to setup tool call instrumentation - ${error}`);

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":"AAKA,OAAO,KAAK,EAAiD,aAAa,EAAE,MAAM,UAAU,CAAA;AAc5F;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAcpE"}
+{"version":3,"file":"instrument-lowlevel.d.ts","sourceRoot":"","sources":["../../src/extensions/instrument-lowlevel.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAiD,aAAa,EAAE,MAAM,UAAU,CAAA;AAmB5F;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAkBpE"}

package/dist/extensions/instrument-lowlevel.js

@@ -35,8 +35,11 @@ const external_instrumentation_js_namespaceObject = require("./instrumentation.j
 const external_tracing_helpers_js_namespaceObject = require("./tracing-helpers.js");
 function instrumentLowLevelServer(server) {
     try {
-        (0, external_instrumentation_js_namespaceObject.instrumentInitializeHandler)(server);
-        (0, external_instrumentation_js_namespaceObject.instrumentToolsListHandler)(server);
+        const handlers = {
+            initialize: external_instrumentation_js_namespaceObject.handleInitializeRequest,
+            'tools/list': external_instrumentation_js_namespaceObject.handleListToolsRequest
+        };
+        (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));
     } catch (error) {

package/dist/extensions/instrument-lowlevel.mjs

@@ -3,12 +3,15 @@ import { MCPAnalyticsEventType } from "./event-types.mjs";
 import { getServerTrackingData } from "./internal.mjs";
 import { log } from "./logger.mjs";
 import { handleReportMissing, resolveMissingCapabilityToolName } from "./tools.mjs";
-import { captureToolCall, instrumentInitializeHandler, instrumentToolsListHandler } from "./instrumentation.mjs";
+import { captureToolCall, handleInitializeRequest, handleListToolsRequest, patchRequestHandlers } from "./instrumentation.mjs";
 import { getContextArgument } from "./tracing-helpers.mjs";
 function instrumentLowLevelServer(server) {
     try {
-        instrumentInitializeHandler(server);
-        instrumentToolsListHandler(server);
+        const handlers = {
+            initialize: handleInitializeRequest,
+            'tools/list': handleListToolsRequest
+        };
+        patchRequestHandlers(server, handlers);
         const originalCallToolHandler = server._requestHandlers.get('tools/call');
         server.setRequestHandler(CallToolRequestSchema, async (request, extra)=>await handleToolCallRequest(server, originalCallToolHandler, request, extra));
     } catch (error) {

package/dist/extensions/instrumentation.d.ts

@@ -1,6 +1,14 @@
-import { type ListToolsResult } from '@modelcontextprotocol/sdk/types.js';
+import type { ListToolsResult } from '@modelcontextprotocol/sdk/types.js';
 import type { CompatibleRequestHandlerExtra, MCPAnalyticsData, MCPRequestLike, MCPServerLike } from '../types';
 import { MCPAnalyticsEventType } from './event-types';
+/**
+ * Single instrumentation core shared by the low-level (`Server`) and high-level
+ * (`McpServer`) wrappers. The two entrypoints differ only in how they reach the
+ * underlying tool — they both funnel the tool-call lifecycle through
+ * {@link captureToolCall}, so error handling, conversation-id minting, session
+ * attribution, and event capture are defined exactly once.
+ */
+type MCPRequestHandler = (request: MCPRequestLike, extra?: CompatibleRequestHandlerExtra) => Promise<unknown>;
 /**
  * Runs the underlying tool. Receives the request with the SDK-injected
  * `conversation_id` stripped; an adapter is free to ignore it (the high-level
@@ -43,19 +51,26 @@ interface TraceToolCallParams {
  */
 export declare function captureToolCall(params: TraceToolCallParams): Promise<unknown>;
 /**
- * Wraps the server's `tools/list` handler so each listing is captured and the
- * SDK-managed tools (context parameter, conversation id, `get_more_tools`) are
- * injected. Idempotent per server. Works for both low-level and high-level
- * servers — the high-level wrapper passes its underlying `server`.
- *
- * The handler can reach us two ways, and we cover both:
- *  1. It already exists when instrument() runs (tools registered first) — wrap
- *     the entry in `_requestHandlers` directly.
- *  2. It's registered after instrument() (e.g. `@rekog/mcp-nest` registers it at
- *     the low level once it gets the server) — intercept `setRequestHandler` and
- *     wrap the handler as it lands, mirroring how `tools/call` already works.
+ * A method's patch: runs the original handler and captures analytics. `server`
+ * and `originalHandler` are bound by {@link patchRequestHandlers}; the SDK
+ * supplies `request` and `extra` per call.
+ */
+export type HandlerPatch = (server: MCPServerLike, originalHandler: MCPRequestHandler, request: MCPRequestLike, extra: CompatibleRequestHandlerExtra | undefined) => Promise<unknown>;
+/**
+ * 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.
+ */
+export declare function patchRequestHandlers(server: MCPServerLike, patches: Record<string, HandlerPatch>): void;
+/**
+ * Captures each `tools/list` and injects the SDK-managed tools (context
+ * parameter, conversation id, `get_more_tools`) into the returned list.
  */
-export declare function instrumentToolsListHandler(server: MCPServerLike): void;
+export declare function handleListToolsRequest(server: MCPServerLike, originalListToolsHandler: MCPRequestHandler, request: MCPRequestLike, extra?: CompatibleRequestHandlerExtra): Promise<{
+    tools: ListToolsResult['tools'];
+}>;
 export declare function cacheToolDescriptions(cache: Map<string, string>, tools: ListToolsResult['tools'] | undefined): void;
 /**
  * Category declared on a tool's `_meta` block (the MCP spec allows arbitrary
@@ -65,9 +80,9 @@ export declare function cacheToolDescriptions(cache: Map<string, string>, tools:
 export declare function readToolMetaCategory(meta: unknown): string | undefined;
 export declare function cacheToolCategories(cache: Map<string, string>, tools: ListToolsResult['tools'] | undefined): void;
 /**
- * Wraps the server's `initialize` handler so the connection handshake is
- * captured (and identity resolved) before the original handler runs.
+ * Captures the connection handshake (and resolves identity) on `initialize`
+ * before the original handler runs.
  */
-export declare function instrumentInitializeHandler(server: MCPServerLike): void;
+export declare function handleInitializeRequest(server: MCPServerLike, originalInitializeHandler: MCPRequestHandler, request: MCPRequestLike, extra?: CompatibleRequestHandlerExtra): 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":"AAIA,OAAO,EAA2B,KAAK,eAAe,EAAE,MAAM,oCAAoC,CAAA;AAClG,OAAO,KAAK,EAAE,6BAA6B,EAAE,gBAAgB,EAAE,cAAc,EAAE,aAAa,EAAY,MAAM,UAAU,CAAA;AAWxH,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAqBrD;;;;GAIG;AACH,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;;;;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,CAuCnF;AAwHD;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAiCtE;AAuGD,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;AAID;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAiCvE"}
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/extensions/instrumentation.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAA;AACzE,OAAO,KAAK,EAAE,6BAA6B,EAAE,gBAAgB,EAAE,cAAc,EAAE,aAAa,EAAY,MAAM,UAAU,CAAA;AAWxH,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAWrD;;;;;;GAMG;AAEH,KAAK,iBAAiB,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,CAAC,EAAE,6BAA6B,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAE7G;;;;GAIG;AACH,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;;;;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,CAuCnF;AAgHD;;;;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,CAwC9C;AAwDD,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;AAID;;;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,CA0BlB"}

package/dist/extensions/instrumentation.js

@@ -27,11 +27,11 @@ __webpack_require__.d(__webpack_exports__, {
     readToolMetaCategory: ()=>readToolMetaCategory,
     cacheToolDescriptions: ()=>cacheToolDescriptions,
     cacheToolCategories: ()=>cacheToolCategories,
+    handleInitializeRequest: ()=>handleInitializeRequest,
     captureToolCall: ()=>captureToolCall,
-    instrumentInitializeHandler: ()=>instrumentInitializeHandler,
-    instrumentToolsListHandler: ()=>instrumentToolsListHandler
+    handleListToolsRequest: ()=>handleListToolsRequest,
+    patchRequestHandlers: ()=>patchRequestHandlers
 });
-const types_js_namespaceObject = require("@modelcontextprotocol/sdk/types.js");
 const external_context_parameters_js_namespaceObject = require("./context-parameters.js");
 const external_conversation_id_js_namespaceObject = require("./conversation-id.js");
 const external_capture_js_namespaceObject = require("./capture.js");
@@ -119,24 +119,19 @@ function publishFailedToolEvent(server, event, error, startTime, conversation) {
         (0, external_logger_js_namespaceObject.log)(`Warning: PostHog MCP analytics failed to publish failed tool event - ${publishError}`);
     }
 }
-const listToolsTracingSetup = new WeakMap();
-function instrumentToolsListHandler(server) {
-    if (!server._capabilities?.tools) return;
-    if (listToolsTracingSetup.get(server)) return;
-    listToolsTracingSetup.set(server, true);
-    try {
-        const existingHandler = server._requestHandlers.get('tools/list');
-        if (existingHandler) server._requestHandlers.set('tools/list', (request, extra)=>handleListToolsRequest(server, existingHandler, request, extra));
-        const originalSetRequestHandler = server.setRequestHandler.bind(server);
-        server.setRequestHandler = (requestSchema, handler)=>{
-            const shape = (0, external_mcp_sdk_compat_js_namespaceObject.getObjectShape)(requestSchema);
-            const method = shape?.method ? (0, external_mcp_sdk_compat_js_namespaceObject.getLiteralValue)(shape.method) : void 0;
-            if ('tools/list' === method) return originalSetRequestHandler(requestSchema, (request, extra)=>handleListToolsRequest(server, handler, request, extra));
-            return originalSetRequestHandler(requestSchema, handler);
-        };
-    } catch (error) {
-        (0, external_logger_js_namespaceObject.log)(`Warning: Failed to override list tools handler - ${error}`);
+function patchRequestHandlers(server, patches) {
+    for (const [handlerName, patch] of Object.entries(patches)){
+        const originalHandler = server._requestHandlers.get(handlerName);
+        if (originalHandler) server._requestHandlers.set(handlerName, (request, extra)=>patch(server, originalHandler, request, extra));
     }
+    const originalSetRequestHandler = server.setRequestHandler.bind(server);
+    server.setRequestHandler = (requestSchema, originalHandler)=>{
+        const shape = (0, external_mcp_sdk_compat_js_namespaceObject.getObjectShape)(requestSchema);
+        const handlerName = shape?.method ? (0, external_mcp_sdk_compat_js_namespaceObject.getLiteralValue)(shape.method) : void 0;
+        const patch = 'string' == typeof handlerName ? patches[handlerName] : void 0;
+        if (!patch) return originalSetRequestHandler(requestSchema, originalHandler);
+        return originalSetRequestHandler(requestSchema, (request, extra)=>patch(server, originalHandler, request, extra));
+    };
 }
 async function handleListToolsRequest(server, originalListToolsHandler, request, extra) {
     const data = (0, external_internal_js_namespaceObject.getServerTrackingData)(server);
@@ -222,43 +217,41 @@ function cacheToolCategories(cache, tools) {
         if (category) cache.set(tool.name, category);
     }
 }
-function instrumentInitializeHandler(server) {
-    const originalInitializeHandler = server._requestHandlers.get('initialize');
-    if (!originalInitializeHandler) return;
-    server.setRequestHandler(types_js_namespaceObject.InitializeRequestSchema, async (request, extra)=>{
-        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.');
-            return await originalInitializeHandler(request, extra);
-        }
-        const sessionId = (0, external_session_js_namespaceObject.getServerSessionId)(server, extra);
-        await (0, external_internal_js_namespaceObject.handleIdentify)(server, data, sessionId, request, extra);
-        const event = {
-            sessionId,
-            resourceName: request.params?.name || 'Unknown Tool Name',
-            eventType: external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpInitialize,
-            parameters: (0, external_mcp_payloads_js_namespaceObject.buildCapturedMcpParameters)(request),
-            timestamp: new Date()
-        };
-        await (0, external_tracing_helpers_js_namespaceObject.applyResolvedMetadata)(event, data, request, extra);
-        const result = await originalInitializeHandler(request, extra);
-        event.response = result;
-        (0, external_capture_js_namespaceObject.captureEvent)(server, event);
-        return result;
-    });
+async function handleInitializeRequest(server, originalInitializeHandler, request, extra) {
+    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.');
+        return await originalInitializeHandler(request, extra);
+    }
+    const sessionId = (0, external_session_js_namespaceObject.getServerSessionId)(server, extra);
+    await (0, external_internal_js_namespaceObject.handleIdentify)(server, data, sessionId, request, extra);
+    const event = {
+        sessionId,
+        resourceName: request.params?.name || 'Unknown Tool Name',
+        eventType: external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpInitialize,
+        parameters: (0, external_mcp_payloads_js_namespaceObject.buildCapturedMcpParameters)(request),
+        timestamp: new Date()
+    };
+    await (0, external_tracing_helpers_js_namespaceObject.applyResolvedMetadata)(event, data, request, extra);
+    const result = await originalInitializeHandler(request, extra);
+    event.response = result;
+    (0, external_capture_js_namespaceObject.captureEvent)(server, event);
+    return result;
 }
 exports.cacheToolCategories = __webpack_exports__.cacheToolCategories;
 exports.cacheToolDescriptions = __webpack_exports__.cacheToolDescriptions;
 exports.captureToolCall = __webpack_exports__.captureToolCall;
-exports.instrumentInitializeHandler = __webpack_exports__.instrumentInitializeHandler;
-exports.instrumentToolsListHandler = __webpack_exports__.instrumentToolsListHandler;
+exports.handleInitializeRequest = __webpack_exports__.handleInitializeRequest;
+exports.handleListToolsRequest = __webpack_exports__.handleListToolsRequest;
+exports.patchRequestHandlers = __webpack_exports__.patchRequestHandlers;
 exports.readToolMetaCategory = __webpack_exports__.readToolMetaCategory;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "cacheToolCategories",
     "cacheToolDescriptions",
     "captureToolCall",
-    "instrumentInitializeHandler",
-    "instrumentToolsListHandler",
+    "handleInitializeRequest",
+    "handleListToolsRequest",
+    "patchRequestHandlers",
     "readToolMetaCategory"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {

package/dist/extensions/instrumentation.mjs

@@ -1,4 +1,3 @@
-import { InitializeRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { addContextParameterToTools, getContextDescription, isContextEnabled } from "./context-parameters.mjs";
 import { addConversationIdToTools, canInjectConversationIdPromptBack, cloneRequestWithoutConversationId, injectConversationIdPromptBack, resolveConversationId } from "./conversation-id.mjs";
 import { captureEvent } from "./capture.mjs";
@@ -86,24 +85,19 @@ function publishFailedToolEvent(server, event, error, startTime, conversation) {
         log(`Warning: PostHog MCP analytics failed to publish failed tool event - ${publishError}`);
     }
 }
-const listToolsTracingSetup = new WeakMap();
-function instrumentToolsListHandler(server) {
-    if (!server._capabilities?.tools) return;
-    if (listToolsTracingSetup.get(server)) return;
-    listToolsTracingSetup.set(server, true);
-    try {
-        const existingHandler = server._requestHandlers.get('tools/list');
-        if (existingHandler) server._requestHandlers.set('tools/list', (request, extra)=>handleListToolsRequest(server, existingHandler, request, extra));
-        const originalSetRequestHandler = server.setRequestHandler.bind(server);
-        server.setRequestHandler = (requestSchema, handler)=>{
-            const shape = getObjectShape(requestSchema);
-            const method = shape?.method ? getLiteralValue(shape.method) : void 0;
-            if ('tools/list' === method) return originalSetRequestHandler(requestSchema, (request, extra)=>handleListToolsRequest(server, handler, request, extra));
-            return originalSetRequestHandler(requestSchema, handler);
-        };
-    } catch (error) {
-        log(`Warning: Failed to override list tools handler - ${error}`);
+function patchRequestHandlers(server, patches) {
+    for (const [handlerName, patch] of Object.entries(patches)){
+        const originalHandler = server._requestHandlers.get(handlerName);
+        if (originalHandler) server._requestHandlers.set(handlerName, (request, extra)=>patch(server, originalHandler, request, extra));
     }
+    const originalSetRequestHandler = server.setRequestHandler.bind(server);
+    server.setRequestHandler = (requestSchema, originalHandler)=>{
+        const shape = getObjectShape(requestSchema);
+        const handlerName = shape?.method ? getLiteralValue(shape.method) : void 0;
+        const patch = 'string' == typeof handlerName ? patches[handlerName] : void 0;
+        if (!patch) return originalSetRequestHandler(requestSchema, originalHandler);
+        return originalSetRequestHandler(requestSchema, (request, extra)=>patch(server, originalHandler, request, extra));
+    };
 }
 async function handleListToolsRequest(server, originalListToolsHandler, request, extra) {
     const data = getServerTrackingData(server);
@@ -189,29 +183,25 @@ function cacheToolCategories(cache, tools) {
         if (category) cache.set(tool.name, category);
     }
 }
-function instrumentInitializeHandler(server) {
-    const originalInitializeHandler = server._requestHandlers.get('initialize');
-    if (!originalInitializeHandler) return;
-    server.setRequestHandler(InitializeRequestSchema, async (request, extra)=>{
-        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.');
-            return await originalInitializeHandler(request, extra);
-        }
-        const sessionId = getServerSessionId(server, extra);
-        await handleIdentify(server, data, sessionId, request, extra);
-        const event = {
-            sessionId,
-            resourceName: request.params?.name || 'Unknown Tool Name',
-            eventType: MCPAnalyticsEventType.mcpInitialize,
-            parameters: buildCapturedMcpParameters(request),
-            timestamp: new Date()
-        };
-        await applyResolvedMetadata(event, data, request, extra);
-        const result = await originalInitializeHandler(request, extra);
-        event.response = result;
-        captureEvent(server, event);
-        return result;
-    });
+async function handleInitializeRequest(server, originalInitializeHandler, request, extra) {
+    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.');
+        return await originalInitializeHandler(request, extra);
+    }
+    const sessionId = getServerSessionId(server, extra);
+    await handleIdentify(server, data, sessionId, request, extra);
+    const event = {
+        sessionId,
+        resourceName: request.params?.name || 'Unknown Tool Name',
+        eventType: MCPAnalyticsEventType.mcpInitialize,
+        parameters: buildCapturedMcpParameters(request),
+        timestamp: new Date()
+    };
+    await applyResolvedMetadata(event, data, request, extra);
+    const result = await originalInitializeHandler(request, extra);
+    event.response = result;
+    captureEvent(server, event);
+    return result;
 }
-export { cacheToolCategories, cacheToolDescriptions, captureToolCall, instrumentInitializeHandler, instrumentToolsListHandler, readToolMetaCategory };
+export { cacheToolCategories, cacheToolDescriptions, captureToolCall, handleInitializeRequest, handleListToolsRequest, patchRequestHandlers, readToolMetaCategory };

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

@@ -1 +1 @@
-{"version":3,"file":"sink.d.ts","sourceRoot":"","sources":["../../src/extensions/sink.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAG3C,OAAO,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAE7D,OAAO,EAAE,KAAK,mBAAmB,EAA6B,MAAM,kBAAkB,CAAA;AAKtF,yEAAyE;AACzE,MAAM,WAAW,iBAAiB;IAChC,0BAA0B,EAAE,OAAO,CAAA;IACnC,kFAAkF;IAClF,UAAU,CAAC,EAAE,YAAY,CAAA;CAC1B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,mBAAmB,EAAE,CAAA;CAAE,GAAG,IAAI,CAAC,CA2BnE;AA4BD;;;;;;;;GAQG;AACH,qBAAa,YAAY;IACX,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,OAAO;IAE7C;;;;OAIG;IACG,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;CA0B1E"}
+{"version":3,"file":"sink.d.ts","sourceRoot":"","sources":["../../src/extensions/sink.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAG3C,OAAO,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAE7D,OAAO,EAAE,KAAK,mBAAmB,EAA6B,MAAM,kBAAkB,CAAA;AAKtF,yEAAyE;AACzE,MAAM,WAAW,iBAAiB;IAChC,0BAA0B,EAAE,OAAO,CAAA;IACnC,kFAAkF;IAClF,UAAU,CAAC,EAAE,YAAY,CAAA;CAC1B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,mBAAmB,EAAE,CAAA;CAAE,GAAG,IAAI,CAAC,CA2BnE;AA4BD;;;;;;;;GAQG;AACH,qBAAa,YAAY;IACX,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,OAAO;IAE7C;;;;OAIG;IACG,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;CAmC1E"}

package/dist/extensions/sink.js

@@ -78,13 +78,19 @@ class McpEventSink {
         if (!result) return;
         const { event: fullEvent, captures } = result;
         try {
-            for (const captureEvent of captures)this.posthog.capture({
-                distinctId: captureEvent.distinct_id,
-                event: captureEvent.event,
-                properties: captureEvent.properties,
-                timestamp: new Date(captureEvent.timestamp),
-                uuid: (0, core_namespaceObject.uuidv7)()
-            });
+            for (const captureEvent of captures){
+                const groups = captureEvent.properties.$groups;
+                this.posthog.capture({
+                    distinctId: captureEvent.distinct_id,
+                    event: captureEvent.event,
+                    properties: captureEvent.properties,
+                    ...groups ? {
+                        groups
+                    } : {},
+                    timestamp: new Date(captureEvent.timestamp),
+                    uuid: (0, core_namespaceObject.uuidv7)()
+                });
+            }
             (0, external_logger_js_namespaceObject.log)(`Captured PostHog event ${fullEvent.id} | ${fullEvent.eventType} | ${fullEvent.duration} ms | ${fullEvent.identifyActorGivenId || 'anonymous'}`);
         } catch (err) {
             (0, external_logger_js_namespaceObject.log)(`Failed to capture PostHog event ${fullEvent.id}: ${err}`);

package/dist/extensions/sink.mjs

@@ -49,13 +49,19 @@ class McpEventSink {
         if (!result) return;
         const { event: fullEvent, captures } = result;
         try {
-            for (const captureEvent of captures)this.posthog.capture({
-                distinctId: captureEvent.distinct_id,
-                event: captureEvent.event,
-                properties: captureEvent.properties,
-                timestamp: new Date(captureEvent.timestamp),
-                uuid: uuidv7()
-            });
+            for (const captureEvent of captures){
+                const groups = captureEvent.properties.$groups;
+                this.posthog.capture({
+                    distinctId: captureEvent.distinct_id,
+                    event: captureEvent.event,
+                    properties: captureEvent.properties,
+                    ...groups ? {
+                        groups
+                    } : {},
+                    timestamp: new Date(captureEvent.timestamp),
+                    uuid: uuidv7()
+                });
+            }
             log(`Captured PostHog event ${fullEvent.id} | ${fullEvent.eventType} | ${fullEvent.duration} ms | ${fullEvent.identifyActorGivenId || 'anonymous'}`);
         } catch (err) {
             log(`Failed to capture PostHog event ${fullEvent.id}: ${err}`);

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "0.4.2";
+export declare const version = "0.4.4";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -26,7 +26,7 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     version: ()=>version
 });
-const version = '0.4.2';
+const version = '0.4.4';
 exports.version = __webpack_exports__.version;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "version"

package/dist/version.mjs

@@ -1,2 +1,2 @@
-const version = '0.4.2';
+const version = '0.4.4';
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/mcp",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "bugs": {
     "url": "https://github.com/PostHog/posthog-js/issues"
   },
@@ -28,7 +28,7 @@
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "dependencies": {
-    "@posthog/core": "^1.37.3"
+    "@posthog/core": "^1.38.0"
   },
   "devDependencies": {
     "@babel/preset-env": "^7.27.1",
@@ -39,8 +39,8 @@
     "@types/node": "^20.0.0",
     "jest": "29.7.0",
     "zod": "^3.25.0",
-    "@posthog-tooling/tsconfig-base": "1.1.1",
-    "posthog-node": "^5.38.5"
+    "posthog-node": "^5.38.6",
+    "@posthog-tooling/tsconfig-base": "1.1.1"
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": ">=1.26.0",

package/src/extensions/instrument-highlevel.ts

@@ -8,11 +8,12 @@ import { stripConversationId } from './conversation-id'
 import { MCPAnalyticsEventType } from './event-types'
 import { getServerTrackingData } from './internal'
 import { log } from './logger'
-import { createWrappedTool, getLiteralValue, getObjectShape, getToolFunction, hasToolFunction } from './mcp-sdk-compat'
+import { createWrappedTool, getToolFunction, hasToolFunction } from './mcp-sdk-compat'
 import { handleReportMissing, resolveMissingCapabilityToolName } from './tools'
 import {
-  instrumentInitializeHandler,
-  instrumentToolsListHandler,
+  handleInitializeRequest,
+  handleListToolsRequest,
+  patchRequestHandlers,
   captureToolCall,
   readToolMetaCategory,
 } from './instrumentation'
@@ -72,8 +73,6 @@ function setupListenerToRegisteredTools(server: HighLevelMCPServerLike): void {
 
             const nextValue = addTracingToToolCallbackInternal(value, property, server)
 
-            instrumentToolsListHandler(server.server as MCPServerLike)
-
             if (typeof nextValue.update === 'function') {
               const originalUpdate = nextValue.update
               nextValue.update = function (...updateArgs: unknown[]) {
@@ -130,7 +129,7 @@ function setupListenerToRegisteredTools(server: HighLevelMCPServerLike): void {
  * (the high-level SDK turns thrown errors into `isError` results otherwise).
  *
  * This is purely the tool-facing concern; event capture lives in
- * {@link captureToolCall} via {@link handleWrappedToolsCall}.
+ * {@link captureToolCall} via {@link handleToolCallRequest}.
  */
 function addTracingToToolCallbackInternal(
   tool: RegisteredTool,
@@ -202,38 +201,9 @@ function addTracingToToolCallbackInternal(
   return wrappedTool
 }
 
-function setupToolsCallHandlerWrapping(server: HighLevelMCPServerLike): void {
-  const lowLevelServer = server.server as MCPServerLike
-
-  const existingHandler = lowLevelServer._requestHandlers.get('tools/call')
-  if (existingHandler) {
-    const wrappedHandler = createToolsCallWrapper(existingHandler, lowLevelServer)
-    lowLevelServer._requestHandlers.set('tools/call', wrappedHandler)
-  }
-
-  const originalSetRequestHandler = lowLevelServer.setRequestHandler.bind(lowLevelServer)
-
-  lowLevelServer.setRequestHandler = ((requestSchema: unknown, handler: MCPRequestHandler) => {
-    const shape = getObjectShape(requestSchema)
-    const method = shape?.method ? getLiteralValue(shape.method) : undefined
-
-    if (method === 'tools/call') {
-      const wrappedHandler = createToolsCallWrapper(handler, lowLevelServer)
-      return originalSetRequestHandler(requestSchema, wrappedHandler)
-    }
-
-    return originalSetRequestHandler(requestSchema, handler)
-  }) as MCPServerLike['setRequestHandler']
-}
-
-function createToolsCallWrapper(originalHandler: MCPRequestHandler, server: MCPServerLike): MCPRequestHandler {
-  return async (request: MCPRequest, extra: MCPRequestExtra) =>
-    await handleWrappedToolsCall(originalHandler, server, request, extra)
-}
-
-async function handleWrappedToolsCall(
-  originalHandler: MCPRequestHandler,
+async function handleToolCallRequest(
   server: MCPServerLike,
+  originalCallToolHandler: MCPRequestHandler,
   request: MCPRequest,
   extra: MCPRequestExtra
 ): Promise<unknown> {
@@ -242,7 +212,7 @@ async function handleWrappedToolsCall(
     log(
       '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 originalHandler(request, extra)
+    return await originalCallToolHandler(request, extra)
   }
 
   if (request.params?.name === resolveMissingCapabilityToolName(data.options)) {
@@ -267,7 +237,7 @@ async function handleWrappedToolsCall(
     data,
     request,
     extra,
-    execute: () => originalHandler(request, extra),
+    execute: () => originalCallToolHandler(request, extra),
     takeCapturedError: () => {
       const captured = extra?.__mcp_analytics_error
       if (extra) {
@@ -280,11 +250,16 @@ async function handleWrappedToolsCall(
 
 export function instrumentHighLevelServer(server: HighLevelMCPServerLike): void {
   try {
-    const mcpAnalyticsData = getServerTrackingData(server.server)
-
-    setupToolsCallHandlerWrapping(server)
-
-    instrumentInitializeHandler(server.server)
+    const lowLevelServer = server.server
+    const mcpAnalyticsData = getServerTrackingData(lowLevelServer)
+
+    // Patch already existing handlers, and patch setRequestHandler to capture dynamically created handlers.
+    const handlers = {
+      initialize: handleInitializeRequest,
+      'tools/list': handleListToolsRequest,
+      'tools/call': handleToolCallRequest,
+    }
+    patchRequestHandlers(lowLevelServer, handlers)
 
     server._registeredTools = addTracingToToolRegistry(server._registeredTools, server)
 
@@ -293,8 +268,6 @@ export function instrumentHighLevelServer(server: HighLevelMCPServerLike): void
       seedToolCategoriesFromRegistry(mcpAnalyticsData.toolCategories, server._registeredTools)
     }
 
-    instrumentToolsListHandler(server.server)
-
     setupListenerToRegisteredTools(server)
   } catch (error) {
     log(`Warning: Failed to setup tool call instrumentation - ${error}`)

package/src/extensions/instrument-lowlevel.ts

@@ -8,7 +8,12 @@ import { MCPAnalyticsEventType } from './event-types'
 import { getServerTrackingData } from './internal'
 import { log } from './logger'
 import { handleReportMissing, resolveMissingCapabilityToolName } from './tools'
-import { instrumentInitializeHandler, instrumentToolsListHandler, captureToolCall } from './instrumentation'
+import {
+  handleInitializeRequest,
+  handleListToolsRequest,
+  patchRequestHandlers,
+  captureToolCall,
+} from './instrumentation'
 import { getContextArgument } from './tracing-helpers'
 
 type MCPRequestHandler = NonNullable<
@@ -24,8 +29,12 @@ type MCPRequestExtra = Parameters<MCPRequestHandler>[1]
  */
 export function instrumentLowLevelServer(server: MCPServerLike): void {
   try {
-    instrumentInitializeHandler(server)
-    instrumentToolsListHandler(server)
+    // Patch already existing handlers, and patch setRequestHandler to capture dynamically created handlers.
+    const handlers = {
+      initialize: handleInitializeRequest,
+      'tools/list': handleListToolsRequest,
+    }
+    patchRequestHandlers(server, handlers)
 
     const originalCallToolHandler = server._requestHandlers.get('tools/call')
     server.setRequestHandler(

package/src/extensions/instrumentation.ts

@@ -2,7 +2,7 @@
 // Copyright (c) 2025 MCPcat
 // Licensed under the MIT License: https://github.com/MCPCat/mcpcat-typescript-sdk/blob/main/LICENSE
 
-import { InitializeRequestSchema, type ListToolsResult } from '@modelcontextprotocol/sdk/types.js'
+import type { ListToolsResult } from '@modelcontextprotocol/sdk/types.js'
 import type { CompatibleRequestHandlerExtra, MCPAnalyticsData, MCPRequestLike, MCPServerLike, McpEvent } from '../types'
 import { addContextParameterToTools, getContextDescription, isContextEnabled } from './context-parameters'
 import {
@@ -228,63 +228,53 @@ function publishFailedToolEvent(
 
 // --- tools/list -----------------------------------------------------------
 
-type MCPServerWithCapabilities = MCPServerLike & {
-  _capabilities?: {
-    tools?: unknown
-  }
-}
-
-const listToolsTracingSetup = new WeakMap<MCPServerLike, boolean>()
+/**
+ * A method's patch: runs the original handler and captures analytics. `server`
+ * and `originalHandler` are bound by {@link patchRequestHandlers}; the SDK
+ * supplies `request` and `extra` per call.
+ */
+export type HandlerPatch = (
+  server: MCPServerLike,
+  originalHandler: MCPRequestHandler,
+  request: MCPRequestLike,
+  extra: CompatibleRequestHandlerExtra | undefined
+) => Promise<unknown>
 
 /**
- * Wraps the server's `tools/list` handler so each listing is captured and the
- * SDK-managed tools (context parameter, conversation id, `get_more_tools`) are
- * injected. Idempotent per server. Works for both low-level and high-level
- * servers — the high-level wrapper passes its underlying `server`.
- *
- * The handler can reach us two ways, and we cover both:
- *  1. It already exists when instrument() runs (tools registered first) — wrap
- *     the entry in `_requestHandlers` directly.
- *  2. It's registered after instrument() (e.g. `@rekog/mcp-nest` registers it at
- *     the low level once it gets the server) — intercept `setRequestHandler` and
- *     wrap the handler as it lands, mirroring how `tools/call` already works.
+ * 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.
  */
-export function instrumentToolsListHandler(server: MCPServerLike): void {
-  if (!(server as MCPServerWithCapabilities)._capabilities?.tools) {
-    return
-  }
-  if (listToolsTracingSetup.get(server)) {
-    return
+export function patchRequestHandlers(server: MCPServerLike, patches: Record<string, HandlerPatch>): void {
+  // Monkey patch existing handlers.
+  for (const [handlerName, patch] of Object.entries(patches)) {
+    const originalHandler = server._requestHandlers.get(handlerName)
+    if (originalHandler) {
+      server._requestHandlers.set(handlerName, (request, extra) => patch(server, originalHandler, request, extra))
+    }
   }
-  listToolsTracingSetup.set(server, true)
 
-  try {
-    // A handler already registered before instrument() — wrap it in place.
-    const existingHandler = server._requestHandlers.get('tools/list')
-    if (existingHandler) {
-      server._requestHandlers.set('tools/list', (request, extra) =>
-        handleListToolsRequest(server, existingHandler, request, extra)
-      )
+  // Monkey patch dynamically added handlers (registered after instrument()).
+  const originalSetRequestHandler = server.setRequestHandler.bind(server)
+  server.setRequestHandler = ((requestSchema: unknown, originalHandler: MCPRequestHandler) => {
+    const shape = getObjectShape(requestSchema)
+    const handlerName = shape?.method ? getLiteralValue(shape.method) : undefined
+    const patch = typeof handlerName === 'string' ? patches[handlerName] : undefined
+    if (!patch) {
+      return originalSetRequestHandler(requestSchema, originalHandler)
     }
 
-    // A handler registered after instrument() — intercept the registration.
-    const originalSetRequestHandler = server.setRequestHandler.bind(server)
-    server.setRequestHandler = ((requestSchema: unknown, handler: MCPRequestHandler) => {
-      const shape = getObjectShape(requestSchema)
-      const method = shape?.method ? getLiteralValue(shape.method) : undefined
-      if (method === 'tools/list') {
-        return originalSetRequestHandler(requestSchema, (request, extra) =>
-          handleListToolsRequest(server, handler, request, extra)
-        )
-      }
-      return originalSetRequestHandler(requestSchema, handler)
-    }) as MCPServerLike['setRequestHandler']
-  } catch (error) {
-    log(`Warning: Failed to override list tools handler - ${error}`)
-  }
+    return originalSetRequestHandler(requestSchema, (request, extra) => patch(server, originalHandler, request, extra))
+  }) as MCPServerLike['setRequestHandler']
 }
 
-async function handleListToolsRequest(
+/**
+ * Captures each `tools/list` and injects the SDK-managed tools (context
+ * parameter, conversation id, `get_more_tools`) into the returned list.
+ */
+export async function handleListToolsRequest(
   server: MCPServerLike,
   originalListToolsHandler: MCPRequestHandler,
   request: MCPRequestLike,
@@ -421,40 +411,38 @@ export function cacheToolCategories(cache: Map<string, string>, tools: ListTools
 // --- initialize -----------------------------------------------------------
 
 /**
- * Wraps the server's `initialize` handler so the connection handshake is
- * captured (and identity resolved) before the original handler runs.
+ * Captures the connection handshake (and resolves identity) on `initialize`
+ * before the original handler runs.
  */
-export function instrumentInitializeHandler(server: MCPServerLike): void {
-  const originalInitializeHandler = server._requestHandlers.get('initialize')
-  if (!originalInitializeHandler) {
-    return
+export async function handleInitializeRequest(
+  server: MCPServerLike,
+  originalInitializeHandler: MCPRequestHandler,
+  request: MCPRequestLike,
+  extra?: CompatibleRequestHandlerExtra
+): Promise<unknown> {
+  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.'
+    )
+    return await originalInitializeHandler(request, extra)
   }
 
-  server.setRequestHandler(InitializeRequestSchema, async (request, extra) => {
-    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.'
-      )
-      return await originalInitializeHandler(request, extra)
-    }
+  const sessionId = getServerSessionId(server, extra)
+  await handleIdentify(server, data, sessionId, request, extra)
 
-    const sessionId = getServerSessionId(server, extra)
-    await handleIdentify(server, data, sessionId, request, extra)
-
-    const event: McpEvent = {
-      sessionId,
-      resourceName: request.params?.name || 'Unknown Tool Name',
-      eventType: MCPAnalyticsEventType.mcpInitialize,
-      parameters: buildCapturedMcpParameters(request),
-      timestamp: new Date(),
-    }
+  const event: McpEvent = {
+    sessionId,
+    resourceName: request.params?.name || 'Unknown Tool Name',
+    eventType: MCPAnalyticsEventType.mcpInitialize,
+    parameters: buildCapturedMcpParameters(request),
+    timestamp: new Date(),
+  }
 
-    await applyResolvedMetadata(event, data, request, extra)
+  await applyResolvedMetadata(event, data, request, extra)
 
-    const result = await originalInitializeHandler(request, extra)
-    event.response = result
-    captureEvent(server, event)
-    return result
-  })
+  const result = await originalInitializeHandler(request, extra)
+  event.response = result
+  captureEvent(server, event)
+  return result
 }

package/src/extensions/sink.ts

@@ -114,10 +114,19 @@ export class McpEventSink {
     const { event: fullEvent, captures } = result
     try {
       for (const captureEvent of captures) {
+        // `$groups` is written into `properties` by `buildPostHogCaptureEvents`,
+        // but posthog-node's `prepareEventMessage` overwrites the outgoing
+        // `$groups` property with the top-level `groups` field
+        // (`$groups: eventMessage.groups || groups`). Without passing `groups`
+        // here the group association would be silently dropped. See
+        // https://github.com/PostHog/posthog-js/issues/3888.
+        const groups = captureEvent.properties.$groups as Record<string, string> | undefined
+
         this.posthog.capture({
           distinctId: captureEvent.distinct_id,
           event: captureEvent.event,
           properties: captureEvent.properties,
+          ...(groups ? { groups } : {}),
           timestamp: new Date(captureEvent.timestamp),
           uuid: uuidv7(),
         })

package/src/version.ts

@@ -1 +1 @@
-export const version = '0.4.2'
+export const version = '0.4.4'