@posthog/mcp 0.10.3 → 0.10.5

package/dist/extensions/conversation-id.mjs

@@ -4,14 +4,14 @@ import { DEFAULT_CONVERSATION_ID_DESCRIPTION } from "./constants.mjs";
 import { log } from "./logger.mjs";
 import { GET_MORE_TOOLS_NAME } from "./tools.mjs";
 const CONVERSATION_ID_PARAM_NAME = 'conversation_id';
-function addConversationIdToTool(tool) {
+function addConversationIdToTool(tool, logger = log) {
     const modifiedTool = {
         ...tool
     };
     const toolName = tool.name || 'unknown';
     const schema = modifiedTool.inputSchema;
     if (!canInjectAnalyticsParameter(schema, CONVERSATION_ID_PARAM_NAME)) {
-        hasAnalyticsParameter(schema, CONVERSATION_ID_PARAM_NAME) ? log(`WARN: Tool "${toolName}" already has '${CONVERSATION_ID_PARAM_NAME}' parameter. Skipping conversation_id injection.`) : log(`WARN: Tool "${toolName}" has complex schema (oneOf/allOf/anyOf). Skipping conversation_id injection.`);
+        logger(hasAnalyticsParameter(schema, CONVERSATION_ID_PARAM_NAME) ? `WARN: Tool "${toolName}" already has '${CONVERSATION_ID_PARAM_NAME}' parameter. Skipping conversation_id injection.` : `WARN: Tool "${toolName}" has complex schema (oneOf/allOf/anyOf/$ref). Skipping conversation_id injection.`);
         return modifiedTool;
     }
     if (!modifiedTool.inputSchema) modifiedTool.inputSchema = {
@@ -29,10 +29,10 @@ function addConversationIdToTool(tool) {
     };
     return modifiedTool;
 }
-function addConversationIdToTools(tools, missingCapabilityToolName = GET_MORE_TOOLS_NAME) {
+function addConversationIdToTools(tools, missingCapabilityToolName = GET_MORE_TOOLS_NAME, logger = log) {
     return tools.map((tool)=>{
         if (tool.name === missingCapabilityToolName) return tool;
-        return addConversationIdToTool(tool);
+        return addConversationIdToTool(tool, logger);
     });
 }
 function resolveConversationId(enabled, args, toolName, missingCapabilityToolName = GET_MORE_TOOLS_NAME) {
@@ -63,18 +63,6 @@ function extractConversationId(args) {
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : void 0;
 }
-function cloneRequestWithoutConversationId(request) {
-    if (!request.params || 'object' != typeof request.params) return request;
-    const args = request.params.arguments;
-    if (!(args && 'object' == typeof args)) return request;
-    return {
-        ...request,
-        params: {
-            ...request.params,
-            arguments: stripConversationId(args)
-        }
-    };
-}
 function stripConversationId(args) {
     if (!args || 'object' != typeof args || !(CONVERSATION_ID_PARAM_NAME in args)) return args;
     const { [CONVERSATION_ID_PARAM_NAME]: _omit, ...rest } = args;
@@ -97,4 +85,4 @@ function injectConversationIdPromptBack(result, conversationId) {
         ]
     };
 }
-export { CONVERSATION_ID_PARAM_NAME, addConversationIdToTool, addConversationIdToTools, buildConversationIdPromptBack, canInjectConversationIdPromptBack, cloneRequestWithoutConversationId, extractConversationId, injectConversationIdPromptBack, resolveConversationId, stripConversationId };
+export { CONVERSATION_ID_PARAM_NAME, addConversationIdToTool, addConversationIdToTools, buildConversationIdPromptBack, canInjectConversationIdPromptBack, extractConversationId, injectConversationIdPromptBack, resolveConversationId, stripConversationId };

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

@@ -1,3 +1,4 @@
 import type { HighLevelMCPServerLike } from '../types';
-export declare function instrumentHighLevelServer(server: HighLevelMCPServerLike): void;
+import type { LoggerFn } from './logger';
+export declare function instrumentHighLevelServer(server: HighLevelMCPServerLike, logger: LoggerFn): void;
 //# sourceMappingURL=instrument-highlevel.d.ts.map

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":"AAMA,OAAO,KAAK,EAEV,sBAAsB,EAIvB,MAAM,UAAU,CAAA;AAsSjB,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,sBAAsB,GAAG,IAAI,CAwB9E"}
+{"version":3,"file":"instrument-highlevel.d.ts","sourceRoot":"","sources":["../../src/extensions/instrument-highlevel.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAEV,sBAAsB,EAIvB,MAAM,UAAU,CAAA;AASjB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAmQxC,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,sBAAsB,EAAE,MAAM,EAAE,QAAQ,GAAG,IAAI,CA2BhG"}

package/dist/extensions/instrument-highlevel.js

@@ -27,11 +27,9 @@ __webpack_require__.d(__webpack_exports__, {
     instrumentHighLevelServer: ()=>instrumentHighLevelServer
 });
 const external_analytics_parameters_js_namespaceObject = require("./analytics-parameters.js");
-const external_conversation_id_js_namespaceObject = require("./conversation-id.js");
 const external_context_parameters_js_namespaceObject = require("./context-parameters.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");
@@ -41,52 +39,31 @@ const MCP_ANALYTICS_PROCESSED = Symbol('__posthog_mcp_analytics_processed__');
 function isCallbackUpdate(value) {
     return !!value && 'object' == typeof value && 'callback' in value && 'function' == typeof value.callback;
 }
-function analyticsOwnsParameter(inputSchema, parameterName) {
-    if (!inputSchema || 'object' != typeof inputSchema) return (0, external_analytics_parameters_js_namespaceObject.canInjectAnalyticsParameter)(void 0, parameterName);
-    if ((0, external_mcp_sdk_compat_js_namespaceObject.isZodRawShapeCompat)(inputSchema)) return (0, external_analytics_parameters_js_namespaceObject.canInjectAnalyticsParameter)({
-        properties: inputSchema
-    }, parameterName);
-    const shape = (0, external_mcp_sdk_compat_js_namespaceObject.getObjectShape)(inputSchema);
-    if (shape) return (0, external_analytics_parameters_js_namespaceObject.canInjectAnalyticsParameter)({
-        properties: shape
-    }, parameterName);
-    const schema = inputSchema;
-    if ('_def' in schema || '_zod' in schema || '~standard' in schema) return (0, external_analytics_parameters_js_namespaceObject.canInjectAnalyticsParameter)(void 0, parameterName);
-    return (0, external_analytics_parameters_js_namespaceObject.canInjectAnalyticsParameter)(schema, parameterName);
-}
-function stripOwnedAnalyticsArguments(args, ownership) {
-    let cleanedArgs = args;
-    if (ownership.context && cleanedArgs && 'object' == typeof cleanedArgs && 'context' in cleanedArgs) {
-        const { context: _context, ...rest } = cleanedArgs;
-        cleanedArgs = rest;
-    }
-    return ownership.conversationId ? (0, external_conversation_id_js_namespaceObject.stripConversationId)(cleanedArgs) : cleanedArgs;
-}
-function addTracingToToolRegistry(tools, server) {
+function addTracingToToolRegistry(tools, server, logger) {
     return Object.fromEntries(Object.entries(tools).map(([name, tool])=>[
             name,
-            addTracingToToolCallbackInternal(tool, name, server)
+            addTracingToToolCallbackInternal(tool, name, server, ()=>tool.inputSchema, logger)
         ]));
 }
-function setupListenerToRegisteredTools(server) {
+function setupListenerToRegisteredTools(server, logger) {
     try {
         const data = (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');
+        if (!data) return void logger('Warning: Cannot setup listener - no tracking data found');
         const handler = {
             set (target, property, value) {
                 try {
                     if ('string' == typeof property && value && 'object' == typeof value && (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`);
+                            logger(`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`);
+                            logger(`Tool ${String(property)} callback already wrapped, skipping proxy wrapping`);
                             return Reflect.set(target, property, value);
                         }
                         const getCurrentInputSchema = ()=>value.inputSchema;
-                        const nextValue = addTracingToToolCallbackInternal(value, property, server, getCurrentInputSchema);
+                        const nextValue = addTracingToToolCallbackInternal(value, property, server, getCurrentInputSchema, logger);
                         if ('function' == typeof nextValue.update) {
                             const originalUpdate = nextValue.update;
                             nextValue.update = function(...updateArgs) {
@@ -95,7 +72,7 @@ function setupListenerToRegisteredTools(server) {
                                     if (isCallbackUpdate(updateObj)) {
                                         const wrappedTool = addTracingToToolCallbackInternal({
                                             callback: updateObj.callback
-                                        }, property, server, getCurrentInputSchema);
+                                        }, property, server, getCurrentInputSchema, logger);
                                         updateObj.callback = (0, external_mcp_sdk_compat_js_namespaceObject.getToolFunction)(wrappedTool);
                                     }
                                 }
@@ -106,7 +83,7 @@ function setupListenerToRegisteredTools(server) {
                     }
                     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}`);
+                    logger(`Warning: Error in proxy set handler for tool ${String(property)} - ${error}`);
                     return Reflect.set(target, property, value);
                 }
             },
@@ -122,21 +99,21 @@ function setupListenerToRegisteredTools(server) {
         };
         const originalTools = server._registeredTools || {};
         server._registeredTools = new Proxy(originalTools, handler);
-        (0, external_logger_js_namespaceObject.log)('Successfully set up listener for new tool registrations');
+        logger('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}`);
+        logger(`Warning: Failed to setup listener for registered tools - ${error}`);
     }
 }
-function addTracingToToolCallbackInternal(tool, toolName, server, getCurrentInputSchema = ()=>tool.inputSchema) {
+function addTracingToToolCallbackInternal(tool, toolName, server, getCurrentInputSchema, logger) {
     const originalCallback = (0, external_mcp_sdk_compat_js_namespaceObject.getToolFunction)(tool);
     const options = (0, external_internal_js_namespaceObject.getServerTrackingData)(server.server)?.options;
     const missingToolName = (0, external_tools_js_namespaceObject.resolveMissingCapabilityToolName)(options);
     if (wrappedCallbacks.has(originalCallback)) {
-        (0, external_logger_js_namespaceObject.log)(`Tool ${toolName} callback already wrapped, skipping re-wrap`);
+        logger(`Tool ${toolName} callback already wrapped, skipping re-wrap`);
         return tool;
     }
     if (tool[MCP_ANALYTICS_PROCESSED]) {
-        (0, external_logger_js_namespaceObject.log)(`Tool ${toolName} already processed, skipping re-wrap`);
+        logger(`Tool ${toolName} already processed, skipping re-wrap`);
         return tool;
     }
     const wrappedCallback = async (...params)=>{
@@ -150,9 +127,9 @@ function addTracingToToolCallbackInternal(tool, toolName, server, getCurrentInpu
             extra = params[0];
         }
         const inputSchema = getCurrentInputSchema();
-        const cleanedArgs = stripOwnedAnalyticsArguments(args, {
-            context: toolName !== missingToolName && (0, external_context_parameters_js_namespaceObject.isContextEnabled)(options?.context) && analyticsOwnsParameter(inputSchema, 'context'),
-            conversationId: toolName !== missingToolName && options?.enableConversationId === true && analyticsOwnsParameter(inputSchema, 'conversation_id')
+        const cleanedArgs = (0, external_analytics_parameters_js_namespaceObject.stripOwnedAnalyticsArguments)(args, {
+            context: toolName !== missingToolName && (0, external_context_parameters_js_namespaceObject.isContextEnabled)(options?.context) && (0, external_analytics_parameters_js_namespaceObject.analyticsOwnsParameter)(inputSchema, 'context'),
+            conversationId: toolName !== missingToolName && options?.enableConversationId === true && (0, external_analytics_parameters_js_namespaceObject.analyticsOwnsParameter)(inputSchema, 'conversation_id')
         });
         try {
             if (void 0 === cleanedArgs) {
@@ -172,10 +149,10 @@ function addTracingToToolCallbackInternal(tool, toolName, server, getCurrentInpu
     wrappedTool[MCP_ANALYTICS_PROCESSED] = true;
     return wrappedTool;
 }
-async function handleToolCallRequest(server, originalCallToolHandler, request, extra) {
+async function handleToolCallRequest(highLevelServer, server, originalCallToolHandler, request, extra, logger) {
     const data = (0, external_internal_js_namespaceObject.getServerTrackingData)(server);
     if (!data) {
-        (0, external_logger_js_namespaceObject.log)('Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using tool calls.');
+        logger('Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using tool calls.');
         return await originalCallToolHandler(request, extra);
     }
     if (request.params?.name === (0, external_tools_js_namespaceObject.resolveMissingCapabilityToolName)(data.options)) {
@@ -189,15 +166,18 @@ async function handleToolCallRequest(server, originalCallToolHandler, request, e
             explicitContextIntent: context,
             execute: async ()=>(0, external_tools_js_namespaceObject.handleReportMissing)({
                     context
-                })
+                }, data.logger)
         });
     }
+    const toolName = request.params?.name;
+    const registeredTool = toolName ? highLevelServer._registeredTools[toolName] : void 0;
     return await (0, external_instrumentation_js_namespaceObject.captureToolCall)({
         server,
         data,
         request,
         extra,
-        execute: ()=>originalCallToolHandler(request, extra),
+        execute: (downstreamRequest)=>originalCallToolHandler(downstreamRequest, extra),
+        parameterOwnership: registeredTool ? (0, external_analytics_parameters_js_namespaceObject.getAnalyticsParameterOwnership)(registeredTool.inputSchema) : void 0,
         takeCapturedError: ()=>{
             const captured = extra?.__mcp_analytics_error;
             if (extra) extra.__mcp_analytics_error = void 0;
@@ -205,24 +185,24 @@ async function handleToolCallRequest(server, originalCallToolHandler, request, e
         }
     });
 }
-function instrumentHighLevelServer(server) {
+function instrumentHighLevelServer(server, logger) {
     try {
         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
+            initialize: (trackedServer, originalHandler, request, extra)=>(0, external_instrumentation_js_namespaceObject.handleInitializeRequest)(trackedServer, originalHandler, request, extra, logger),
+            'tools/list': (trackedServer, originalHandler, request, extra)=>(0, external_instrumentation_js_namespaceObject.handleListToolsRequest)(trackedServer, originalHandler, request, extra, logger),
+            'tools/call': (trackedServer, originalHandler, request, extra)=>handleToolCallRequest(server, trackedServer, originalHandler, request, extra, logger)
         };
         (0, external_instrumentation_js_namespaceObject.patchRequestHandlers)(lowLevelServer, handlers);
-        server._registeredTools = addTracingToToolRegistry(server._registeredTools, server);
+        server._registeredTools = addTracingToToolRegistry(server._registeredTools, server, logger);
         if (mcpAnalyticsData) {
             seedToolDescriptionsFromRegistry(mcpAnalyticsData.toolDescriptions, server._registeredTools);
             seedToolCategoriesFromRegistry(mcpAnalyticsData.toolCategories, server._registeredTools);
         }
-        setupListenerToRegisteredTools(server);
+        setupListenerToRegisteredTools(server, logger);
     } catch (error) {
-        (0, external_logger_js_namespaceObject.log)(`Warning: Failed to setup tool call instrumentation - ${error}`);
+        logger(`Warning: Failed to setup tool call instrumentation - ${error}`);
     }
 }
 function seedToolDescriptionsFromRegistry(cache, tools) {

package/dist/extensions/instrument-highlevel.mjs

@@ -1,10 +1,8 @@
-import { canInjectAnalyticsParameter } from "./analytics-parameters.mjs";
-import { stripConversationId } from "./conversation-id.mjs";
+import { analyticsOwnsParameter, getAnalyticsParameterOwnership, stripOwnedAnalyticsArguments } from "./analytics-parameters.mjs";
 import { isContextEnabled } from "./context-parameters.mjs";
 import { MCPAnalyticsEventType } from "./event-types.mjs";
 import { getServerTrackingData } from "./internal.mjs";
-import { log } from "./logger.mjs";
-import { createWrappedTool, getObjectShape, getToolFunction, hasToolFunction, isZodRawShapeCompat } from "./mcp-sdk-compat.mjs";
+import { createWrappedTool, getToolFunction, hasToolFunction } from "./mcp-sdk-compat.mjs";
 import { handleReportMissing, resolveMissingCapabilityToolName } from "./tools.mjs";
 import { captureToolCall, handleInitializeRequest, handleListToolsRequest, patchRequestHandlers, readToolMetaCategory } from "./instrumentation.mjs";
 import { getContextArgument } from "./tracing-helpers.mjs";
@@ -13,52 +11,31 @@ const MCP_ANALYTICS_PROCESSED = Symbol('__posthog_mcp_analytics_processed__');
 function isCallbackUpdate(value) {
     return !!value && 'object' == typeof value && 'callback' in value && 'function' == typeof value.callback;
 }
-function analyticsOwnsParameter(inputSchema, parameterName) {
-    if (!inputSchema || 'object' != typeof inputSchema) return canInjectAnalyticsParameter(void 0, parameterName);
-    if (isZodRawShapeCompat(inputSchema)) return canInjectAnalyticsParameter({
-        properties: inputSchema
-    }, parameterName);
-    const shape = getObjectShape(inputSchema);
-    if (shape) return canInjectAnalyticsParameter({
-        properties: shape
-    }, parameterName);
-    const schema = inputSchema;
-    if ('_def' in schema || '_zod' in schema || '~standard' in schema) return canInjectAnalyticsParameter(void 0, parameterName);
-    return canInjectAnalyticsParameter(schema, parameterName);
-}
-function stripOwnedAnalyticsArguments(args, ownership) {
-    let cleanedArgs = args;
-    if (ownership.context && cleanedArgs && 'object' == typeof cleanedArgs && 'context' in cleanedArgs) {
-        const { context: _context, ...rest } = cleanedArgs;
-        cleanedArgs = rest;
-    }
-    return ownership.conversationId ? stripConversationId(cleanedArgs) : cleanedArgs;
-}
-function addTracingToToolRegistry(tools, server) {
+function addTracingToToolRegistry(tools, server, logger) {
     return Object.fromEntries(Object.entries(tools).map(([name, tool])=>[
             name,
-            addTracingToToolCallbackInternal(tool, name, server)
+            addTracingToToolCallbackInternal(tool, name, server, ()=>tool.inputSchema, logger)
         ]));
 }
-function setupListenerToRegisteredTools(server) {
+function setupListenerToRegisteredTools(server, logger) {
     try {
         const data = getServerTrackingData(server.server);
-        if (!data) return void log('Warning: Cannot setup listener - no tracking data found');
+        if (!data) return void logger('Warning: Cannot setup listener - no tracking data found');
         const handler = {
             set (target, property, value) {
                 try {
                     if ('string' == typeof property && value && 'object' == typeof value && hasToolFunction(value)) {
                         if ('string' == typeof value.description) data.toolDescriptions.set(property, value.description);
                         if (value[MCP_ANALYTICS_PROCESSED]) {
-                            log(`Tool ${String(property)} already processed, skipping proxy wrapping`);
+                            logger(`Tool ${String(property)} already processed, skipping proxy wrapping`);
                             return Reflect.set(target, property, value);
                         }
                         if (wrappedCallbacks.has(getToolFunction(value))) {
-                            log(`Tool ${String(property)} callback already wrapped, skipping proxy wrapping`);
+                            logger(`Tool ${String(property)} callback already wrapped, skipping proxy wrapping`);
                             return Reflect.set(target, property, value);
                         }
                         const getCurrentInputSchema = ()=>value.inputSchema;
-                        const nextValue = addTracingToToolCallbackInternal(value, property, server, getCurrentInputSchema);
+                        const nextValue = addTracingToToolCallbackInternal(value, property, server, getCurrentInputSchema, logger);
                         if ('function' == typeof nextValue.update) {
                             const originalUpdate = nextValue.update;
                             nextValue.update = function(...updateArgs) {
@@ -67,7 +44,7 @@ function setupListenerToRegisteredTools(server) {
                                     if (isCallbackUpdate(updateObj)) {
                                         const wrappedTool = addTracingToToolCallbackInternal({
                                             callback: updateObj.callback
-                                        }, property, server, getCurrentInputSchema);
+                                        }, property, server, getCurrentInputSchema, logger);
                                         updateObj.callback = getToolFunction(wrappedTool);
                                     }
                                 }
@@ -78,7 +55,7 @@ function setupListenerToRegisteredTools(server) {
                     }
                     return Reflect.set(target, property, value);
                 } catch (error) {
-                    log(`Warning: Error in proxy set handler for tool ${String(property)} - ${error}`);
+                    logger(`Warning: Error in proxy set handler for tool ${String(property)} - ${error}`);
                     return Reflect.set(target, property, value);
                 }
             },
@@ -94,21 +71,21 @@ function setupListenerToRegisteredTools(server) {
         };
         const originalTools = server._registeredTools || {};
         server._registeredTools = new Proxy(originalTools, handler);
-        log('Successfully set up listener for new tool registrations');
+        logger('Successfully set up listener for new tool registrations');
     } catch (error) {
-        log(`Warning: Failed to setup listener for registered tools - ${error}`);
+        logger(`Warning: Failed to setup listener for registered tools - ${error}`);
     }
 }
-function addTracingToToolCallbackInternal(tool, toolName, server, getCurrentInputSchema = ()=>tool.inputSchema) {
+function addTracingToToolCallbackInternal(tool, toolName, server, getCurrentInputSchema, logger) {
     const originalCallback = getToolFunction(tool);
     const options = getServerTrackingData(server.server)?.options;
     const missingToolName = resolveMissingCapabilityToolName(options);
     if (wrappedCallbacks.has(originalCallback)) {
-        log(`Tool ${toolName} callback already wrapped, skipping re-wrap`);
+        logger(`Tool ${toolName} callback already wrapped, skipping re-wrap`);
         return tool;
     }
     if (tool[MCP_ANALYTICS_PROCESSED]) {
-        log(`Tool ${toolName} already processed, skipping re-wrap`);
+        logger(`Tool ${toolName} already processed, skipping re-wrap`);
         return tool;
     }
     const wrappedCallback = async (...params)=>{
@@ -144,10 +121,10 @@ function addTracingToToolCallbackInternal(tool, toolName, server, getCurrentInpu
     wrappedTool[MCP_ANALYTICS_PROCESSED] = true;
     return wrappedTool;
 }
-async function handleToolCallRequest(server, originalCallToolHandler, request, extra) {
+async function handleToolCallRequest(highLevelServer, server, originalCallToolHandler, request, extra, logger) {
     const data = getServerTrackingData(server);
     if (!data) {
-        log('Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using tool calls.');
+        logger('Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using tool calls.');
         return await originalCallToolHandler(request, extra);
     }
     if (request.params?.name === resolveMissingCapabilityToolName(data.options)) {
@@ -161,15 +138,18 @@ async function handleToolCallRequest(server, originalCallToolHandler, request, e
             explicitContextIntent: context,
             execute: async ()=>handleReportMissing({
                     context
-                })
+                }, data.logger)
         });
     }
+    const toolName = request.params?.name;
+    const registeredTool = toolName ? highLevelServer._registeredTools[toolName] : void 0;
     return await captureToolCall({
         server,
         data,
         request,
         extra,
-        execute: ()=>originalCallToolHandler(request, extra),
+        execute: (downstreamRequest)=>originalCallToolHandler(downstreamRequest, extra),
+        parameterOwnership: registeredTool ? getAnalyticsParameterOwnership(registeredTool.inputSchema) : void 0,
         takeCapturedError: ()=>{
             const captured = extra?.__mcp_analytics_error;
             if (extra) extra.__mcp_analytics_error = void 0;
@@ -177,24 +157,24 @@ async function handleToolCallRequest(server, originalCallToolHandler, request, e
         }
     });
 }
-function instrumentHighLevelServer(server) {
+function instrumentHighLevelServer(server, logger) {
     try {
         const lowLevelServer = server.server;
         const mcpAnalyticsData = getServerTrackingData(lowLevelServer);
         const handlers = {
-            initialize: handleInitializeRequest,
-            'tools/list': handleListToolsRequest,
-            'tools/call': handleToolCallRequest
+            initialize: (trackedServer, originalHandler, request, extra)=>handleInitializeRequest(trackedServer, originalHandler, request, extra, logger),
+            'tools/list': (trackedServer, originalHandler, request, extra)=>handleListToolsRequest(trackedServer, originalHandler, request, extra, logger),
+            'tools/call': (trackedServer, originalHandler, request, extra)=>handleToolCallRequest(server, trackedServer, originalHandler, request, extra, logger)
         };
         patchRequestHandlers(lowLevelServer, handlers);
-        server._registeredTools = addTracingToToolRegistry(server._registeredTools, server);
+        server._registeredTools = addTracingToToolRegistry(server._registeredTools, server, logger);
         if (mcpAnalyticsData) {
             seedToolDescriptionsFromRegistry(mcpAnalyticsData.toolDescriptions, server._registeredTools);
             seedToolCategoriesFromRegistry(mcpAnalyticsData.toolCategories, server._registeredTools);
         }
-        setupListenerToRegisteredTools(server);
+        setupListenerToRegisteredTools(server, logger);
     } catch (error) {
-        log(`Warning: Failed to setup tool call instrumentation - ${error}`);
+        logger(`Warning: Failed to setup tool call instrumentation - ${error}`);
     }
 }
 function seedToolDescriptionsFromRegistry(cache, tools) {

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

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

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

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

package/dist/extensions/instrument-lowlevel.js

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

package/dist/extensions/instrument-lowlevel.mjs

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

package/dist/extensions/instrumentation.d.ts

@@ -1,6 +1,7 @@
 import type { ListToolsResult } from '@modelcontextprotocol/sdk/types.js';
-import type { CompatibleRequestHandlerExtra, MCPAnalyticsData, MCPRequestLike, MCPServerLike } from '../types';
+import type { AnalyticsParameterOwnership, CompatibleRequestHandlerExtra, MCPAnalyticsData, MCPRequestLike, MCPServerLike } from '../types';
 import { MCPAnalyticsEventType } from './event-types';
+import type { LoggerFn } from './logger';
 /**
  * Single instrumentation core shared by the low-level (`Server`) and high-level
  * (`McpServer`) wrappers. The two entrypoints differ only in how they reach the
@@ -9,11 +10,7 @@ import { MCPAnalyticsEventType } from './event-types';
  * 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
- * path strips arguments inside the wrapped callback instead).
- */
+/** Runs the underlying tool with SDK-owned analytics arguments removed. */
 type ToolExecutor = (downstreamRequest: MCPRequestLike) => Promise<unknown>;
 interface TraceToolCallParams {
     server: MCPServerLike;
@@ -21,6 +18,8 @@ interface TraceToolCallParams {
     request: MCPRequestLike;
     extra?: CompatibleRequestHandlerExtra;
     execute: ToolExecutor;
+    /** Optional schema-derived ownership override for adapters with direct registry access. */
+    parameterOwnership?: AnalyticsParameterOwnership;
     /**
      * 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
@@ -68,7 +67,7 @@ export declare function patchRequestHandlers(server: MCPServerLike, patches: Rec
  * Captures each `tools/list` and injects the SDK-managed tools (context
  * parameter, conversation id, `get_more_tools`) into the returned list.
  */
-export declare function handleListToolsRequest(server: MCPServerLike, originalListToolsHandler: MCPRequestHandler, request: MCPRequestLike, extra?: CompatibleRequestHandlerExtra): Promise<{
+export declare function handleListToolsRequest(server: MCPServerLike, originalListToolsHandler: MCPRequestHandler, request: MCPRequestLike, extra: CompatibleRequestHandlerExtra | undefined, logger: LoggerFn): Promise<{
     tools: ListToolsResult['tools'];
 }>;
 export declare function cacheToolDescriptions(cache: Map<string, string>, tools: ListToolsResult['tools'] | undefined): void;
@@ -83,6 +82,6 @@ export declare function cacheToolCategories(cache: Map<string, string>, tools: L
  * Captures the connection handshake (and resolves identity) on `initialize`
  * before the original handler runs.
  */
-export declare function handleInitializeRequest(server: MCPServerLike, originalInitializeHandler: MCPRequestHandler, request: MCPRequestLike, extra?: CompatibleRequestHandlerExtra): Promise<unknown>;
+export declare function handleInitializeRequest(server: MCPServerLike, originalInitializeHandler: MCPRequestHandler, request: MCPRequestLike, extra: CompatibleRequestHandlerExtra | undefined, logger: LoggerFn): Promise<unknown>;
 export {};
 //# sourceMappingURL=instrumentation.d.ts.map

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

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