@posthog/mcp 0.0.9 → 0.1.16

package/dist/extensions/instrumentation.js

@@ -0,0 +1,237 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    cacheToolDescriptions: ()=>cacheToolDescriptions,
+    captureToolCall: ()=>captureToolCall,
+    instrumentInitializeHandler: ()=>instrumentInitializeHandler,
+    instrumentToolsListHandler: ()=>instrumentToolsListHandler
+});
+const types_js_namespaceObject = require("@modelcontextprotocol/sdk/types.js");
+const external_context_parameters_js_namespaceObject = require("./context-parameters.js");
+const external_conversation_id_js_namespaceObject = require("./conversation-id.js");
+const external_capture_js_namespaceObject = require("./capture.js");
+const external_event_types_js_namespaceObject = require("./event-types.js");
+const external_exceptions_js_namespaceObject = require("./exceptions.js");
+const external_intent_js_namespaceObject = require("./intent.js");
+const external_internal_js_namespaceObject = require("./internal.js");
+const external_logger_js_namespaceObject = require("./logger.js");
+const external_mcp_payloads_js_namespaceObject = require("./mcp-payloads.js");
+const external_session_js_namespaceObject = require("./session.js");
+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, eventType, explicitContextIntent, takeCapturedError } = params;
+    const conversation = (0, external_conversation_id_js_namespaceObject.resolveConversationId)(data.options.enableConversationId ?? false, request.params?.arguments, request.params?.name);
+    const downstreamRequest = conversation.conversationId ? (0, external_conversation_id_js_namespaceObject.cloneRequestWithoutConversationId)(request) : request;
+    const startTime = new Date();
+    const event = await prepareToolCallEvent(server, data, request, downstreamRequest, extra, startTime, conversation, eventType ?? external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpToolsCall);
+    if (event && explicitContextIntent) (0, external_intent_js_namespaceObject.setExplicitContextIntent)(event, explicitContextIntent);
+    let result;
+    try {
+        result = await execute(downstreamRequest);
+    } catch (error) {
+        publishFailedToolEvent(server, event, error, startTime, conversation);
+        throw error;
+    }
+    const finalResult = applyConversationPromptBack(event, result, conversation);
+    publishSuccessfulToolEvent(server, event, finalResult, startTime, takeCapturedError);
+    return finalResult;
+}
+async function prepareToolCallEvent(server, data, request, downstreamRequest, extra, startTime, conversation, eventType) {
+    try {
+        const sessionId = (0, external_session_js_namespaceObject.getServerSessionId)(server, extra);
+        await (0, external_internal_js_namespaceObject.handleIdentify)(server, data, sessionId, request, extra);
+        const toolName = request.params?.name;
+        const event = {
+            sessionId,
+            conversationId: conversation.conversationId,
+            resourceName: toolName || 'Unknown Tool Name',
+            parameters: (0, external_mcp_payloads_js_namespaceObject.buildCapturedMcpParameters)(downstreamRequest),
+            eventType,
+            timestamp: startTime,
+            toolDescription: toolName ? data.toolDescriptions.get(toolName) : void 0
+        };
+        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, extra));
+        return event;
+    } catch (error) {
+        (0, external_logger_js_namespaceObject.log)(`Warning: PostHog MCP analytics instrumentation failed for tool ${request.params?.name}, the tool will still run - ${error}`);
+        return null;
+    }
+}
+function applyConversationPromptBack(event, result, conversation) {
+    if (!conversation.minted) return result;
+    if ((0, external_conversation_id_js_namespaceObject.canInjectConversationIdPromptBack)(result)) return (0, external_conversation_id_js_namespaceObject.injectConversationIdPromptBack)(result, conversation.conversationId);
+    if (event) event.conversationId = void 0;
+    return result;
+}
+function publishSuccessfulToolEvent(server, event, result, startTime, takeCapturedError) {
+    if (!event) return;
+    try {
+        if ((0, external_tracing_helpers_js_namespaceObject.isToolResultError)(result)) {
+            event.isError = true;
+            const capturedError = takeCapturedError?.();
+            event.error = (0, external_exceptions_js_namespaceObject.captureException)(capturedError ?? result);
+        } else event.isError = false;
+        event.response = result;
+        event.duration = Date.now() - startTime.getTime();
+        (0, external_capture_js_namespaceObject.captureEvent)(server, event);
+    } catch (error) {
+        (0, external_logger_js_namespaceObject.log)(`Warning: PostHog MCP analytics failed to publish tool event - ${error}`);
+    }
+}
+function publishFailedToolEvent(server, event, error, startTime, conversation) {
+    if (!event) return;
+    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);
+    } catch (publishError) {
+        (0, external_logger_js_namespaceObject.log)(`Warning: PostHog MCP analytics failed to publish failed tool event - ${publishError}`);
+    }
+}
+const listToolsTracingSetup = new WeakMap();
+function instrumentToolsListHandler(server) {
+    if (!server._capabilities?.tools) return;
+    if (listToolsTracingSetup.get(server)) return;
+    const originalListToolsHandler = server._requestHandlers.get('tools/list');
+    if (!originalListToolsHandler) return;
+    try {
+        server.setRequestHandler(types_js_namespaceObject.ListToolsRequestSchema, async (request, extra)=>await handleListToolsRequest(server, originalListToolsHandler, request, extra));
+        listToolsTracingSetup.set(server, true);
+    } catch (error) {
+        (0, external_logger_js_namespaceObject.log)(`Warning: Failed to override list tools handler - ${error}`);
+    }
+}
+async function handleListToolsRequest(server, originalListToolsHandler, request, extra) {
+    const data = (0, external_internal_js_namespaceObject.getServerTrackingData)(server);
+    const startTime = new Date();
+    const event = {
+        sessionId: (0, external_session_js_namespaceObject.getServerSessionId)(server, extra),
+        parameters: (0, external_mcp_payloads_js_namespaceObject.buildCapturedMcpParameters)(request),
+        eventType: external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpToolsList,
+        timestamp: startTime
+    };
+    if (data) await (0, external_tracing_helpers_js_namespaceObject.applyResolvedMetadata)(event, data, request, extra);
+    const tools = await getTracedToolsList(server, originalListToolsHandler, request, extra, event);
+    if (!data) {
+        (0, external_logger_js_namespaceObject.log)('Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using tool calls.');
+        return {
+            tools
+        };
+    }
+    if (0 === tools.length) {
+        (0, external_logger_js_namespaceObject.log)('Warning: No tools found in the original list. This is likely due to the tools not being registered before PostHog MCP analytics.instrument().');
+        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);
+        return {
+            tools
+        };
+    }
+    event.response = {
+        tools
+    };
+    event.listedToolNames = collectListedToolNames(tools);
+    event.isError = false;
+    event.duration = Date.now() - startTime.getTime();
+    (0, external_capture_js_namespaceObject.captureEvent)(server, event);
+    return {
+        tools
+    };
+}
+function collectListedToolNames(tools) {
+    if (!tools || 0 === tools.length) return;
+    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) {
+    try {
+        const data = (0, external_internal_js_namespaceObject.getServerTrackingData)(server);
+        const originalResponse = await originalListToolsHandler(request, extra);
+        let tools = originalResponse.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));
+        if (data?.options.enableConversationId) tools = (0, external_conversation_id_js_namespaceObject.addConversationIdToTools)(tools);
+        if (data?.options.reportMissing) {
+            const alreadyPresent = tools.some((tool)=>tool?.name === external_tools_js_namespaceObject.GET_MORE_TOOLS_NAME);
+            if (!alreadyPresent) tools.push((0, external_tools_js_namespaceObject.getReportMissingToolDescriptor)());
+        }
+        if (data) cacheToolDescriptions(data.toolDescriptions, tools);
+        return tools;
+    } catch (error) {
+        (0, external_logger_js_namespaceObject.log)(`Warning: Original list tools handler failed, this suggests an error PostHog MCP analytics did not cause - ${error}`);
+        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);
+        throw error;
+    }
+}
+function cacheToolDescriptions(cache, tools) {
+    if (!tools) return;
+    for (const tool of tools)if (tool?.name && 'string' == typeof tool.description) cache.set(tool.name, tool.description);
+}
+function instrumentInitializeHandler(server) {
+    const originalInitializeHandler = server._requestHandlers.get('initialize');
+    if (!originalInitializeHandler) return;
+    server.setRequestHandler(types_js_namespaceObject.InitializeRequestSchema, async (request, extra)=>{
+        const data = (0, external_internal_js_namespaceObject.getServerTrackingData)(server);
+        if (!data) {
+            (0, external_logger_js_namespaceObject.log)('Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using tool calls.');
+            return await originalInitializeHandler(request, extra);
+        }
+        const sessionId = (0, external_session_js_namespaceObject.getServerSessionId)(server, extra);
+        await (0, external_internal_js_namespaceObject.handleIdentify)(server, data, sessionId, request, extra);
+        const event = {
+            sessionId,
+            resourceName: request.params?.name || 'Unknown Tool Name',
+            eventType: external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpInitialize,
+            parameters: (0, external_mcp_payloads_js_namespaceObject.buildCapturedMcpParameters)(request),
+            timestamp: new Date()
+        };
+        await (0, external_tracing_helpers_js_namespaceObject.applyResolvedMetadata)(event, data, request, extra);
+        const result = await originalInitializeHandler(request, extra);
+        event.response = result;
+        (0, external_capture_js_namespaceObject.captureEvent)(server, event);
+        return result;
+    });
+}
+exports.cacheToolDescriptions = __webpack_exports__.cacheToolDescriptions;
+exports.captureToolCall = __webpack_exports__.captureToolCall;
+exports.instrumentInitializeHandler = __webpack_exports__.instrumentInitializeHandler;
+exports.instrumentToolsListHandler = __webpack_exports__.instrumentToolsListHandler;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "cacheToolDescriptions",
+    "captureToolCall",
+    "instrumentInitializeHandler",
+    "instrumentToolsListHandler"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/instrumentation.mjs

