@posthog/mcp 0.10.5 → 0.10.7

package/dist/extensions/instrumentation.js

@@ -24,11 +24,12 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    readToolMetaCategory: ()=>readToolMetaCategory,
+    isToolAdvertised: ()=>isToolAdvertised,
     cacheToolDescriptions: ()=>cacheToolDescriptions,
-    cacheToolCategories: ()=>cacheToolCategories,
     handleInitializeRequest: ()=>handleInitializeRequest,
     captureToolCall: ()=>captureToolCall,
+    readToolMetaCategory: ()=>readToolMetaCategory,
+    cacheToolCategories: ()=>cacheToolCategories,
     handleListToolsRequest: ()=>handleListToolsRequest,
     patchRequestHandlers: ()=>patchRequestHandlers
 });
@@ -49,26 +50,26 @@ const external_tools_js_namespaceObject = require("./tools.js");
 const external_tracing_helpers_js_namespaceObject = require("./tracing-helpers.js");
 async function captureToolCall(params) {
     const { server, data, request, extra, execute, parameterOwnership, eventType, explicitContextIntent, takeCapturedError } = params;
-    const ownership = getActiveAnalyticsParameterOwnership(data, request.params?.name, parameterOwnership);
-    const conversation = (0, external_conversation_id_js_namespaceObject.resolveConversationId)(ownership.conversationId, request.params?.arguments, request.params?.name, (0, external_tools_js_namespaceObject.resolveMissingCapabilityToolName)(data.options));
+    const resolvedEventType = eventType ?? external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpToolsCall;
+    const ownership = getActiveAnalyticsParameterOwnership(data, request.params?.name, parameterOwnership, resolvedEventType === external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpMissingCapability);
+    const conversation = (0, external_conversation_id_js_namespaceObject.resolveConversationId)(ownership.conversationId, request.params?.arguments, request.params?.name, resolvedEventType === external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpMissingCapability ? (0, external_tools_js_namespaceObject.resolveMissingCapabilityToolName)(data.options) : '');
     const downstreamRequest = cloneRequestWithoutOwnedAnalyticsArguments(request, ownership);
     const startTime = new Date();
-    const event = await prepareToolCallEvent(server, data, request, downstreamRequest, extra, startTime, conversation, ownership, eventType ?? external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpToolsCall);
-    if (event && explicitContextIntent) (0, external_intent_js_namespaceObject.setExplicitContextIntent)(event, explicitContextIntent);
+    const preparedEvent = await prepareToolCallEvent(server, data, request, downstreamRequest, extra, startTime, conversation, ownership, resolvedEventType);
+    if (preparedEvent && explicitContextIntent) (0, external_intent_js_namespaceObject.setExplicitContextIntent)(preparedEvent.event, explicitContextIntent);
     let result;
     try {
         result = await execute(downstreamRequest);
     } catch (error) {
-        publishFailedToolEvent(server, event, error, startTime, conversation, data.logger);
+        publishFailedToolEvent(server, preparedEvent, error, startTime, conversation, data.logger);
         throw error;
     }
-    const finalResult = applyConversationPromptBack(event, result, conversation);
-    publishSuccessfulToolEvent(server, event, finalResult, startTime, data.logger, takeCapturedError);
+    const finalResult = applyConversationPromptBack(preparedEvent?.event ?? null, result, conversation);
+    publishSuccessfulToolEvent(server, preparedEvent, finalResult, startTime, data.logger, takeCapturedError);
     return finalResult;
 }
