@posthog/mcp 0.0.8 → 0.1.16

package/dist/extensions/instrument-highlevel.js

@@ -0,0 +1,229 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    instrumentHighLevelServer: ()=>instrumentHighLevelServer
+});
+const external_conversation_id_js_namespaceObject = require("./conversation-id.js");
+const external_event_types_js_namespaceObject = require("./event-types.js");
+const external_internal_js_namespaceObject = require("./internal.js");
+const external_logger_js_namespaceObject = require("./logger.js");
+const external_mcp_sdk_compat_js_namespaceObject = require("./mcp-sdk-compat.js");
+const external_tools_js_namespaceObject = require("./tools.js");
+const external_instrumentation_js_namespaceObject = require("./instrumentation.js");
+const external_tracing_helpers_js_namespaceObject = require("./tracing-helpers.js");
+const wrappedCallbacks = new WeakMap();
+const MCP_ANALYTICS_PROCESSED = Symbol('__posthog_mcp_analytics_processed__');
+function isCallbackUpdate(value) {
+    return !!value && 'object' == typeof value && 'callback' in value && 'function' == typeof value.callback;
+}
+function addTracingToToolRegistry(tools, server) {
+    return Object.fromEntries(Object.entries(tools).map(([name, tool])=>[
+            name,
+            addTracingToToolCallbackInternal(tool, name, server)
+        ]));
+}
+function setupListenerToRegisteredTools(server) {
+    try {
+        const data = (0, external_internal_js_namespaceObject.getServerTrackingData)(server.server);
+        if (!data) return void (0, external_logger_js_namespaceObject.log)('Warning: Cannot setup listener - no tracking data found');
+        const handler = {
+            set (target, property, value) {
+                try {
+                    if ('string' == typeof property && value && 'object' == typeof value && (0, external_mcp_sdk_compat_js_namespaceObject.hasToolFunction)(value)) {
+                        if ('string' == typeof value.description) data.toolDescriptions.set(property, value.description);
+                        if (value[MCP_ANALYTICS_PROCESSED]) {
+                            (0, external_logger_js_namespaceObject.log)(`Tool ${String(property)} already processed, skipping proxy wrapping`);
+                            return Reflect.set(target, property, value);
+                        }
+                        if (wrappedCallbacks.has((0, external_mcp_sdk_compat_js_namespaceObject.getToolFunction)(value))) {
+                            (0, external_logger_js_namespaceObject.log)(`Tool ${String(property)} callback already wrapped, skipping proxy wrapping`);
+                            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) {
+                                if (updateArgs[0]) {
+                                    const updateObj = updateArgs[0];
+                                    if (isCallbackUpdate(updateObj)) {
+                                        const wrappedTool = addTracingToToolCallbackInternal({
+                                            callback: updateObj.callback
+                                        }, property, server);
+                                        updateObj.callback = (0, external_mcp_sdk_compat_js_namespaceObject.getToolFunction)(wrappedTool);
+                                    }
+                                }
+                                return originalUpdate.apply(this, updateArgs);
+                            };
+                        }
+                        return Reflect.set(target, property, nextValue);
+                    }
+                    return Reflect.set(target, property, value);
+                } catch (error) {
+                    (0, external_logger_js_namespaceObject.log)(`Warning: Error in proxy set handler for tool ${String(property)} - ${error}`);
+                    return Reflect.set(target, property, value);
+                }
+            },
+            get (target, property) {
+                return Reflect.get(target, property);
+            },
+            deleteProperty (target, property) {
+                return Reflect.deleteProperty(target, property);
+            },
+            has (target, property) {
+                return Reflect.has(target, property);
+            }
+        };
+        const originalTools = server._registeredTools || {};
+        server._registeredTools = new Proxy(originalTools, handler);
+        (0, external_logger_js_namespaceObject.log)('Successfully set up listener for new tool registrations');
+    } catch (error) {
+        (0, external_logger_js_namespaceObject.log)(`Warning: Failed to setup listener for registered tools - ${error}`);
+    }
+}
+function addTracingToToolCallbackInternal(tool, toolName, _server) {
+    const originalCallback = (0, external_mcp_sdk_compat_js_namespaceObject.getToolFunction)(tool);
+    if (wrappedCallbacks.has(originalCallback)) {
+        (0, external_logger_js_namespaceObject.log)(`Tool ${toolName} callback already wrapped, skipping re-wrap`);
+        return tool;
+    }
+    if (tool[MCP_ANALYTICS_PROCESSED]) {
+        (0, external_logger_js_namespaceObject.log)(`Tool ${toolName} already processed, skipping re-wrap`);
+        return tool;
+    }
+    const wrappedCallback = async (...params)=>{
+        let args;
+        let extra;
+        if (2 === params.length) {
+            args = params[0];
+            extra = params[1];
+        } else {
+            args = void 0;
+            extra = params[0];
+        }
+        const removeContextFromArgs = (input)=>{
+            if (input && 'object' == typeof input && 'context' in input) {
+                const { context: _context, ...rest } = input;
+                return rest;
+            }
+            return input;
+        };
+        const cleanedArgs = toolName === external_tools_js_namespaceObject.GET_MORE_TOOLS_NAME ? args : (0, external_conversation_id_js_namespaceObject.stripConversationId)(removeContextFromArgs(args));
+        try {
+            if (void 0 === cleanedArgs) {
+                const handler = originalCallback;
+                return await handler(extra);
+            }
+            const handler = originalCallback;
+            return await handler(cleanedArgs, extra);
+        } catch (error) {
+            if (error instanceof Error) extra.__mcp_analytics_error = error;
+            throw error;
+        }
+    };
+    wrappedCallbacks.set(originalCallback, true);
+    wrappedCallbacks.set(wrappedCallback, true);
+    const wrappedTool = (0, external_mcp_sdk_compat_js_namespaceObject.createWrappedTool)(tool, wrappedCallback);
+    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) {
+    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);
+    }
+    if (request.params?.name === external_tools_js_namespaceObject.GET_MORE_TOOLS_NAME) {
+        const context = (0, external_tracing_helpers_js_namespaceObject.getContextArgument)(request) || '';
+        return await (0, external_instrumentation_js_namespaceObject.captureToolCall)({
+            server,
+            data,
+            request,
+            extra,
+            eventType: external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpMissingCapability,
+            explicitContextIntent: context,
+            execute: async ()=>(0, external_tools_js_namespaceObject.handleReportMissing)({
+                    context
+                })
+        });
+    }
+    return await (0, external_instrumentation_js_namespaceObject.captureToolCall)({
+        server,
+        data,
+        request,
+        extra,
+        execute: ()=>originalHandler(request, extra),
+        takeCapturedError: ()=>{
+            const captured = extra?.__mcp_analytics_error;
+            if (extra) extra.__mcp_analytics_error = void 0;
+            return captured;
+        }
+    });
+}
+function instrumentHighLevelServer(server) {
+    try {
+        const mcpAnalyticsData = (0, external_internal_js_namespaceObject.getServerTrackingData)(server.server);
+        setupToolsCallHandlerWrapping(server);
+        (0, external_instrumentation_js_namespaceObject.instrumentInitializeHandler)(server.server);
+        server._registeredTools = addTracingToToolRegistry(server._registeredTools, server);
+        if (mcpAnalyticsData) seedToolDescriptionsFromRegistry(mcpAnalyticsData.toolDescriptions, 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}`);
+    }
+}
+function seedToolDescriptionsFromRegistry(cache, tools) {
+    for (const [name, tool] of Object.entries(tools))if ('string' == typeof tool?.description) cache.set(name, tool.description);
+}
+exports.instrumentHighLevelServer = __webpack_exports__.instrumentHighLevelServer;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "instrumentHighLevelServer"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/instrument-highlevel.mjs

@@ -0,0 +1,195 @@
+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 { GET_MORE_TOOLS_NAME, handleReportMissing } from "./tools.mjs";
+import { captureToolCall, instrumentInitializeHandler, instrumentToolsListHandler } from "./instrumentation.mjs";
+import { getContextArgument } from "./tracing-helpers.mjs";
+const wrappedCallbacks = new WeakMap();
+const MCP_ANALYTICS_PROCESSED = Symbol('__posthog_mcp_analytics_processed__');
+function isCallbackUpdate(value) {
+    return !!value && 'object' == typeof value && 'callback' in value && 'function' == typeof value.callback;
+}
+function addTracingToToolRegistry(tools, server) {
+    return Object.fromEntries(Object.entries(tools).map(([name, tool])=>[
+            name,
+            addTracingToToolCallbackInternal(tool, name, server)
+        ]));
+}
+function setupListenerToRegisteredTools(server) {
+    try {
+        const data = getServerTrackingData(server.server);
+        if (!data) return void log('Warning: Cannot setup listener - no tracking data found');
+        const handler = {
+            set (target, property, value) {
+                try {
+                    if ('string' == typeof property && value && 'object' == typeof value && hasToolFunction(value)) {
+                        if ('string' == typeof value.description) data.toolDescriptions.set(property, value.description);
+                        if (value[MCP_ANALYTICS_PROCESSED]) {
+                            log(`Tool ${String(property)} already processed, skipping proxy wrapping`);
+                            return Reflect.set(target, property, value);
+                        }
+                        if (wrappedCallbacks.has(getToolFunction(value))) {
+                            log(`Tool ${String(property)} callback already wrapped, skipping proxy wrapping`);
+                            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) {
+                                if (updateArgs[0]) {
+                                    const updateObj = updateArgs[0];
+                                    if (isCallbackUpdate(updateObj)) {
+                                        const wrappedTool = addTracingToToolCallbackInternal({
+                                            callback: updateObj.callback
+                                        }, property, server);
+                                        updateObj.callback = getToolFunction(wrappedTool);
+                                    }
+                                }
+                                return originalUpdate.apply(this, updateArgs);
+                            };
+                        }
+                        return Reflect.set(target, property, nextValue);
+                    }
+                    return Reflect.set(target, property, value);
+                } catch (error) {
+                    log(`Warning: Error in proxy set handler for tool ${String(property)} - ${error}`);
+                    return Reflect.set(target, property, value);
+                }
+            },
+            get (target, property) {
+                return Reflect.get(target, property);
+            },
+            deleteProperty (target, property) {
+                return Reflect.deleteProperty(target, property);
+            },
+            has (target, property) {
+                return Reflect.has(target, property);
+            }
+        };
+        const originalTools = server._registeredTools || {};
+        server._registeredTools = new Proxy(originalTools, handler);
+        log('Successfully set up listener for new tool registrations');
+    } catch (error) {
+        log(`Warning: Failed to setup listener for registered tools - ${error}`);
+    }
+}
+function addTracingToToolCallbackInternal(tool, toolName, _server) {
+    const originalCallback = getToolFunction(tool);
+    if (wrappedCallbacks.has(originalCallback)) {
+        log(`Tool ${toolName} callback already wrapped, skipping re-wrap`);
+        return tool;
+    }
+    if (tool[MCP_ANALYTICS_PROCESSED]) {
+        log(`Tool ${toolName} already processed, skipping re-wrap`);
+        return tool;
+    }
+    const wrappedCallback = async (...params)=>{
+        let args;
+        let extra;
+        if (2 === params.length) {
+            args = params[0];
+            extra = params[1];
+        } else {
+            args = void 0;
+            extra = params[0];
+        }
+        const removeContextFromArgs = (input)=>{
+            if (input && 'object' == typeof input && 'context' in input) {
+                const { context: _context, ...rest } = input;
+                return rest;
+            }
+            return input;
+        };
+        const cleanedArgs = toolName === GET_MORE_TOOLS_NAME ? args : stripConversationId(removeContextFromArgs(args));
+        try {
+            if (void 0 === cleanedArgs) {
+                const handler = originalCallback;
+                return await handler(extra);
+            }
+            const handler = originalCallback;
+            return await handler(cleanedArgs, extra);
+        } catch (error) {
+            if (error instanceof Error) extra.__mcp_analytics_error = error;
+            throw error;
+        }
+    };
+    wrappedCallbacks.set(originalCallback, true);
+    wrappedCallbacks.set(wrappedCallback, true);
+    const wrappedTool = createWrappedTool(tool, wrappedCallback);
+    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) {
+    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);
+    }
+    if (request.params?.name === GET_MORE_TOOLS_NAME) {
+        const context = getContextArgument(request) || '';
+        return await captureToolCall({
+            server,
+            data,
+            request,
+            extra,
+            eventType: MCPAnalyticsEventType.mcpMissingCapability,
+            explicitContextIntent: context,
+            execute: async ()=>handleReportMissing({
+                    context
+                })
+        });
+    }
+    return await captureToolCall({
+        server,
+        data,
+        request,
+        extra,
+        execute: ()=>originalHandler(request, extra),
+        takeCapturedError: ()=>{
+            const captured = extra?.__mcp_analytics_error;
+            if (extra) extra.__mcp_analytics_error = void 0;
+            return captured;
+        }
+    });
+}
+function instrumentHighLevelServer(server) {
+    try {
+        const mcpAnalyticsData = getServerTrackingData(server.server);
+        setupToolsCallHandlerWrapping(server);
+        instrumentInitializeHandler(server.server);
+        server._registeredTools = addTracingToToolRegistry(server._registeredTools, server);
+        if (mcpAnalyticsData) seedToolDescriptionsFromRegistry(mcpAnalyticsData.toolDescriptions, server._registeredTools);
+        instrumentToolsListHandler(server.server);
+        setupListenerToRegisteredTools(server);
+    } catch (error) {
+        log(`Warning: Failed to setup tool call instrumentation - ${error}`);
+    }
+}
+function seedToolDescriptionsFromRegistry(cache, tools) {
+    for (const [name, tool] of Object.entries(tools))if ('string' == typeof tool?.description) cache.set(name, tool.description);
+}
+export { instrumentHighLevelServer };

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"instrument-lowlevel.d.ts","sourceRoot":"","sources":["../../src/extensions/instrument-lowlevel.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAiD,aAAa,EAAE,MAAM,UAAU,CAAA;AAc5F;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAcpE"}

package/dist/extensions/instrument-lowlevel.js

@@ -0,0 +1,85 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    instrumentLowLevelServer: ()=>instrumentLowLevelServer
+});
+const types_js_namespaceObject = require("@modelcontextprotocol/sdk/types.js");
+const external_event_types_js_namespaceObject = require("./event-types.js");
+const external_internal_js_namespaceObject = require("./internal.js");
+const external_logger_js_namespaceObject = require("./logger.js");
+const external_tools_js_namespaceObject = require("./tools.js");
+const external_instrumentation_js_namespaceObject = require("./instrumentation.js");
+const external_tracing_helpers_js_namespaceObject = require("./tracing-helpers.js");
+function instrumentLowLevelServer(server) {
+    try {
+        (0, external_instrumentation_js_namespaceObject.instrumentInitializeHandler)(server);
+        (0, external_instrumentation_js_namespaceObject.instrumentToolsListHandler)(server);
+        const originalCallToolHandler = server._requestHandlers.get('tools/call');
+        server.setRequestHandler(types_js_namespaceObject.CallToolRequestSchema, async (request, extra)=>await handleToolCallRequest(server, originalCallToolHandler, request, extra));
+    } catch (error) {
+        (0, external_logger_js_namespaceObject.log)(`Warning: Failed to setup tool call instrumentation - ${error}`);
+        throw error;
+    }
+}
+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 originalCallToolHandler?.(request, extra);
+    }
+    if (request.params?.name === external_tools_js_namespaceObject.GET_MORE_TOOLS_NAME) {
+        const context = (0, external_tracing_helpers_js_namespaceObject.getContextArgument)(request) || '';
+        return await (0, external_instrumentation_js_namespaceObject.captureToolCall)({
+            server,
+            data,
+            request,
+            extra,
+            eventType: external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpMissingCapability,
+            explicitContextIntent: context,
+            execute: async ()=>(0, external_tools_js_namespaceObject.handleReportMissing)({
+                    context
+                })
+        });
+    }
+    return await (0, external_instrumentation_js_namespaceObject.captureToolCall)({
+        server,
+        data,
+        request,
+        extra,
+        execute: (downstreamRequest)=>runOriginalToolHandler(originalCallToolHandler, downstreamRequest, extra)
+    });
+}
+function runOriginalToolHandler(handler, request, extra) {
+    if (!handler) throw new Error(`Unknown tool: ${request.params?.name || 'unknown'}`);
+    return handler(request, extra);
+}
+exports.instrumentLowLevelServer = __webpack_exports__.instrumentLowLevelServer;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "instrumentLowLevelServer"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/instrument-lowlevel.mjs

@@ -0,0 +1,51 @@
+import { CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { MCPAnalyticsEventType } from "./event-types.mjs";
+import { getServerTrackingData } from "./internal.mjs";
+import { log } from "./logger.mjs";
+import { GET_MORE_TOOLS_NAME, handleReportMissing } from "./tools.mjs";
+import { captureToolCall, instrumentInitializeHandler, instrumentToolsListHandler } from "./instrumentation.mjs";
+import { getContextArgument } from "./tracing-helpers.mjs";
+function instrumentLowLevelServer(server) {
+    try {
+        instrumentInitializeHandler(server);
+        instrumentToolsListHandler(server);
+        const originalCallToolHandler = server._requestHandlers.get('tools/call');
+        server.setRequestHandler(CallToolRequestSchema, async (request, extra)=>await handleToolCallRequest(server, originalCallToolHandler, request, extra));
+    } catch (error) {
+        log(`Warning: Failed to setup tool call instrumentation - ${error}`);
+        throw error;
+    }
+}
+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 originalCallToolHandler?.(request, extra);
+    }
+    if (request.params?.name === GET_MORE_TOOLS_NAME) {
+        const context = getContextArgument(request) || '';
+        return await captureToolCall({
+            server,
+            data,
+            request,
+            extra,
+            eventType: MCPAnalyticsEventType.mcpMissingCapability,
+            explicitContextIntent: context,
+            execute: async ()=>handleReportMissing({
+                    context
+                })
+        });
+    }
+    return await captureToolCall({
+        server,
+        data,
+        request,
+        extra,
+        execute: (downstreamRequest)=>runOriginalToolHandler(originalCallToolHandler, downstreamRequest, extra)
+    });
+}
+function runOriginalToolHandler(handler, request, extra) {
+    if (!handler) throw new Error(`Unknown tool: ${request.params?.name || 'unknown'}`);
+    return handler(request, extra);
+}
+export { instrumentLowLevelServer };

package/dist/extensions/instrumentation.d.ts

@@ -0,0 +1,59 @@
+import { type ListToolsResult } from '@modelcontextprotocol/sdk/types.js';
+import type { CompatibleRequestHandlerExtra, MCPAnalyticsData, MCPRequestLike, MCPServerLike } from '../types';
+import { MCPAnalyticsEventType } from './event-types';
+/**
+ * Runs the underlying tool. Receives the request with the SDK-injected
+ * `conversation_id` stripped; an adapter is free to ignore it (the high-level
+ * path strips arguments inside the wrapped callback instead).
+ */
+type ToolExecutor = (downstreamRequest: MCPRequestLike) => Promise<unknown>;
+interface TraceToolCallParams {
+    server: MCPServerLike;
+    data: MCPAnalyticsData;
+    request: MCPRequestLike;
+    extra?: CompatibleRequestHandlerExtra;
+    execute: ToolExecutor;
+    /**
+     * Event type to capture. Defaults to a tool call; the `get_more_tools` virtual
+     * tool passes `mcpMissingCapability` so it records a capability gap rather than
+     * a tool invocation.
+     */
+    eventType?: MCPAnalyticsEventType;
+    /**
+     * When set, used verbatim as the captured intent (source `context_parameter`)
+     * instead of running `resolveToolCallIntent`. Used by the `get_more_tools`
+     * virtual tool, which carries its intent in the `context` argument.
+     */
+    explicitContextIntent?: string;
+    /**
+     * Optional accessor for an error the executor captured out-of-band. The
+     * high-level SDK turns thrown tool errors into `isError: true` results before
+     * they reach us, so the wrapped callback stashes the original error and we
+     * read it here to capture the real stack rather than the result envelope.
+     */
+    takeCapturedError?: () => unknown;
+}
+/**
+ * The shared tool-call lifecycle: resolve conversation id, build + enrich the
+ * analytics event, run the tool, then capture success/failure.
+ *
+ * Analytics is isolated from the tool path on both sides — a failure while
+ * preparing or publishing the event can never change what the tool returns or
+ * throws, and the tool's own errors are always re-thrown to the caller.
+ */
+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`.
+ */
+export declare function instrumentToolsListHandler(server: MCPServerLike): void;
+export declare function cacheToolDescriptions(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.
+ */
+export declare function instrumentInitializeHandler(server: MCPServerLike): void;
+export {};
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/extensions/instrumentation.ts"],"names":[],"mappings":"AAAA,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,CAsCnF;AAuHD;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAsBtE;AAqGD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,eAAe,CAAC,OAAO,CAAC,GAAG,SAAS,GAAG,IAAI,CASnH;AAID;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAiCvE"}