@@ -0,0 +1,194 @@
+import { InitializeRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { addContextParameterToTools, getContextDescription, isContextEnabled } from "./context-parameters.mjs";
+import { addConversationIdToTools, canInjectConversationIdPromptBack, cloneRequestWithoutConversationId, injectConversationIdPromptBack, resolveConversationId } from "./conversation-id.mjs";
+import { captureEvent } from "./capture.mjs";
+import { MCPAnalyticsEventType } from "./event-types.mjs";
+import { captureException } from "./exceptions.mjs";
+import { resolveToolCallIntent, setEventIntent, setExplicitContextIntent } from "./intent.mjs";
+import { getServerTrackingData, handleIdentify } from "./internal.mjs";
+import { log } from "./logger.mjs";
+import { buildCapturedMcpParameters } from "./mcp-payloads.mjs";
+import { getServerSessionId } from "./session.mjs";
+import { GET_MORE_TOOLS_NAME, getReportMissingToolDescriptor } from "./tools.mjs";
+import { applyResolvedMetadata, isToolResultError } from "./tracing-helpers.mjs";
+async function captureToolCall(params) {
+    const { server, data, request, extra, execute, eventType, explicitContextIntent, takeCapturedError } = params;
+    const conversation = resolveConversationId(data.options.enableConversationId ?? false, request.params?.arguments, request.params?.name);
+    const downstreamRequest = conversation.conversationId ? cloneRequestWithoutConversationId(request) : request;
+    const startTime = new Date();
+    const event = await prepareToolCallEvent(server, data, request, downstreamRequest, extra, startTime, conversation, eventType ?? MCPAnalyticsEventType.mcpToolsCall);
+    if (event && explicitContextIntent) setExplicitContextIntent(event, explicitContextIntent);
+    let result;
+    try {
+        result = await execute(downstreamRequest);
+    } catch (error) {
+        publishFailedToolEvent(server, event, error, startTime, conversation);
+        throw error;
+    }
+    const finalResult = applyConversationPromptBack(event, result, conversation);
+    publishSuccessfulToolEvent(server, event, finalResult, startTime, takeCapturedError);
+    return finalResult;
+}
+async function prepareToolCallEvent(server, data, request, downstreamRequest, extra, startTime, conversation, eventType) {
+    try {
+        const sessionId = getServerSessionId(server, extra);
+        await handleIdentify(server, data, sessionId, request, extra);
+        const toolName = request.params?.name;
+        const event = {
+            sessionId,
+            conversationId: conversation.conversationId,
+            resourceName: toolName || 'Unknown Tool Name',
+            parameters: buildCapturedMcpParameters(downstreamRequest),
+            eventType,
+            timestamp: startTime,
+            toolDescription: toolName ? data.toolDescriptions.get(toolName) : void 0
+        };
+        await applyResolvedMetadata(event, data, request, extra);
+        setEventIntent(event, await resolveToolCallIntent(data, request, extra));
+        return event;
+    } catch (error) {
+        log(`Warning: PostHog MCP analytics instrumentation failed for tool ${request.params?.name}, the tool will still run - ${error}`);
+        return null;
+    }
+}
+function applyConversationPromptBack(event, result, conversation) {
+    if (!conversation.minted) return result;
+    if (canInjectConversationIdPromptBack(result)) return injectConversationIdPromptBack(result, conversation.conversationId);
+    if (event) event.conversationId = void 0;
+    return result;
+}
+function publishSuccessfulToolEvent(server, event, result, startTime, takeCapturedError) {
+    if (!event) return;
+    try {
+        if (isToolResultError(result)) {
+            event.isError = true;
+            const capturedError = takeCapturedError?.();
+            event.error = captureException(capturedError ?? result);
+        } else event.isError = false;
+        event.response = result;
+        event.duration = Date.now() - startTime.getTime();
+        captureEvent(server, event);
+    } catch (error) {
+        log(`Warning: PostHog MCP analytics failed to publish tool event - ${error}`);
+    }
+}
+function publishFailedToolEvent(server, event, error, startTime, conversation) {
+    if (!event) return;
+    try {
+        if (conversation.minted) event.conversationId = void 0;
+        event.isError = true;
+        event.error = captureException(error);
+        event.duration = Date.now() - startTime.getTime();
+        captureEvent(server, event);
+    } catch (publishError) {
+        log(`Warning: PostHog MCP analytics failed to publish failed tool event - ${publishError}`);
+    }
+}
+const listToolsTracingSetup = new WeakMap();
+function instrumentToolsListHandler(server) {
+    if (!server._capabilities?.tools) return;
+    if (listToolsTracingSetup.get(server)) return;
+    const originalListToolsHandler = server._requestHandlers.get('tools/list');
+    if (!originalListToolsHandler) return;
+    try {
+        server.setRequestHandler(ListToolsRequestSchema, async (request, extra)=>await handleListToolsRequest(server, originalListToolsHandler, request, extra));
+        listToolsTracingSetup.set(server, true);
+    } catch (error) {
+        log(`Warning: Failed to override list tools handler - ${error}`);
+    }
+}
+async function handleListToolsRequest(server, originalListToolsHandler, request, extra) {
+    const data = getServerTrackingData(server);
+    const startTime = new Date();
+    const event = {
+        sessionId: getServerSessionId(server, extra),
+        parameters: buildCapturedMcpParameters(request),
+        eventType: MCPAnalyticsEventType.mcpToolsList,
+        timestamp: startTime
+    };
+    if (data) await applyResolvedMetadata(event, data, request, extra);
+    const tools = await getTracedToolsList(server, originalListToolsHandler, request, extra, event);
+    if (!data) {
+        log('Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using tool calls.');
+        return {
+            tools
+        };
+    }
+    if (0 === tools.length) {
+        log('Warning: No tools found in the original list. This is likely due to the tools not being registered before PostHog MCP analytics.instrument().');
+        event.error = captureException('No tools were sent to MCP client.');
+        event.isError = true;
+        event.duration = Date.now() - startTime.getTime();
+        captureEvent(server, event);
+        return {
+            tools
+        };
+    }
+    event.response = {
+        tools
+    };
+    event.listedToolNames = collectListedToolNames(tools);
+    event.isError = false;
+    event.duration = Date.now() - startTime.getTime();
+    captureEvent(server, event);
+    return {
+        tools
+    };
+}
+function collectListedToolNames(tools) {
+    if (!tools || 0 === tools.length) return;
+    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) {
+    try {
+        const data = getServerTrackingData(server);
+        const originalResponse = await originalListToolsHandler(request, extra);
+        let tools = originalResponse.tools || [];
+        if (data && isContextEnabled(data.options.context)) tools = addContextParameterToTools(tools, getContextDescription(data.options.context));
+        if (data?.options.enableConversationId) tools = addConversationIdToTools(tools);
+        if (data?.options.reportMissing) {
+            const alreadyPresent = tools.some((tool)=>tool?.name === GET_MORE_TOOLS_NAME);
+            if (!alreadyPresent) tools.push(getReportMissingToolDescriptor());
+        }
+        if (data) cacheToolDescriptions(data.toolDescriptions, tools);
+        return tools;
+    } catch (error) {
+        log(`Warning: Original list tools handler failed, this suggests an error PostHog MCP analytics did not cause - ${error}`);
+        event.error = captureException(error);
+        event.isError = true;
+        event.duration = event.timestamp ? Date.now() - event.timestamp.getTime() : 0;
+        captureEvent(server, event);
+        throw error;
+    }
+}
+function cacheToolDescriptions(cache, tools) {
+    if (!tools) return;
+    for (const tool of tools)if (tool?.name && 'string' == typeof tool.description) cache.set(tool.name, tool.description);
+}
+function instrumentInitializeHandler(server) {
+    const originalInitializeHandler = server._requestHandlers.get('initialize');
+    if (!originalInitializeHandler) return;
+    server.setRequestHandler(InitializeRequestSchema, async (request, extra)=>{
+        const data = getServerTrackingData(server);
+        if (!data) {
+            log('Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using tool calls.');
+            return await originalInitializeHandler(request, extra);
+        }
+        const sessionId = getServerSessionId(server, extra);
+        await handleIdentify(server, data, sessionId, request, extra);
+        const event = {
+            sessionId,
+            resourceName: request.params?.name || 'Unknown Tool Name',
+            eventType: MCPAnalyticsEventType.mcpInitialize,
+            parameters: buildCapturedMcpParameters(request),
+            timestamp: new Date()
+        };
+        await applyResolvedMetadata(event, data, request, extra);
+        const result = await originalInitializeHandler(request, extra);
+        event.response = result;
+        captureEvent(server, event);
+        return result;
+    });
+}
+export { cacheToolDescriptions, captureToolCall, instrumentInitializeHandler, instrumentToolsListHandler };

package/dist/extensions/intent.d.ts

@@ -0,0 +1,10 @@
+import type { CompatibleRequestHandlerExtra, MCPAnalyticsData, MCPAnalyticsIntentSource, MCPRequestLike, McpEvent } from '../types';
+interface ResolvedIntent {
+    intent: string;
+    source: MCPAnalyticsIntentSource;
+}
+export declare function resolveToolCallIntent(data: MCPAnalyticsData, request: MCPRequestLike, extra?: CompatibleRequestHandlerExtra): Promise<ResolvedIntent | null>;
+export declare function setEventIntent(event: McpEvent, resolvedIntent: ResolvedIntent | null): void;
+export declare function setExplicitContextIntent(event: McpEvent, context: string): void;
+export {};
+//# sourceMappingURL=intent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intent.d.ts","sourceRoot":"","sources":["../../src/extensions/intent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,6BAA6B,EAC7B,gBAAgB,EAChB,wBAAwB,EACxB,cAAc,EACd,QAAQ,EACT,MAAM,UAAU,CAAA;AAIjB,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,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

@@ -0,0 +1,84 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    setExplicitContextIntent: ()=>setExplicitContextIntent,
+    resolveToolCallIntent: ()=>resolveToolCallIntent,
+    setEventIntent: ()=>setEventIntent
+});
+const external_context_parameters_js_namespaceObject = require("./context-parameters.js");
+const external_logger_js_namespaceObject = require("./logger.js");
+function getContextArgument(request) {
+    const context = request.params?.arguments?.context;
+    return 'string' == typeof context && context.trim() ? context : void 0;
+}
+function normalizeIntent(intent) {
+    if ('string' != typeof intent) return null;
+    const trimmed = intent.trim();
+    return trimmed ? trimmed : null;
+}
+async function runIntentFallback(data, request, extra) {
+    if (!data.options.intentFallback) return null;
+    try {
+        const intent = normalizeIntent(await data.options.intentFallback(request, extra));
+        return intent ? {
+            intent,
+            source: 'inferred'
+        } : null;
+    } catch (error) {
+        (0, external_logger_js_namespaceObject.log)(`intentFallback callback error: ${error}`);
+        return null;
+    }
+}
+async function resolveToolCallIntent(data, request, extra) {
+    const contextArgument = getContextArgument(request);
+    if ((0, external_context_parameters_js_namespaceObject.isContextEnabled)(data.options.context) && request.params?.name !== 'get_more_tools' && contextArgument) return {
+        intent: contextArgument,
+        source: 'context_parameter'
+    };
+    return await runIntentFallback(data, request, extra);
+}
+function setEventIntent(event, resolvedIntent) {
+    if (!resolvedIntent) return;
+    event.userIntent = resolvedIntent.intent;
+    event.userIntentSource = resolvedIntent.source;
+}
+function setExplicitContextIntent(event, context) {
+    const intent = normalizeIntent(context);
+    if (!intent) return;
+    event.userIntent = intent;
+    event.userIntentSource = 'context_parameter';
+}
+exports.resolveToolCallIntent = __webpack_exports__.resolveToolCallIntent;
+exports.setEventIntent = __webpack_exports__.setEventIntent;
+exports.setExplicitContextIntent = __webpack_exports__.setExplicitContextIntent;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "resolveToolCallIntent",
+    "setEventIntent",
+    "setExplicitContextIntent"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/intent.mjs