-function getActiveAnalyticsParameterOwnership(data, toolName, override) {
+function getActiveAnalyticsParameterOwnership(data, toolName, override, isMissingCapabilityTool) {
     const ownership = override ?? (toolName ? data.toolAnalyticsParameterOwnership.get(toolName) : void 0);
-    const isMissingCapabilityTool = toolName === (0, external_tools_js_namespaceObject.resolveMissingCapabilityToolName)(data.options);
     return {
         context: !isMissingCapabilityTool && (0, external_context_parameters_js_namespaceObject.isContextEnabled)(data.options.context) && ownership?.context === true,
         conversationId: !isMissingCapabilityTool && true === data.options.enableConversationId && ownership?.conversationId === true
@@ -89,7 +90,9 @@ function cloneRequestWithoutOwnedAnalyticsArguments(request, ownership) {
 async function prepareToolCallEvent(server, data, request, downstreamRequest, extra, startTime, conversation, ownership, eventType) {
     try {
         const sessionId = (0, external_session_js_namespaceObject.getSessionId)(server, extra);
-        await (0, external_internal_js_namespaceObject.handleIdentify)(server, data, sessionId, request, extra);
+        const sessionInfo = (0, external_session_js_namespaceObject.getSessionInfo)(server, data, sessionId);
+        const identity = await (0, external_internal_js_namespaceObject.handleIdentify)(server, data, sessionId, request, sessionInfo, extra);
+        const requestAttribution = (0, external_internal_js_namespaceObject.withIdentity)(sessionInfo, identity);
         const toolName = request.params?.name;
         const event = {
             sessionId,
@@ -104,7 +107,10 @@ async function prepareToolCallEvent(server, data, request, downstreamRequest, ex
         (0, external_client_identity_js_namespaceObject.stampMetaClientInfo)(event, request);
         await (0, external_tracing_helpers_js_namespaceObject.applyResolvedMetadata)(event, data, request, extra);
         (0, external_intent_js_namespaceObject.setEventIntent)(event, await (0, external_intent_js_namespaceObject.resolveToolCallIntent)(data, request, ownership.context, extra));
-        return event;
+        return {
+            event,
+            requestAttribution
+        };
     } catch (error) {
         data.logger(`Warning: PostHog MCP analytics instrumentation failed for tool ${request.params?.name}, the tool will still run - ${error}`);
         return null;
@@ -116,8 +122,9 @@ function applyConversationPromptBack(event, result, conversation) {
     if (event) event.conversationId = void 0;
     return result;
 }
-function publishSuccessfulToolEvent(server, event, result, startTime, logger, takeCapturedError) {
-    if (!event) return;
+function publishSuccessfulToolEvent(server, preparedEvent, result, startTime, logger, takeCapturedError) {
+    if (!preparedEvent) return;
+    const { event, requestAttribution } = preparedEvent;
     try {
         if ((0, external_tracing_helpers_js_namespaceObject.isToolResultError)(result)) {
             event.isError = true;
@@ -126,49 +133,85 @@ function publishSuccessfulToolEvent(server, event, result, startTime, logger, ta
         } else event.isError = false;
         event.response = result;
         event.duration = Date.now() - startTime.getTime();
-        (0, external_capture_js_namespaceObject.captureEvent)(server, event, logger);
+        (0, external_capture_js_namespaceObject.captureEvent)(server, event, logger, requestAttribution);
     } catch (error) {
         logger(`Warning: PostHog MCP analytics failed to publish tool event - ${error}`);
     }
 }
-function publishFailedToolEvent(server, event, error, startTime, conversation, logger) {
-    if (!event) return;
+function publishFailedToolEvent(server, preparedEvent, error, startTime, conversation, logger) {
+    if (!preparedEvent) return;
+    const { event, requestAttribution } = preparedEvent;
     try {
         if (conversation.minted) event.conversationId = void 0;
         event.isError = true;
         event.error = (0, external_exceptions_js_namespaceObject.captureException)(error);
         event.duration = Date.now() - startTime.getTime();
-        (0, external_capture_js_namespaceObject.captureEvent)(server, event, logger);
+        (0, external_capture_js_namespaceObject.captureEvent)(server, event, logger, requestAttribution);
     } catch (publishError) {
         logger(`Warning: PostHog MCP analytics failed to publish failed tool event - ${publishError}`);
     }
 }
+const originalRequestHandlers = new WeakMap();
+function rememberOriginalRequestHandler(server, handlerName, originalHandler) {
+    let handlers = originalRequestHandlers.get(server);
+    if (!handlers) {
+        handlers = new Map();
+        originalRequestHandlers.set(server, handlers);
+    }
+    handlers.set(handlerName, originalHandler);
+}
 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));
+        if (originalHandler) {
+            rememberOriginalRequestHandler(server, handlerName, 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));
+        if (!patch || 'string' != typeof handlerName) return originalSetRequestHandler(requestSchema, originalHandler);
+        const result = originalSetRequestHandler(requestSchema, originalHandler);
+        const registeredHandler = server._requestHandlers.get(handlerName);
+        if (registeredHandler) {
+            rememberOriginalRequestHandler(server, handlerName, registeredHandler);
+            server._requestHandlers.set(handlerName, (request, extra)=>patch(server, registeredHandler, request, extra));
+        }
+        return result;
     };
 }
+async function isToolAdvertised(server, toolName, extra, logger) {
+    const listHandler = originalRequestHandlers.get(server)?.get('tools/list');
+    if (!listHandler || !server._requestHandlers.has('tools/list')) return;
+    try {
+        const response = await listHandler({
+            method: 'tools/list',
+            params: {}
+        }, extra);
+        if (!response || !Array.isArray(response.tools)) return;
+        return response.tools.some((tool)=>tool?.name === toolName);
+    } catch (error) {
+        logger(`Warning: PostHog MCP analytics could not determine whether "${toolName}" is advertised; delegating to the server - ${error}`);
+        return;
+    }
+}
 async function handleListToolsRequest(server, originalListToolsHandler, request, extra, logger) {
     const data = (0, external_internal_js_namespaceObject.getServerTrackingData)(server);
     const startTime = new Date();
+    const sessionId = (0, external_session_js_namespaceObject.getSessionId)(server, extra);
+    const requestAttribution = (0, external_session_js_namespaceObject.getSessionInfo)(server, data, sessionId);
     const event = {
-        sessionId: (0, external_session_js_namespaceObject.getSessionId)(server, extra),
+        sessionId,
         parameters: (0, external_mcp_payloads_js_namespaceObject.buildCapturedMcpParameters)(request),
         eventType: external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpToolsList,
         timestamp: startTime
     };
     (0, external_client_identity_js_namespaceObject.stampMetaClientInfo)(event, request);
     if (data) await (0, external_tracing_helpers_js_namespaceObject.applyResolvedMetadata)(event, data, request, extra);
-    const tools = await getTracedToolsList(server, originalListToolsHandler, request, extra, event, logger);
+    const tools = await getTracedToolsList(server, originalListToolsHandler, request, extra, event, logger, requestAttribution);
     if (!data) {
         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 {
@@ -180,7 +223,7 @@ async function handleListToolsRequest(server, originalListToolsHandler, request,
         event.error = (0, external_exceptions_js_namespaceObject.captureException)('No tools were sent to MCP client.');
         event.isError = true;
         event.duration = Date.now() - startTime.getTime();
-        (0, external_capture_js_namespaceObject.captureEvent)(server, event, data.logger);
+        (0, external_capture_js_namespaceObject.captureEvent)(server, event, data.logger, requestAttribution);
         return {
             tools
         };
@@ -191,7 +234,7 @@ async function handleListToolsRequest(server, originalListToolsHandler, request,
     event.listedToolNames = collectListedToolNames(tools);
     event.isError = false;
     event.duration = Date.now() - startTime.getTime();
-    (0, external_capture_js_namespaceObject.captureEvent)(server, event, data.logger);
+    (0, external_capture_js_namespaceObject.captureEvent)(server, event, data.logger, requestAttribution);
     return {
         tools
     };
@@ -204,18 +247,27 @@ function collectListedToolNames(tools) {
     const names = tools.map((tool)=>tool?.name).filter((name)=>'string' == typeof name);
     return names.length > 0 ? names : void 0;
 }
-async function getTracedToolsList(server, originalListToolsHandler, request, extra, event, logger) {
+async function getTracedToolsList(server, originalListToolsHandler, request, extra, event, logger, requestAttribution) {
     try {
         const data = (0, external_internal_js_namespaceObject.getServerTrackingData)(server);
         const originalResponse = await originalListToolsHandler(request, extra);
-        let tools = originalResponse.tools || [];
+        let tools = [
+            ...originalResponse.tools || []
+        ];
         if (data) cacheToolAnalyticsParameterOwnership(data.toolAnalyticsParameterOwnership, tools);
         if (data && (0, external_context_parameters_js_namespaceObject.isContextEnabled)(data.options.context)) tools = (0, external_context_parameters_js_namespaceObject.addContextParameterToTools)(tools, (0, external_context_parameters_js_namespaceObject.getContextDescription)(data.options.context), data.logger);
-        if (data?.options.enableConversationId) tools = (0, external_conversation_id_js_namespaceObject.addConversationIdToTools)(tools, (0, external_tools_js_namespaceObject.resolveMissingCapabilityToolName)(data.options), data.logger);
-        if (data?.options.reportMissing) {
+        if (data) {
             const missingToolName = (0, external_tools_js_namespaceObject.resolveMissingCapabilityToolName)(data.options);
-            const alreadyPresent = tools.some((tool)=>tool?.name === missingToolName);
-            if (!alreadyPresent) tools.push((0, external_tools_js_namespaceObject.getReportMissingToolDescriptor)(missingToolName));
+            let injectedMissingCapabilityTool = false;
+            if (data.options.reportMissing) {
+                const alreadyPresent = tools.some((tool)=>tool?.name === missingToolName);
+                if (alreadyPresent) data.logger(`Warning: Cannot inject missing-capability tool "${missingToolName}" because a real tool already uses that name. The real tool will not be intercepted.`);
+                else {
+                    tools.push((0, external_tools_js_namespaceObject.getReportMissingToolDescriptor)(missingToolName));
+                    injectedMissingCapabilityTool = true;
+                }
+            }
+            if (data.options.enableConversationId) tools = (0, external_conversation_id_js_namespaceObject.addConversationIdToTools)(tools, missingToolName, injectedMissingCapabilityTool, data.logger);
         }
         if (data) {
             cacheToolDescriptions(data.toolDescriptions, tools);
@@ -227,7 +279,7 @@ async function getTracedToolsList(server, originalListToolsHandler, request, ext
         event.error = (0, external_exceptions_js_namespaceObject.captureException)(error);
         event.isError = true;
         event.duration = event.timestamp ? Date.now() - event.timestamp.getTime() : 0;
-        (0, external_capture_js_namespaceObject.captureEvent)(server, event, logger);
+        (0, external_capture_js_namespaceObject.captureEvent)(server, event, logger, requestAttribution);
         throw error;
     }
 }
@@ -276,19 +328,19 @@ function mintStatelessSessionOnInitialize(server, data, request, extra) {
         return;
     }
 }
-function upgradeMintedTokenToNegotiated(server, data, mintedSessionId, negotiatedProtocolVersion) {
+function upgradeMintedTokenToNegotiated(server, mintedSessionId, sessionInfo, negotiatedProtocolVersion, logger) {
     try {
         const transport = server.transport;
         if (!transport) return;
         const token = (0, external_session_token_js_namespaceObject.encodeSessionId)({
             sessionId: mintedSessionId,
-            clientName: data.sessionInfo.clientName,
-            clientVersion: data.sessionInfo.clientVersion,
+            clientName: sessionInfo.clientName,
+            clientVersion: sessionInfo.clientVersion,
             protocolVersion: negotiatedProtocolVersion
         });
         (0, external_session_token_js_namespaceObject.writeSessionIdToTransport)(transport, token);
     } catch (error) {
-        data.logger(`Warning: PostHog MCP analytics failed to upgrade the stateless session token - ${error}`);
+        logger(`Warning: PostHog MCP analytics failed to upgrade the stateless session token - ${error}`);
     }
 }
 function readInitializeClientInfo(request) {
@@ -308,7 +360,15 @@ async function handleInitializeRequest(server, originalInitializeHandler, reques
     }
     const mintedSessionId = mintStatelessSessionOnInitialize(server, data, request, extra);
     const sessionId = (0, external_session_js_namespaceObject.getSessionId)(server, extra);
-    await (0, external_internal_js_namespaceObject.handleIdentify)(server, data, sessionId, request, extra);
+    const sessionInfo = (0, external_session_js_namespaceObject.getSessionInfo)(server, data, sessionId);
+    const initializeClientInfo = readInitializeClientInfo(request);
+    const requestSessionInfo = {
+        ...sessionInfo,
+        clientName: initializeClientInfo?.name ?? sessionInfo.clientName,
+        clientVersion: initializeClientInfo?.version ?? sessionInfo.clientVersion
+    };
+    const identity = await (0, external_internal_js_namespaceObject.handleIdentify)(server, data, sessionId, request, requestSessionInfo, extra);
+    const requestAttribution = (0, external_internal_js_namespaceObject.withIdentity)(requestSessionInfo, identity);
     const event = {
         sessionId,
         resourceName: request.params?.name || 'Unknown Tool Name',
@@ -322,10 +382,18 @@ async function handleInitializeRequest(server, originalInitializeHandler, reques
     event.response = result;
     const negotiatedProtocolVersion = readProtocolVersion(result, request);
     event.protocolVersion = negotiatedProtocolVersion;
-    data.sessionInfo.protocolVersion = negotiatedProtocolVersion;
-    (0, external_internal_js_namespaceObject.setServerTrackingData)(server, data);
-    if (mintedSessionId) upgradeMintedTokenToNegotiated(server, data, mintedSessionId, negotiatedProtocolVersion);
-    (0, external_capture_js_namespaceObject.captureEvent)(server, event, data.logger);
+    if (data.sessionId === sessionId) {
+        data.sessionInfo = {
+            ...data.sessionInfo,
+            protocolVersion: negotiatedProtocolVersion
+        };
+        (0, external_internal_js_namespaceObject.setServerTrackingData)(server, data);
+    }
+    if (mintedSessionId) upgradeMintedTokenToNegotiated(server, mintedSessionId, requestSessionInfo, negotiatedProtocolVersion, data.logger);
+    (0, external_capture_js_namespaceObject.captureEvent)(server, event, data.logger, {
+        ...requestAttribution,
+        protocolVersion: negotiatedProtocolVersion
+    });
     return result;
 }
 function readProtocolVersion(result, request) {
@@ -339,6 +407,7 @@ exports.cacheToolDescriptions = __webpack_exports__.cacheToolDescriptions;
 exports.captureToolCall = __webpack_exports__.captureToolCall;
 exports.handleInitializeRequest = __webpack_exports__.handleInitializeRequest;
 exports.handleListToolsRequest = __webpack_exports__.handleListToolsRequest;
+exports.isToolAdvertised = __webpack_exports__.isToolAdvertised;
 exports.patchRequestHandlers = __webpack_exports__.patchRequestHandlers;
 exports.readToolMetaCategory = __webpack_exports__.readToolMetaCategory;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
@@ -347,6 +416,7 @@ for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "captureToolCall",
     "handleInitializeRequest",
     "handleListToolsRequest",
+    "isToolAdvertised",
     "patchRequestHandlers",
     "readToolMetaCategory"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];

package/dist/extensions/instrumentation.mjs

@@ -6,35 +6,35 @@ import { captureEvent } from "./capture.mjs";
 import { MCPAnalyticsEventType } from "./event-types.mjs";
 import { captureException } from "./exceptions.mjs";
 import { resolveToolCallIntent, setEventIntent, setExplicitContextIntent } from "./intent.mjs";
-import { getServerTrackingData, handleIdentify, setServerTrackingData } from "./internal.mjs";
+import { getServerTrackingData, handleIdentify, setServerTrackingData, withIdentity } from "./internal.mjs";
 import { buildCapturedMcpParameters } from "./mcp-payloads.mjs";
 import { getLiteralValue, getObjectShape } from "./mcp-sdk-compat.mjs";
-import { getSessionId, newSessionId } from "./session.mjs";
+import { getSessionId, getSessionInfo, newSessionId } from "./session.mjs";
 import { encodeSessionId, readMcpSessionHeader, writeSessionIdToTransport } from "./session-token.mjs";
 import { getReportMissingToolDescriptor, resolveMissingCapabilityToolName } from "./tools.mjs";
 import { applyResolvedMetadata, isToolResultError } from "./tracing-helpers.mjs";
 async function captureToolCall(params) {
     const { server, data, request, extra, execute, parameterOwnership, eventType, explicitContextIntent, takeCapturedError } = params;
-    const ownership = getActiveAnalyticsParameterOwnership(data, request.params?.name, parameterOwnership);
-    const conversation = resolveConversationId(ownership.conversationId, request.params?.arguments, request.params?.name, resolveMissingCapabilityToolName(data.options));
+    const resolvedEventType = eventType ?? MCPAnalyticsEventType.mcpToolsCall;
+    const ownership = getActiveAnalyticsParameterOwnership(data, request.params?.name, parameterOwnership, resolvedEventType === MCPAnalyticsEventType.mcpMissingCapability);
+    const conversation = resolveConversationId(ownership.conversationId, request.params?.arguments, request.params?.name, resolvedEventType === MCPAnalyticsEventType.mcpMissingCapability ? resolveMissingCapabilityToolName(data.options) : '');
     const downstreamRequest = cloneRequestWithoutOwnedAnalyticsArguments(request, ownership);
     const startTime = new Date();
-    const event = await prepareToolCallEvent(server, data, request, downstreamRequest, extra, startTime, conversation, ownership, eventType ?? MCPAnalyticsEventType.mcpToolsCall);
-    if (event && explicitContextIntent) setExplicitContextIntent(event, explicitContextIntent);
+    const preparedEvent = await prepareToolCallEvent(server, data, request, downstreamRequest, extra, startTime, conversation, ownership, resolvedEventType);
+    if (preparedEvent && explicitContextIntent) setExplicitContextIntent(preparedEvent.event, explicitContextIntent);
     let result;
     try {
         result = await execute(downstreamRequest);
     } catch (error) {
-        publishFailedToolEvent(server, event, error, startTime, conversation, data.logger);
+        publishFailedToolEvent(server, preparedEvent, error, startTime, conversation, data.logger);
         throw error;
     }
-    const finalResult = applyConversationPromptBack(event, result, conversation);
-    publishSuccessfulToolEvent(server, event, finalResult, startTime, data.logger, takeCapturedError);
+    const finalResult = applyConversationPromptBack(preparedEvent?.event ?? null, result, conversation);
+    publishSuccessfulToolEvent(server, preparedEvent, finalResult, startTime, data.logger, takeCapturedError);
     return finalResult;
 }
-function getActiveAnalyticsParameterOwnership(data, toolName, override) {
+function getActiveAnalyticsParameterOwnership(data, toolName, override, isMissingCapabilityTool) {
     const ownership = override ?? (toolName ? data.toolAnalyticsParameterOwnership.get(toolName) : void 0);
-    const isMissingCapabilityTool = toolName === resolveMissingCapabilityToolName(data.options);
     return {
         context: !isMissingCapabilityTool && isContextEnabled(data.options.context) && ownership?.context === true,
         conversationId: !isMissingCapabilityTool && true === data.options.enableConversationId && ownership?.conversationId === true
@@ -55,7 +55,9 @@ function cloneRequestWithoutOwnedAnalyticsArguments(request, ownership) {
 async function prepareToolCallEvent(server, data, request, downstreamRequest, extra, startTime, conversation, ownership, eventType) {
     try {
         const sessionId = getSessionId(server, extra);
-        await handleIdentify(server, data, sessionId, request, extra);
+        const sessionInfo = getSessionInfo(server, data, sessionId);
+        const identity = await handleIdentify(server, data, sessionId, request, sessionInfo, extra);
+        const requestAttribution = withIdentity(sessionInfo, identity);
         const toolName = request.params?.name;
         const event = {
             sessionId,
@@ -70,7 +72,10 @@ async function prepareToolCallEvent(server, data, request, downstreamRequest, ex
         stampMetaClientInfo(event, request);
         await applyResolvedMetadata(event, data, request, extra);
         setEventIntent(event, await resolveToolCallIntent(data, request, ownership.context, extra));
-        return event;
+        return {
+            event,
+            requestAttribution
+        };
     } catch (error) {
         data.logger(`Warning: PostHog MCP analytics instrumentation failed for tool ${request.params?.name}, the tool will still run - ${error}`);
         return null;
@@ -82,8 +87,9 @@ function applyConversationPromptBack(event, result, conversation) {
     if (event) event.conversationId = void 0;
     return result;
 }
-function publishSuccessfulToolEvent(server, event, result, startTime, logger, takeCapturedError) {
-    if (!event) return;
+function publishSuccessfulToolEvent(server, preparedEvent, result, startTime, logger, takeCapturedError) {
+    if (!preparedEvent) return;
+    const { event, requestAttribution } = preparedEvent;
     try {
         if (isToolResultError(result)) {
             event.isError = true;
@@ -92,49 +98,85 @@ function publishSuccessfulToolEvent(server, event, result, startTime, logger, ta
         } else event.isError = false;
         event.response = result;
         event.duration = Date.now() - startTime.getTime();
-        captureEvent(server, event, logger);
+        captureEvent(server, event, logger, requestAttribution);
     } catch (error) {
         logger(`Warning: PostHog MCP analytics failed to publish tool event - ${error}`);
     }
 }
-function publishFailedToolEvent(server, event, error, startTime, conversation, logger) {
-    if (!event) return;
+function publishFailedToolEvent(server, preparedEvent, error, startTime, conversation, logger) {
+    if (!preparedEvent) return;
+    const { event, requestAttribution } = preparedEvent;
     try {
         if (conversation.minted) event.conversationId = void 0;
         event.isError = true;
         event.error = captureException(error);
         event.duration = Date.now() - startTime.getTime();
-        captureEvent(server, event, logger);
+        captureEvent(server, event, logger, requestAttribution);
     } catch (publishError) {
         logger(`Warning: PostHog MCP analytics failed to publish failed tool event - ${publishError}`);
     }
 }
+const originalRequestHandlers = new WeakMap();
+function rememberOriginalRequestHandler(server, handlerName, originalHandler) {
+    let handlers = originalRequestHandlers.get(server);
+    if (!handlers) {
+        handlers = new Map();
+        originalRequestHandlers.set(server, handlers);
+    }
+    handlers.set(handlerName, originalHandler);
+}
 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));
+        if (originalHandler) {
+            rememberOriginalRequestHandler(server, handlerName, 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));
+        if (!patch || 'string' != typeof handlerName) return originalSetRequestHandler(requestSchema, originalHandler);
+        const result = originalSetRequestHandler(requestSchema, originalHandler);
+        const registeredHandler = server._requestHandlers.get(handlerName);
+        if (registeredHandler) {
+            rememberOriginalRequestHandler(server, handlerName, registeredHandler);
+            server._requestHandlers.set(handlerName, (request, extra)=>patch(server, registeredHandler, request, extra));
+        }
+        return result;
     };
 }
+async function isToolAdvertised(server, toolName, extra, logger) {
+    const listHandler = originalRequestHandlers.get(server)?.get('tools/list');
+    if (!listHandler || !server._requestHandlers.has('tools/list')) return;
+    try {
+        const response = await listHandler({
+            method: 'tools/list',
+            params: {}
+        }, extra);
+        if (!response || !Array.isArray(response.tools)) return;
+        return response.tools.some((tool)=>tool?.name === toolName);
+    } catch (error) {
+        logger(`Warning: PostHog MCP analytics could not determine whether "${toolName}" is advertised; delegating to the server - ${error}`);
+        return;
+    }
+}
 async function handleListToolsRequest(server, originalListToolsHandler, request, extra, logger) {
     const data = getServerTrackingData(server);
     const startTime = new Date();
+    const sessionId = getSessionId(server, extra);
+    const requestAttribution = getSessionInfo(server, data, sessionId);
     const event = {
-        sessionId: getSessionId(server, extra),
+        sessionId,
         parameters: buildCapturedMcpParameters(request),
         eventType: MCPAnalyticsEventType.mcpToolsList,
         timestamp: startTime
     };
     stampMetaClientInfo(event, request);
     if (data) await applyResolvedMetadata(event, data, request, extra);
-    const tools = await getTracedToolsList(server, originalListToolsHandler, request, extra, event, logger);
+    const tools = await getTracedToolsList(server, originalListToolsHandler, request, extra, event, logger, requestAttribution);
     if (!data) {
         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 {
@@ -146,7 +188,7 @@ async function handleListToolsRequest(server, originalListToolsHandler, request,
         event.error = captureException('No tools were sent to MCP client.');
         event.isError = true;
         event.duration = Date.now() - startTime.getTime();
-        captureEvent(server, event, data.logger);
+        captureEvent(server, event, data.logger, requestAttribution);
         return {
             tools
         };
@@ -157,7 +199,7 @@ async function handleListToolsRequest(server, originalListToolsHandler, request,
     event.listedToolNames = collectListedToolNames(tools);
     event.isError = false;
     event.duration = Date.now() - startTime.getTime();
-    captureEvent(server, event, data.logger);
+    captureEvent(server, event, data.logger, requestAttribution);
     return {
         tools
     };
@@ -170,18 +212,27 @@ function collectListedToolNames(tools) {
     const names = tools.map((tool)=>tool?.name).filter((name)=>'string' == typeof name);
     return names.length > 0 ? names : void 0;
 }
-async function getTracedToolsList(server, originalListToolsHandler, request, extra, event, logger) {
+async function getTracedToolsList(server, originalListToolsHandler, request, extra, event, logger, requestAttribution) {
     try {
         const data = getServerTrackingData(server);
         const originalResponse = await originalListToolsHandler(request, extra);
-        let tools = originalResponse.tools || [];
+        let tools = [
+            ...originalResponse.tools || []
+        ];
         if (data) cacheToolAnalyticsParameterOwnership(data.toolAnalyticsParameterOwnership, tools);
         if (data && isContextEnabled(data.options.context)) tools = addContextParameterToTools(tools, getContextDescription(data.options.context), data.logger);
-        if (data?.options.enableConversationId) tools = addConversationIdToTools(tools, resolveMissingCapabilityToolName(data.options), data.logger);
-        if (data?.options.reportMissing) {
+        if (data) {
             const missingToolName = resolveMissingCapabilityToolName(data.options);
-            const alreadyPresent = tools.some((tool)=>tool?.name === missingToolName);
-            if (!alreadyPresent) tools.push(getReportMissingToolDescriptor(missingToolName));
+            let injectedMissingCapabilityTool = false;
+            if (data.options.reportMissing) {
+                const alreadyPresent = tools.some((tool)=>tool?.name === missingToolName);
+                if (alreadyPresent) data.logger(`Warning: Cannot inject missing-capability tool "${missingToolName}" because a real tool already uses that name. The real tool will not be intercepted.`);
+                else {
+                    tools.push(getReportMissingToolDescriptor(missingToolName));
+                    injectedMissingCapabilityTool = true;
+                }
+            }
+            if (data.options.enableConversationId) tools = addConversationIdToTools(tools, missingToolName, injectedMissingCapabilityTool, data.logger);
         }
         if (data) {
             cacheToolDescriptions(data.toolDescriptions, tools);
@@ -193,7 +244,7 @@ async function getTracedToolsList(server, originalListToolsHandler, request, ext
         event.error = captureException(error);
         event.isError = true;
         event.duration = event.timestamp ? Date.now() - event.timestamp.getTime() : 0;
-        captureEvent(server, event, logger);
+        captureEvent(server, event, logger, requestAttribution);
         throw error;
     }
 }
@@ -242,19 +293,19 @@ function mintStatelessSessionOnInitialize(server, data, request, extra) {
         return;
     }
 }
-function upgradeMintedTokenToNegotiated(server, data, mintedSessionId, negotiatedProtocolVersion) {
+function upgradeMintedTokenToNegotiated(server, mintedSessionId, sessionInfo, negotiatedProtocolVersion, logger) {
     try {
         const transport = server.transport;
         if (!transport) return;
         const token = encodeSessionId({
             sessionId: mintedSessionId,
-            clientName: data.sessionInfo.clientName,
-            clientVersion: data.sessionInfo.clientVersion,
+            clientName: sessionInfo.clientName,
+            clientVersion: sessionInfo.clientVersion,
             protocolVersion: negotiatedProtocolVersion
         });
         writeSessionIdToTransport(transport, token);
     } catch (error) {
-        data.logger(`Warning: PostHog MCP analytics failed to upgrade the stateless session token - ${error}`);
+        logger(`Warning: PostHog MCP analytics failed to upgrade the stateless session token - ${error}`);
     }
 }
 function readInitializeClientInfo(request) {
@@ -274,7 +325,15 @@ async function handleInitializeRequest(server, originalInitializeHandler, reques
     }
     const mintedSessionId = mintStatelessSessionOnInitialize(server, data, request, extra);
     const sessionId = getSessionId(server, extra);
-    await handleIdentify(server, data, sessionId, request, extra);
+    const sessionInfo = getSessionInfo(server, data, sessionId);
+    const initializeClientInfo = readInitializeClientInfo(request);
+    const requestSessionInfo = {
+        ...sessionInfo,
+        clientName: initializeClientInfo?.name ?? sessionInfo.clientName,
+        clientVersion: initializeClientInfo?.version ?? sessionInfo.clientVersion
+    };
+    const identity = await handleIdentify(server, data, sessionId, request, requestSessionInfo, extra);
+    const requestAttribution = withIdentity(requestSessionInfo, identity);
     const event = {
         sessionId,
         resourceName: request.params?.name || 'Unknown Tool Name',
@@ -288,10 +347,18 @@ async function handleInitializeRequest(server, originalInitializeHandler, reques
     event.response = result;
     const negotiatedProtocolVersion = readProtocolVersion(result, request);
     event.protocolVersion = negotiatedProtocolVersion;
-    data.sessionInfo.protocolVersion = negotiatedProtocolVersion;
-    setServerTrackingData(server, data);
-    if (mintedSessionId) upgradeMintedTokenToNegotiated(server, data, mintedSessionId, negotiatedProtocolVersion);
-    captureEvent(server, event, data.logger);
+    if (data.sessionId === sessionId) {
+        data.sessionInfo = {
+            ...data.sessionInfo,
+            protocolVersion: negotiatedProtocolVersion
+        };
+        setServerTrackingData(server, data);
+    }
+    if (mintedSessionId) upgradeMintedTokenToNegotiated(server, mintedSessionId, requestSessionInfo, negotiatedProtocolVersion, data.logger);
+    captureEvent(server, event, data.logger, {
+        ...requestAttribution,
+        protocolVersion: negotiatedProtocolVersion
+    });
     return result;
 }
 function readProtocolVersion(result, request) {
@@ -300,4 +367,4 @@ function readProtocolVersion(result, request) {
     const requested = request.params?.protocolVersion;
     return 'string' == typeof requested && requested.length > 0 ? requested : void 0;
 }
-export { cacheToolCategories, cacheToolDescriptions, captureToolCall, handleInitializeRequest, handleListToolsRequest, patchRequestHandlers, readToolMetaCategory };
+export { cacheToolCategories, cacheToolDescriptions, captureToolCall, handleInitializeRequest, handleListToolsRequest, isToolAdvertised, patchRequestHandlers, readToolMetaCategory };

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

@@ -1 +1 @@
-{"version":3,"file":"intent.d.ts","sourceRoot":"","sources":["../../src/extensions/intent.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,6BAA6B,EAC7B,gBAAgB,EAChB,wBAAwB,EACxB,cAAc,EACd,QAAQ,EACT,MAAM,UAAU,CAAA;AAGjB,UAAU,cAAc;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,wBAAwB,CAAA;CACjC;AAkCD,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,cAAc,EACvB,oBAAoB,EAAE,OAAO,EAC7B,KAAK,CAAC,EAAE,6BAA6B,GACpC,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAYhC;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,cAAc,GAAG,IAAI,GAAG,IAAI,CAO3F;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAQ/E"}
+{"version":3,"file":"intent.d.ts","sourceRoot":"","sources":["../../src/extensions/intent.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,6BAA6B,EAC7B,gBAAgB,EAChB,wBAAwB,EACxB,cAAc,EACd,QAAQ,EACT,MAAM,UAAU,CAAA;AAGjB,UAAU,cAAc;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,wBAAwB,CAAA;CACjC;AAkCD,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,cAAc,EACvB,oBAAoB,EAAE,OAAO,EAC7B,KAAK,CAAC,EAAE,6BAA6B,GACpC,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAOhC;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,cAAc,GAAG,IAAI,GAAG,IAAI,CAO3F;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAQ/E"}

package/dist/extensions/intent.js

@@ -53,7 +53,7 @@ async function runIntentFallback(data, request, extra) {
 }
 async function resolveToolCallIntent(data, request, analyticsOwnsContext, extra) {
     const contextArgument = getContextArgument(request);
-    if (analyticsOwnsContext && (0, external_context_parameters_js_namespaceObject.isContextEnabled)(data.options.context) && request.params?.name !== 'get_more_tools' && contextArgument) return {
+    if (analyticsOwnsContext && (0, external_context_parameters_js_namespaceObject.isContextEnabled)(data.options.context) && contextArgument) return {
         intent: contextArgument,
         source: 'context_parameter'
     };