@posthog/mcp 0.10.6 → 0.10.7

package/dist/extensions/capture.d.ts

@@ -1,4 +1,4 @@
-import type { MCPServerLike, McpEvent } from '../types';
+import type { MCPServerLike, McpEvent, SessionInfo } from '../types';
 import type { LoggerFn } from './logger';
 /**
  * Materializes an `McpEvent` against the server's tracking data + session info,
@@ -10,5 +10,5 @@ import type { LoggerFn } from './logger';
  * Auto-capture callers (tool calls, listings, identify) intentionally ignore the
  * return value, keeping the tool path isolated from analytics latency/errors.
  */
-export declare function captureEvent(server: MCPServerLike, eventInput: McpEvent, logger: LoggerFn): Promise<void> | undefined;
+export declare function captureEvent(server: MCPServerLike, eventInput: McpEvent, logger: LoggerFn, requestAttribution?: SessionInfo): Promise<void> | undefined;
 //# sourceMappingURL=capture.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"capture.d.ts","sourceRoot":"","sources":["../../src/extensions/capture.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGxC;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CAkErH"}
+{"version":3,"file":"capture.d.ts","sourceRoot":"","sources":["../../src/extensions/capture.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAGpE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGxC;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,QAAQ,EACpB,MAAM,EAAE,QAAQ,EAChB,kBAAkB,CAAC,EAAE,WAAW,GAC/B,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CAoE3B"}

package/dist/extensions/capture.js

@@ -29,12 +29,12 @@ __webpack_require__.d(__webpack_exports__, {
 const external_event_types_js_namespaceObject = require("./event-types.js");
 const external_internal_js_namespaceObject = require("./internal.js");
 const external_session_js_namespaceObject = require("./session.js");
-function captureEvent(server, eventInput, logger) {
+function captureEvent(server, eventInput, logger, requestAttribution) {
     const data = (0, external_internal_js_namespaceObject.getServerTrackingData)(server);
     if (!data) return void logger('Warning: Server tracking data not found. Event will not be published.');
     const sink = data.sink;
     if (!sink) return;
-    const sessionInfo = (0, external_session_js_namespaceObject.getSessionInfo)(server, data, eventInput.sessionId);
+    const sessionInfo = requestAttribution ?? (0, external_session_js_namespaceObject.getSessionInfo)(server, data, eventInput.sessionId);
     const duration = eventInput.duration || (eventInput.timestamp ? Date.now() - eventInput.timestamp.getTime() : void 0);
     const fullEvent = {
         id: eventInput.id || '',

package/dist/extensions/capture.mjs

@@ -1,12 +1,12 @@
 import { MCPAnalyticsEventType } from "./event-types.mjs";
 import { getServerTrackingData } from "./internal.mjs";
 import { getSessionInfo } from "./session.mjs";
-function captureEvent(server, eventInput, logger) {
+function captureEvent(server, eventInput, logger, requestAttribution) {
     const data = getServerTrackingData(server);
     if (!data) return void logger('Warning: Server tracking data not found. Event will not be published.');
     const sink = data.sink;
     if (!sink) return;
-    const sessionInfo = getSessionInfo(server, data, eventInput.sessionId);
+    const sessionInfo = requestAttribution ?? getSessionInfo(server, data, eventInput.sessionId);
     const duration = eventInput.duration || (eventInput.timestamp ? Date.now() - eventInput.timestamp.getTime() : void 0);
     const fullEvent = {
         id: eventInput.id || '',

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

@@ -1 +1 @@
-{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/extensions/instrumentation.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/extensions/instrumentation.ts"],"names":[],"mappings":"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"}

package/dist/extensions/instrumentation.js

@@ -55,17 +55,17 @@ async function captureToolCall(params) {
     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, resolvedEventType);
-    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, isMissingCapabilityTool) {
@@ -90,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,
@@ -105,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;
@@ -117,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;
@@ -127,19 +133,20 @@ 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}`);
     }
@@ -194,15 +201,17 @@ async function isToolAdvertised(server, toolName, extra, logger) {
 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 {
@@ -214,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
         };
@@ -225,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
     };
@@ -238,7 +247,7 @@ 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);
@@ -270,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;
     }
 }
@@ -319,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) {
@@ -351,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',
@@ -365,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) {

package/dist/extensions/instrumentation.mjs

@@ -6,10 +6,10 @@ 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";
@@ -20,17 +20,17 @@ async function captureToolCall(params) {
     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, resolvedEventType);
-    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, isMissingCapabilityTool) {
@@ -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,19 +98,20 @@ 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}`);
     }
@@ -159,15 +166,17 @@ async function isToolAdvertised(server, toolName, extra, logger) {
 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 {
@@ -179,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
         };
@@ -190,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
     };
@@ -203,7 +212,7 @@ 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);
@@ -235,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;
     }
 }
@@ -284,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) {
@@ -316,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',
@@ -330,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) {

package/dist/extensions/internal.d.ts

@@ -1,4 +1,4 @@
-import type { CompatibleRequestHandlerExtra, MCPAnalyticsData, MCPRequestLike, MCPServerLike, UserIdentity } from '../types';
+import type { CompatibleRequestHandlerExtra, MCPAnalyticsData, MCPRequestLike, MCPServerLike, SessionInfo, UserIdentity } from '../types';
 /**
  * Bounded LRU cache for session identities, capped at `maxSize` entries so a
  * long-lived server can't accumulate identities for unboundedly many sessions.
@@ -24,7 +24,8 @@ export declare function mergeIdentities(previous: UserIdentity | undefined, next
  * `$identify` event at most once per session: at `initialize`, when a
  * long-lived server first sees the identity, or when it materially changes.
  */
-export declare function handleIdentify(server: MCPServerLike, data: MCPAnalyticsData, sessionId: string, request: MCPRequestLike, extra?: CompatibleRequestHandlerExtra): Promise<void>;
+export declare function handleIdentify(server: MCPServerLike, data: MCPAnalyticsData, sessionId: string, request: MCPRequestLike, requestAttribution: SessionInfo, extra?: CompatibleRequestHandlerExtra): Promise<UserIdentity | undefined>;
+export declare function withIdentity(sessionInfo: SessionInfo, identity: UserIdentity | undefined): SessionInfo;
 /**
  * Resolves the `eventProperties` callback. Returns null when no callback is
  * configured, or when it returns nullish or throws — a throw never propagates

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

@@ -1 +1 @@
-{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../src/extensions/internal.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,6BAA6B,EAC7B,gBAAgB,EAChB,cAAc,EACd,aAAa,EAEb,YAAY,EACb,MAAM,UAAU,CAAA;AAKjB;;;;;GAKG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkC;IACzD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;gBAErB,OAAO,SAAO;IAI1B,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAWhD,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,GAAG,IAAI;IAapD,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI/B,IAAI,IAAI,MAAM;CAGf;AAID,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,GAAG,gBAAgB,GAAG,SAAS,CAEzF;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAEzF;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,GAAG,OAAO,CA4B5E;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,YAAY,GAAG,SAAS,EAAE,IAAI,EAAE,YAAY,GAAG,YAAY,CAapG;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,gBAAgB,EACtB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,cAAc,EACvB,KAAK,CAAC,EAAE,6BAA6B,GACpC,OAAO,CAAC,IAAI,CAAC,CAkDf;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,cAAc,EACvB,KAAK,CAAC,EAAE,6BAA6B,GACpC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,CAUzC"}
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../src/extensions/internal.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,6BAA6B,EAC7B,gBAAgB,EAChB,cAAc,EACd,aAAa,EAEb,WAAW,EACX,YAAY,EACb,MAAM,UAAU,CAAA;AAKjB;;;;;GAKG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkC;IACzD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;gBAErB,OAAO,SAAO;IAI1B,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAWhD,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,GAAG,IAAI;IAapD,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI/B,IAAI,IAAI,MAAM;CAGf;AAID,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,GAAG,gBAAgB,GAAG,SAAS,CAEzF;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAEzF;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,GAAG,OAAO,CA4B5E;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,YAAY,GAAG,SAAS,EAAE,IAAI,EAAE,YAAY,GAAG,YAAY,CAapG;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,gBAAgB,EACtB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,cAAc,EACvB,kBAAkB,EAAE,WAAW,EAC/B,KAAK,CAAC,EAAE,6BAA6B,GACpC,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAsDnC;AAED,wBAAgB,YAAY,CAAC,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,GAAG,SAAS,GAAG,WAAW,CAOtG;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,cAAc,EACvB,KAAK,CAAC,EAAE,6BAA6B,GACpC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,CAUzC"}

package/dist/extensions/internal.js

@@ -26,11 +26,12 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     mergeIdentities: ()=>mergeIdentities,
     areIdentitiesEqual: ()=>areIdentitiesEqual,
+    getServerTrackingData: ()=>getServerTrackingData,
+    setServerTrackingData: ()=>setServerTrackingData,
     resolveEventProperties: ()=>resolveEventProperties,
+    withIdentity: ()=>withIdentity,
     handleIdentify: ()=>handleIdentify,
-    getServerTrackingData: ()=>getServerTrackingData,
-    IdentityCache: ()=>IdentityCache,
-    setServerTrackingData: ()=>setServerTrackingData
+    IdentityCache: ()=>IdentityCache
 });
 const external_event_types_js_namespaceObject = require("./event-types.js");
 const external_capture_js_namespaceObject = require("./capture.js");
@@ -94,8 +95,10 @@ function mergeIdentities(previous, next) {
         groups: next.groups ?? previous.groups
     };
 }
-async function handleIdentify(server, data, sessionId, request, extra) {
-    if (!data.options.identify) return;
+async function handleIdentify(server, data, sessionId, request, requestAttribution, extra) {
+    const identityBeforeRequest = data.identifiedSessions.get(sessionId);
+    const sessionSourceBeforeIdentify = data.sessionSource;
+    if (!data.options.identify) return identityBeforeRequest;
     const identifyEvent = {
         sessionId,
         resourceName: getRequestResourceName(request),
@@ -114,17 +117,28 @@ async function handleIdentify(server, data, sessionId, request, extra) {
             const mergedIdentity = mergeIdentities(previousIdentity, identityResult);
             const changed = void 0 !== previousIdentity && !areIdentitiesEqual(previousIdentity, mergedIdentity);
             const firstSeen = void 0 === previousIdentity;
-            const announcedAtInitialize = 'token' === data.sessionSource && 'initialize' !== request.method;
+            const announcedAtInitialize = 'token' === sessionSourceBeforeIdentify && 'initialize' !== request.method;
             const shouldPublish = changed || firstSeen && !announcedAtInitialize;
             data.identifiedSessions.set(sessionId, mergedIdentity);
             if (shouldPublish) {
                 data.logger(`Identified session ${sessionId}`);
-                (0, external_capture_js_namespaceObject.captureEvent)(server, identifyEvent, data.logger);
+                (0, external_capture_js_namespaceObject.captureEvent)(server, identifyEvent, data.logger, withIdentity(requestAttribution, mergedIdentity));
             }
-        } else data.logger(`Warning: Supplied identify function returned null for session ${sessionId}`);
+            return mergedIdentity;
+        }
+        data.logger(`Warning: Supplied identify function returned null for session ${sessionId}`);
     } catch (error) {
         data.logger(`Error: User supplied identify function threw an error while identifying session ${sessionId} - ${error}`);
     }
+    return identityBeforeRequest;
+}
+function withIdentity(sessionInfo, identity) {
+    return {
+        ...sessionInfo,
+        identifyActorGivenId: identity?.distinctId,
+        identifyActorData: identity?.properties || {},
+        identifyActorGroups: identity?.groups
+    };
 }
 async function resolveEventProperties(data, request, extra) {
     if (!data.options.eventProperties) return null;
@@ -148,6 +162,7 @@ exports.handleIdentify = __webpack_exports__.handleIdentify;
 exports.mergeIdentities = __webpack_exports__.mergeIdentities;
 exports.resolveEventProperties = __webpack_exports__.resolveEventProperties;
 exports.setServerTrackingData = __webpack_exports__.setServerTrackingData;
+exports.withIdentity = __webpack_exports__.withIdentity;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "IdentityCache",
     "areIdentitiesEqual",
@@ -155,7 +170,8 @@ for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "handleIdentify",
     "mergeIdentities",
     "resolveEventProperties",
-    "setServerTrackingData"
+    "setServerTrackingData",
+    "withIdentity"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/extensions/internal.mjs

@@ -60,8 +60,10 @@ function mergeIdentities(previous, next) {
         groups: next.groups ?? previous.groups
     };
 }
-async function handleIdentify(server, data, sessionId, request, extra) {
-    if (!data.options.identify) return;
+async function handleIdentify(server, data, sessionId, request, requestAttribution, extra) {
+    const identityBeforeRequest = data.identifiedSessions.get(sessionId);
+    const sessionSourceBeforeIdentify = data.sessionSource;
+    if (!data.options.identify) return identityBeforeRequest;
     const identifyEvent = {
         sessionId,
         resourceName: getRequestResourceName(request),
@@ -80,17 +82,28 @@ async function handleIdentify(server, data, sessionId, request, extra) {
             const mergedIdentity = mergeIdentities(previousIdentity, identityResult);
             const changed = void 0 !== previousIdentity && !areIdentitiesEqual(previousIdentity, mergedIdentity);
             const firstSeen = void 0 === previousIdentity;
-            const announcedAtInitialize = 'token' === data.sessionSource && 'initialize' !== request.method;
+            const announcedAtInitialize = 'token' === sessionSourceBeforeIdentify && 'initialize' !== request.method;
             const shouldPublish = changed || firstSeen && !announcedAtInitialize;
             data.identifiedSessions.set(sessionId, mergedIdentity);
             if (shouldPublish) {
                 data.logger(`Identified session ${sessionId}`);
-                captureEvent(server, identifyEvent, data.logger);
+                captureEvent(server, identifyEvent, data.logger, withIdentity(requestAttribution, mergedIdentity));
             }
-        } else data.logger(`Warning: Supplied identify function returned null for session ${sessionId}`);
+            return mergedIdentity;
+        }
+        data.logger(`Warning: Supplied identify function returned null for session ${sessionId}`);
     } catch (error) {
         data.logger(`Error: User supplied identify function threw an error while identifying session ${sessionId} - ${error}`);
     }
+    return identityBeforeRequest;
+}
+function withIdentity(sessionInfo, identity) {
+    return {
+        ...sessionInfo,
+        identifyActorGivenId: identity?.distinctId,
+        identifyActorData: identity?.properties || {},
+        identifyActorGroups: identity?.groups
+    };
 }
 async function resolveEventProperties(data, request, extra) {
     if (!data.options.eventProperties) return null;
@@ -107,4 +120,4 @@ function getRequestResourceName(request) {
     if (!params || 'object' != typeof params || !('name' in params)) return 'Unknown';
     return 'string' == typeof params.name ? params.name : 'Unknown';
 }
-export { IdentityCache, areIdentitiesEqual, getServerTrackingData, handleIdentify, mergeIdentities, resolveEventProperties, setServerTrackingData };
+export { IdentityCache, areIdentitiesEqual, getServerTrackingData, handleIdentify, mergeIdentities, resolveEventProperties, setServerTrackingData, withIdentity };

package/dist/extensions/session.js

@@ -90,7 +90,9 @@ function getSessionInfo(server, data, sessionId) {
     if (!data) return sessionInfo;
     data.sessionInfo = sessionInfo;
     (0, external_internal_js_namespaceObject.setServerTrackingData)(server, data);
-    return data.sessionInfo;
+    return {
+        ...sessionInfo
+    };
 }
 exports.deriveSessionIdFromMCPSession = __webpack_exports__.deriveSessionIdFromMCPSession;
 exports.getSessionId = __webpack_exports__.getSessionId;

package/dist/extensions/session.mjs

@@ -59,6 +59,8 @@ function getSessionInfo(server, data, sessionId) {
     if (!data) return sessionInfo;
     data.sessionInfo = sessionInfo;
     setServerTrackingData(server, data);
-    return data.sessionInfo;
+    return {
+        ...sessionInfo
+    };
 }
 export { deriveSessionIdFromMCPSession, getSessionId, getSessionInfo, newSessionId };

package/dist/version.d.ts

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

package/dist/version.js

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

package/dist/version.mjs

@@ -1,2 +1,2 @@
-const version = '0.10.6';
+const version = '0.10.7';
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/mcp",
-  "version": "0.10.6",
+  "version": "0.10.7",
   "bugs": {
     "url": "https://github.com/PostHog/posthog-js/issues"
   },
@@ -39,8 +39,8 @@
     "@types/node": "^20.0.0",
     "jest": "29.7.0",
     "zod": "^3.25.0",
-    "posthog-node": "^5.47.8",
-    "@posthog-tooling/tsconfig-base": "1.1.1"
+    "@posthog-tooling/tsconfig-base": "1.1.1",
+    "posthog-node": "^5.47.9"
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": ">=1.26.0",

package/src/extensions/capture.ts

@@ -3,7 +3,7 @@
 // Copyright (c) 2025 AgentCat, Inc. (formerly MCPcat)
 // Licensed under the MIT License: https://github.com/agentcathq/agentcat-typescript-sdk/blob/main/LICENSE
 
-import type { MCPServerLike, McpEvent } from '../types'
+import type { MCPServerLike, McpEvent, SessionInfo } from '../types'
 import { MCPAnalyticsEventType } from './event-types'
 import { getServerTrackingData } from './internal'
 import type { LoggerFn } from './logger'
@@ -19,7 +19,12 @@ import { getSessionInfo } from './session'
  * Auto-capture callers (tool calls, listings, identify) intentionally ignore the
  * return value, keeping the tool path isolated from analytics latency/errors.
  */
-export function captureEvent(server: MCPServerLike, eventInput: McpEvent, logger: LoggerFn): Promise<void> | undefined {
+export function captureEvent(
+  server: MCPServerLike,
+  eventInput: McpEvent,
+  logger: LoggerFn,
+  requestAttribution?: SessionInfo
+): Promise<void> | undefined {
   const data = getServerTrackingData(server)
   if (!data) {
     logger('Warning: Server tracking data not found. Event will not be published.')
@@ -31,7 +36,10 @@ export function captureEvent(server: MCPServerLike, eventInput: McpEvent, logger
     return
   }
 
-  const sessionInfo = getSessionInfo(server, data, eventInput.sessionId)
+  // Instrumented request paths pass an immutable snapshot resolved before any
+  // user callback or handler can yield to a concurrent request. Custom capture
+  // has no request context, so it intentionally falls back to current state.
+  const sessionInfo = requestAttribution ?? getSessionInfo(server, data, eventInput.sessionId)
 
   const duration =
     eventInput.duration || (eventInput.timestamp ? Date.now() - eventInput.timestamp.getTime() : undefined)
@@ -48,9 +56,8 @@ export function captureEvent(server: MCPServerLike, eventInput: McpEvent, logger
     sdkVersion: sessionInfo.sdkVersion,
     serverName: sessionInfo.serverName,
     serverVersion: sessionInfo.serverVersion,
-    // Prefer identity the event captured for *this* request (from `_meta`, see
-    // stampMetaClientInfo) over the server-wide sessionInfo, so a concurrent
-    // request from another client can't misattribute this one.
+    // Prefer client metadata stamped onto this event from the request's `_meta`
+    // over sessionInfo, so concurrent stateless requests stay isolated.
     clientName: eventInput.clientName ?? sessionInfo.clientName,
     clientVersion: eventInput.clientVersion ?? sessionInfo.clientVersion,
     identifyActorGivenId: sessionInfo.identifyActorGivenId,

package/src/extensions/instrumentation.ts

@@ -12,6 +12,7 @@ import type {
   MCPServerLike,
   McpEvent,
   ServerClientInfoLike,
+  SessionInfo,
 } from '../types'
 import { getAnalyticsParameterOwnership, stripOwnedAnalyticsArguments } from './analytics-parameters'
 import { addContextParameterToTools, getContextDescription, isContextEnabled } from './context-parameters'
@@ -27,11 +28,11 @@ import { captureEvent } from './capture'
 import { MCPAnalyticsEventType } from './event-types'
 import { captureException } from './exceptions'
 import { resolveToolCallIntent, setEventIntent, setExplicitContextIntent } from './intent'
-import { getServerTrackingData, handleIdentify, setServerTrackingData } from './internal'
+import { getServerTrackingData, handleIdentify, setServerTrackingData, withIdentity } from './internal'
 import type { LoggerFn } from './logger'
 import { buildCapturedMcpParameters } from './mcp-payloads'
 import { getLiteralValue, getObjectShape } from './mcp-sdk-compat'
-import { getSessionId, newSessionId } from './session'
+import { getSessionId, getSessionInfo, newSessionId } from './session'
 import { encodeSessionId, readMcpSessionHeader, writeSessionIdToTransport } from './session-token'
 import { getReportMissingToolDescriptor, resolveMissingCapabilityToolName } from './tools'
 import { applyResolvedMetadata, isToolResultError } from './tracing-helpers'
@@ -118,7 +119,7 @@ export async function captureToolCall(params: TraceToolCallParams): Promise<unkn
   // Prepare the event in isolation: if identity/metadata/intent resolution
   // throws, we drop instrumentation for this call but still run the tool.
   const startTime = new Date()
-  const event = await prepareToolCallEvent(
+  const preparedEvent = await prepareToolCallEvent(
     server,
     data,
     request,
@@ -129,23 +130,28 @@ export async function captureToolCall(params: TraceToolCallParams): Promise<unkn
     ownership,
     resolvedEventType
   )
-  if (event && explicitContextIntent) {
-    setExplicitContextIntent(event, explicitContextIntent)
+  if (preparedEvent && explicitContextIntent) {
+    setExplicitContextIntent(preparedEvent.event, explicitContextIntent)
   }
 
   let result: unknown
   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
 }
 
+interface PreparedToolEvent {
+  event: McpEvent
+  requestAttribution: SessionInfo
+}
+
 function getActiveAnalyticsParameterOwnership(
   data: MCPAnalyticsData,
   toolName: string | undefined,
@@ -188,10 +194,14 @@ async function prepareToolCallEvent(
   conversation: ConversationIdResolution,
   ownership: AnalyticsParameterOwnership,
   eventType: MCPAnalyticsEventType
-): Promise<McpEvent | null> {
+): Promise<PreparedToolEvent | null> {
   try {
     const sessionId = getSessionId(server, extra)
-    await handleIdentify(server, data, sessionId, request, extra)
+    // Snapshot token/client/protocol metadata synchronously, before identify or
+    // metadata callbacks can yield and let another request replace shared state.
+    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: McpEvent = {
@@ -211,7 +221,7 @@ async function prepareToolCallEvent(
 
     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}`
@@ -244,15 +254,16 @@ function applyConversationPromptBack(
 
 function publishSuccessfulToolEvent(
   server: MCPServerLike,
-  event: McpEvent | null,
+  preparedEvent: PreparedToolEvent | null,
   result: unknown,
   startTime: Date,
   logger: LoggerFn,
   takeCapturedError?: () => unknown
 ): void {
-  if (!event) {
+  if (!preparedEvent) {
     return
   }
+  const { event, requestAttribution } = preparedEvent
   try {
     if (isToolResultError(result)) {
       event.isError = true
@@ -263,7 +274,7 @@ function publishSuccessfulToolEvent(
     }
     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}`)
   }
@@ -271,15 +282,16 @@ function publishSuccessfulToolEvent(
 
 function publishFailedToolEvent(
   server: MCPServerLike,
-  event: McpEvent | null,
+  preparedEvent: PreparedToolEvent | null,
   error: unknown,
   startTime: Date,
   conversation: ConversationIdResolution,
   logger: LoggerFn
 ): void {
-  if (!event) {
+  if (!preparedEvent) {
     return
   }
+  const { event, requestAttribution } = preparedEvent
   try {
     if (conversation.minted) {
       event.conversationId = undefined
@@ -287,7 +299,7 @@ function publishFailedToolEvent(
     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}`)
   }
@@ -407,8 +419,12 @@ export async function handleListToolsRequest(
 ): Promise<{ tools: ListToolsResult['tools'] }> {
   const data = getServerTrackingData(server)
   const startTime = new Date()
+  const sessionId = getSessionId(server, extra)
+  // Snapshot before metadata resolution or the list handler can yield to a
+  // concurrent request using the same instrumented server.
+  const requestAttribution = getSessionInfo(server, data, sessionId)
   const event: McpEvent = {
-    sessionId: getSessionId(server, extra),
+    sessionId,
     parameters: buildCapturedMcpParameters(request),
     eventType: MCPAnalyticsEventType.mcpToolsList,
     timestamp: startTime,
@@ -419,7 +435,15 @@ export async function handleListToolsRequest(
     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(
@@ -435,7 +459,7 @@ export async function handleListToolsRequest(
     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 }
   }
 
@@ -443,7 +467,7 @@ export async function handleListToolsRequest(
   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 }
 }
 
@@ -473,7 +497,8 @@ async function getTracedToolsList(
   request: MCPRequestLike,
   extra: CompatibleRequestHandlerExtra | undefined,
   event: McpEvent,
-  logger: LoggerFn
+  logger: LoggerFn,
+  requestAttribution: SessionInfo
 ): Promise<ListToolsResult['tools']> {
   try {
     const data = getServerTrackingData(server)
@@ -521,7 +546,7 @@ async function getTracedToolsList(
     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
   }
 }
@@ -630,9 +655,10 @@ function mintStatelessSessionOnInitialize(
  */
 function upgradeMintedTokenToNegotiated(
   server: MCPServerLike,
-  data: MCPAnalyticsData,
   mintedSessionId: string,
-  negotiatedProtocolVersion: string | undefined
+  sessionInfo: SessionInfo,
+  negotiatedProtocolVersion: string | undefined,
+  logger: LoggerFn
 ): void {
   try {
     const transport = server.transport
@@ -641,13 +667,13 @@ function upgradeMintedTokenToNegotiated(
     }
     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}`)
   }
 }
 
@@ -689,7 +715,17 @@ export async function handleInitializeRequest(
   // Mint first so the `$mcp_initialize` event below already carries the minted id.
   const mintedSessionId = mintStatelessSessionOnInitialize(server, data, request, extra)
   const sessionId = getSessionId(server, extra)
-  await handleIdentify(server, data, sessionId, request, extra)
+  // Snapshot before identify, metadata, or the initialize handler can yield to
+  // another request using the same instrumented server.
+  const sessionInfo = getSessionInfo(server, data, sessionId)
+  const initializeClientInfo = readInitializeClientInfo(request)
+  const requestSessionInfo: SessionInfo = {
+    ...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: McpEvent = {
     sessionId,
@@ -712,12 +748,19 @@ export async function handleInitializeRequest(
   // re-mint the token so pods replaying it report the negotiated version too.
   const negotiatedProtocolVersion = readProtocolVersion(result, request)
   event.protocolVersion = negotiatedProtocolVersion
-  data.sessionInfo.protocolVersion = negotiatedProtocolVersion
-  setServerTrackingData(server, data)
+  // Do not let a delayed initialize overwrite whichever session became current
+  // while its callbacks or the original handler were awaiting.
+  if (data.sessionId === sessionId) {
+    data.sessionInfo = { ...data.sessionInfo, protocolVersion: negotiatedProtocolVersion }
+    setServerTrackingData(server, data)
+  }
   if (mintedSessionId) {
-    upgradeMintedTokenToNegotiated(server, data, mintedSessionId, negotiatedProtocolVersion)
+    upgradeMintedTokenToNegotiated(server, mintedSessionId, requestSessionInfo, negotiatedProtocolVersion, data.logger)
   }
-  captureEvent(server, event, data.logger)
+  captureEvent(server, event, data.logger, {
+    ...requestAttribution,
+    protocolVersion: negotiatedProtocolVersion,
+  })
   return result
 }
 

package/src/extensions/internal.ts

@@ -9,6 +9,7 @@ import type {
   MCPRequestLike,
   MCPServerLike,
   McpEvent,
+  SessionInfo,
   UserIdentity,
 } from '../types'
 import { MCPAnalyticsEventType } from './event-types'
@@ -128,10 +129,13 @@ export async function handleIdentify(
   data: MCPAnalyticsData,
   sessionId: string,
   request: MCPRequestLike,
+  requestAttribution: SessionInfo,
   extra?: CompatibleRequestHandlerExtra
-): Promise<void> {
+): Promise<UserIdentity | undefined> {
+  const identityBeforeRequest = data.identifiedSessions.get(sessionId)
+  const sessionSourceBeforeIdentify = data.sessionSource
   if (!data.options.identify) {
-    return
+    return identityBeforeRequest
   }
 
   const identifyEvent: McpEvent = {
@@ -162,23 +166,34 @@ export async function handleIdentify(
       // announced); revisit with the stateless-by-default rework.
       const changed = previousIdentity !== undefined && !areIdentitiesEqual(previousIdentity, mergedIdentity)
       const firstSeen = previousIdentity === undefined
-      const announcedAtInitialize = data.sessionSource === 'token' && request.method !== 'initialize'
+      const announcedAtInitialize = sessionSourceBeforeIdentify === 'token' && request.method !== 'initialize'
       const shouldPublish = changed || (firstSeen && !announcedAtInitialize)
 
       data.identifiedSessions.set(sessionId, mergedIdentity)
 
       if (shouldPublish) {
         data.logger(`Identified session ${sessionId}`)
-        captureEvent(server, identifyEvent, data.logger)
+        captureEvent(server, identifyEvent, data.logger, withIdentity(requestAttribution, mergedIdentity))
       }
-    } else {
-      data.logger(`Warning: Supplied identify function returned null for session ${sessionId}`)
+      return mergedIdentity
     }
+
+    data.logger(`Warning: Supplied identify function returned null for session ${sessionId}`)
   } catch (error) {
     data.logger(
       `Error: User supplied identify function threw an error while identifying session ${sessionId} - ${error}`
     )
   }
+  return identityBeforeRequest
+}
+
+export function withIdentity(sessionInfo: SessionInfo, identity: UserIdentity | undefined): SessionInfo {
+  return {
+    ...sessionInfo,
+    identifyActorGivenId: identity?.distinctId,
+    identifyActorData: identity?.properties || {},
+    identifyActorGroups: identity?.groups,
+  }
 }
 
 /**

package/src/extensions/session.ts

@@ -125,5 +125,5 @@ export function getSessionInfo(
 
   data.sessionInfo = sessionInfo
   setServerTrackingData(server, data)
-  return data.sessionInfo
+  return { ...sessionInfo }
 }

package/src/version.ts

@@ -1 +1 @@
-export const version = '0.10.6'
+export const version = '0.10.7'