@@ -0,0 +1,44 @@
+import { isContextEnabled } from "./context-parameters.mjs";
+import { log } from "./logger.mjs";
+function getContextArgument(request) {
+    const context = request.params?.arguments?.context;
+    return 'string' == typeof context && context.trim() ? context : void 0;
+}
+function normalizeIntent(intent) {
+    if ('string' != typeof intent) return null;
+    const trimmed = intent.trim();
+    return trimmed ? trimmed : null;
+}
+async function runIntentFallback(data, request, extra) {
+    if (!data.options.intentFallback) return null;
+    try {
+        const intent = normalizeIntent(await data.options.intentFallback(request, extra));
+        return intent ? {
+            intent,
+            source: 'inferred'
+        } : null;
+    } catch (error) {
+        log(`intentFallback callback error: ${error}`);
+        return null;
+    }
+}
+async function resolveToolCallIntent(data, request, extra) {
+    const contextArgument = getContextArgument(request);
+    if (isContextEnabled(data.options.context) && request.params?.name !== 'get_more_tools' && contextArgument) return {
+        intent: contextArgument,
+        source: 'context_parameter'
+    };
+    return await runIntentFallback(data, request, extra);
+}
+function setEventIntent(event, resolvedIntent) {
+    if (!resolvedIntent) return;
+    event.userIntent = resolvedIntent.intent;
+    event.userIntentSource = resolvedIntent.source;
+}
+function setExplicitContextIntent(event, context) {
+    const intent = normalizeIntent(context);
+    if (!intent) return;
+    event.userIntent = intent;
+    event.userIntentSource = 'context_parameter';
+}
+export { resolveToolCallIntent, setEventIntent, setExplicitContextIntent };

