@posthog/mcp 0.4.1 → 0.4.3

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,12 +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`.
+ * 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
@@ -58,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,EAGL,KAAK,eAAe,EACrB,MAAM,oCAAoC,CAAA;AAC3C,OAAO,KAAK,EAAE,6BAA6B,EAAE,gBAAgB,EAAE,cAAc,EAAE,aAAa,EAAY,MAAM,UAAU,CAAA;AAWxH,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAoBrD;;;;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;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAsBtE;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");
@@ -41,6 +41,7 @@ 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");
 const external_tools_js_namespaceObject = require("./tools.js");
 const external_tracing_helpers_js_namespaceObject = require("./tracing-helpers.js");
@@ -118,18 +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;
-    const originalListToolsHandler = server._requestHandlers.get('tools/list');
-    if (!originalListToolsHandler) return;
-    try {
-        server.setRequestHandler(types_js_namespaceObject.ListToolsRequestSchema, async (request, extra)=>await handleListToolsRequest(server, originalListToolsHandler, request, extra));
-        listToolsTracingSetup.set(server, true);
-    } 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);
@@ -215,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, ListToolsRequestSchema } 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";
@@ -8,6 +7,7 @@ import { resolveToolCallIntent, setEventIntent, setExplicitContextIntent } from
 import { getServerTrackingData, handleIdentify } from "./internal.mjs";
 import { log } from "./logger.mjs";
 import { buildCapturedMcpParameters } from "./mcp-payloads.mjs";
+import { getLiteralValue, getObjectShape } from "./mcp-sdk-compat.mjs";
 import { getServerSessionId } from "./session.mjs";
 import { getReportMissingToolDescriptor, resolveMissingCapabilityToolName } from "./tools.mjs";
 import { applyResolvedMetadata, isToolResultError } from "./tracing-helpers.mjs";
@@ -85,18 +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;
-    const originalListToolsHandler = server._requestHandlers.get('tools/list');
-    if (!originalListToolsHandler) return;
-    try {
-        server.setRequestHandler(ListToolsRequestSchema, async (request, extra)=>await handleListToolsRequest(server, originalListToolsHandler, request, extra));
-        listToolsTracingSetup.set(server, true);
-    } 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);
@@ -182,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/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "0.4.1";
+export declare const version = "0.4.3";
 //# 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.1';
+const version = '0.4.3';
 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.1';
+const version = '0.4.3';
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/mcp",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "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.36.0"
+    "@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.2"
+    "posthog-node": "^5.38.5",
+    "@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,11 +2,7 @@
 // Copyright (c) 2025 MCPcat
 // Licensed under the MIT License: https://github.com/MCPCat/mcpcat-typescript-sdk/blob/main/LICENSE
 
-import {
-  InitializeRequestSchema,
-  ListToolsRequestSchema,
-  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 {
@@ -24,6 +20,7 @@ import { resolveToolCallIntent, setEventIntent, setExplicitContextIntent } from
 import { getServerTrackingData, handleIdentify } from './internal'
 import { log } from './logger'
 import { buildCapturedMcpParameters } from './mcp-payloads'
+import { getLiteralValue, getObjectShape } from './mcp-sdk-compat'
 import { getServerSessionId } from './session'
 import { getReportMissingToolDescriptor, resolveMissingCapabilityToolName } from './tools'
 import { applyResolvedMetadata, isToolResultError } from './tracing-helpers'
@@ -231,45 +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`.
+ * 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))
+    }
   }
 
-  const originalListToolsHandler = server._requestHandlers.get('tools/list')
-  if (!originalListToolsHandler) {
-    return
-  }
+  // 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)
+    }
 
-  try {
-    server.setRequestHandler(
-      ListToolsRequestSchema,
-      async (request, extra) => await handleListToolsRequest(server, originalListToolsHandler, request, extra)
-    )
-    listToolsTracingSetup.set(server, true)
-  } 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,
@@ -406,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/version.ts

@@ -1 +1 @@
-export const version = '0.4.1'
+export const version = '0.4.3'