package/dist/extensions/internal.d.ts

@@ -0,0 +1,32 @@
+import type { CompatibleRequestHandlerExtra, MCPAnalyticsData, MCPRequestLike, MCPServerLike, 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.
+ * One instance lives on each server's tracking data — it is NOT shared across
+ * server instances, so identities never bleed between servers.
+ */
+export declare class IdentityCache {
+    private readonly _cache;
+    private readonly _maxSize;
+    constructor(maxSize?: number);
+    get(sessionId: string): UserIdentity | undefined;
+    set(sessionId: string, identity: UserIdentity): void;
+    has(sessionId: string): boolean;
+    size(): number;
+}
+export declare function getServerTrackingData(server: MCPServerLike): MCPAnalyticsData | undefined;
+export declare function setServerTrackingData(server: MCPServerLike, data: MCPAnalyticsData): void;
+export declare function areIdentitiesEqual(a: UserIdentity, b: UserIdentity): boolean;
+export declare function mergeIdentities(previous: UserIdentity | undefined, next: UserIdentity): UserIdentity;
+/**
+ * Resolves the optional `identify` callback, dedupes against the server's identity
+ * cache, and publishes an `$identify` event only when the identity has materially changed.
+ */
+export declare function handleIdentify(server: MCPServerLike, data: MCPAnalyticsData, sessionId: string, request: MCPRequestLike, extra?: CompatibleRequestHandlerExtra): Promise<void>;
+/**
+ * Resolves the `eventProperties` callback. Returns null when no callback is
+ * configured, or when it returns nullish or throws — a throw never propagates
+ * into the tool path.
+ */
+export declare function resolveEventProperties(data: MCPAnalyticsData, request: MCPRequestLike, extra?: CompatibleRequestHandlerExtra): Promise<Record<string, unknown> | null>;
+//# sourceMappingURL=internal.d.ts.map

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

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