@posthog/mcp 0.0.9 → 0.1.16

package/dist/extensions/mcp-sdk-compat.mjs

@@ -0,0 +1,60 @@
+function getToolFunction(tool) {
+    if ('handler' in tool && 'function' == typeof tool.handler) return tool.handler;
+    if ('callback' in tool && 'function' == typeof tool.callback) return tool.callback;
+    throw new Error('Tool has neither callback nor handler property');
+}
+function getToolFunctionKey(tool) {
+    if ('handler' in tool && 'function' == typeof tool.handler) return 'handler';
+    return 'callback';
+}
+function hasToolFunction(tool) {
+    if (!tool || 'object' != typeof tool) return false;
+    const t = tool;
+    return 'handler' in t && 'function' == typeof t.handler || 'callback' in t && 'function' == typeof t.callback;
+}
+function createWrappedTool(originalTool, wrappedFunction) {
+    const key = getToolFunctionKey(originalTool);
+    return {
+        ...originalTool,
+        [key]: wrappedFunction
+    };
+}
+function isZ4Schema(schema) {
+    if (!schema || 'object' != typeof schema) return false;
+    return !!schema._zod;
+}
+function getObjectShape(schema) {
+    if (!schema || 'object' != typeof schema) return;
+    let rawShape;
+    if (isZ4Schema(schema)) {
+        const v4Schema = schema;
+        rawShape = v4Schema._zod?.def?.shape;
+    } else {
+        const v3Schema = schema;
+        rawShape = v3Schema.shape ?? v3Schema._def?.shape;
+    }
+    if (!rawShape) return;
+    if ('function' == typeof rawShape) try {
+        return rawShape();
+    } catch  {
+        return;
+    }
+    return rawShape;
+}
+function getLiteralValue(schema) {
+    if (!schema || 'object' != typeof schema) return;
+    if (isZ4Schema(schema)) {
+        const v4Schema = schema;
+        const def = v4Schema._zod?.def;
+        if (def?.value !== void 0) return def.value;
+        if (Array.isArray(def?.values) && def.values.length > 0) return def.values[0];
+    } else {
+        const v3Schema = schema;
+        const def = v3Schema._def;
+        if (def?.value !== void 0) return def.value;
+        if (Array.isArray(def?.values) && def.values.length > 0) return def.values[0];
+    }
+    const directValue = schema.value;
+    if (void 0 !== directValue) return directValue;
+}
+export { createWrappedTool, getLiteralValue, getObjectShape, getToolFunction, getToolFunctionKey, hasToolFunction, isZ4Schema };

package/dist/extensions/posthog-events.d.ts

@@ -0,0 +1,14 @@
+import type { Event } from '../types';
+export interface PostHogCaptureEvent {
+    distinct_id: string;
+    event: string;
+    properties: Record<string, unknown>;
+    timestamp: string;
+    type: 'capture';
+}
+export interface BuildPostHogCaptureEventsOptions {
+    /** Whether to emit a `$exception` sibling alongside errored events. Defaults to `true`. */
+    enableExceptionAutocapture?: boolean;
+}
+export declare function buildPostHogCaptureEvents(event: Event, options?: BuildPostHogCaptureEventsOptions): PostHogCaptureEvent[];
+//# sourceMappingURL=posthog-events.d.ts.map

package/dist/extensions/posthog-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"posthog-events.d.ts","sourceRoot":"","sources":["../../src/extensions/posthog-events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAyBrC,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACnC,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,SAAS,CAAA;CAChB;AAED,MAAM,WAAW,gCAAgC;IAC/C,2FAA2F;IAC3F,0BAA0B,CAAC,EAAE,OAAO,CAAA;CACrC;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,KAAK,EACZ,OAAO,GAAE,gCAAqC,GAC7C,mBAAmB,EAAE,CAQvB"}

package/dist/extensions/posthog-events.js

@@ -0,0 +1,143 @@
+"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__, {
+    buildPostHogCaptureEvents: ()=>buildPostHogCaptureEvents
+});
+const external_constants_js_namespaceObject = require("./constants.js");
+const external_event_types_js_namespaceObject = require("./event-types.js");
+const BUILT_IN_EVENT_NAME_BY_TYPE = {
+    [external_event_types_js_namespaceObject.MCPAnalyticsEventType.custom]: external_constants_js_namespaceObject.PostHogMCPAnalyticsEvent.Custom,
+    [external_event_types_js_namespaceObject.MCPAnalyticsEventType.identify]: external_constants_js_namespaceObject.PostHogMCPAnalyticsEvent.Identify,
+    [external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpMissingCapability]: external_constants_js_namespaceObject.PostHogMCPAnalyticsEvent.MissingCapability,
+    [external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpInitialize]: external_constants_js_namespaceObject.PostHogMCPAnalyticsEvent.Initialize,
+    [external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpPromptsGet]: external_constants_js_namespaceObject.PostHogMCPAnalyticsEvent.PromptGet,
+    [external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpPromptsList]: external_constants_js_namespaceObject.PostHogMCPAnalyticsEvent.PromptsList,
+    [external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpResourcesList]: external_constants_js_namespaceObject.PostHogMCPAnalyticsEvent.ResourcesList,
+    [external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpResourcesRead]: external_constants_js_namespaceObject.PostHogMCPAnalyticsEvent.ResourceRead,
+    [external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpToolsCall]: external_constants_js_namespaceObject.PostHogMCPAnalyticsEvent.ToolCall,
+    [external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpToolsList]: external_constants_js_namespaceObject.PostHogMCPAnalyticsEvent.ToolsList
+};
+function getDistinctId(event) {
+    return event.identifyActorGivenId || event.sessionId || 'anonymous';
+}
+function getTimestamp(event) {
+    return event.timestamp ? event.timestamp.toISOString() : new Date().toISOString();
+}
+function buildPostHogCaptureEvents(event, options = {}) {
+    const batch = [
+        buildCaptureEvent(event)
+    ];
+    if (event.isError && event.error && false !== options.enableExceptionAutocapture) batch.push(buildExceptionEvent(event));
+    return batch;
+}
+function buildCaptureEvent(event) {
+    const distinctId = getDistinctId(event);
+    const timestamp = getTimestamp(event);
+    const properties = {
+        [external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.SessionId]: event.sessionId,
+        [external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.Source]: external_constants_js_namespaceObject.POSTHOG_MCP_ANALYTICS_SOURCE
+    };
+    addConversationIdProperty(event, properties);
+    addPersonProcessingProperty(event, properties);
+    addGroupsProperty(event, properties);
+    addCommonEventProperties(event, properties);
+    addCustomEventProperties(event, properties);
+    return {
+        event: event.eventName ?? BUILT_IN_EVENT_NAME_BY_TYPE[event.eventType],
+        distinct_id: distinctId,
+        properties,
+        timestamp,
+        type: 'capture'
+    };
+}
+function addConversationIdProperty(event, properties) {
+    if (void 0 !== event.conversationId && '' !== event.conversationId) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.ConversationId] = event.conversationId;
+}
+function addGroupsProperty(event, properties) {
+    if (event.groups && Object.keys(event.groups).length > 0) properties.$groups = event.groups;
+}
+function addPersonProcessingProperty(event, properties) {
+    if (!event.identifyActorGivenId) properties.$process_person_profile = false;
+}
+function addCommonEventProperties(event, properties) {
+    if (event.resourceName) {
+        properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.ResourceName] = event.resourceName;
+        if (event.eventType === external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpToolsCall) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.ToolName] = event.resourceName;
+    }
+    if (event.toolDescription && event.eventType === external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpToolsCall) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.ToolDescription] = event.toolDescription;
+    if (event.listedToolNames && event.listedToolNames.length > 0 && event.eventType === external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpToolsList) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.ListedToolNames] = event.listedToolNames;
+    if (void 0 !== event.duration) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.DurationMs] = event.duration;
+    if (event.serverName) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.ServerName] = event.serverName;
+    if (event.serverVersion) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.ServerVersion] = event.serverVersion;
+    if (event.clientName) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.ClientName] = event.clientName;
+    if (event.clientVersion) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.ClientVersion] = event.clientVersion;
+    if (event.userIntent) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.Intent] = event.userIntent;
+    if (event.userIntentSource) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.IntentSource] = event.userIntentSource;
+    if (void 0 !== event.isError) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.IsError] = event.isError;
+    if (void 0 !== event.parameters) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.Parameters] = event.parameters;
+    if (void 0 !== event.response) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.Response] = event.response;
+    if (event.identifyActorData && Object.keys(event.identifyActorData).length > 0) properties.$set = {
+        ...event.identifyActorData
+    };
+}
+function addCustomEventProperties(event, properties) {
+    if (event.properties) for (const [key, value] of Object.entries(event.properties))properties[key] = value;
+}
+function buildExceptionEvent(event) {
+    const distinctId = getDistinctId(event);
+    const timestamp = getTimestamp(event);
+    const properties = {
+        [external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.SessionId]: event.sessionId
+    };
+    addConversationIdProperty(event, properties);
+    addPersonProcessingProperty(event, properties);
+    addGroupsProperty(event, properties);
+    if (event.error) Object.assign(properties, event.error);
+    if (event.resourceName) {
+        properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.ResourceName] = event.resourceName;
+        if (event.eventType === external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpToolsCall) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.ToolName] = event.resourceName;
+    }
+    if (event.toolDescription && event.eventType === external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpToolsCall) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.ToolDescription] = event.toolDescription;
+    if (event.serverName) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.ServerName] = event.serverName;
+    if (event.serverVersion) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.ServerVersion] = event.serverVersion;
+    if (event.clientName) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.ClientName] = event.clientName;
+    if (event.clientVersion) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.ClientVersion] = event.clientVersion;
+    addCustomEventProperties(event, properties);
+    return {
+        event: external_constants_js_namespaceObject.PostHogMCPAnalyticsEvent.Exception,
+        distinct_id: distinctId,
+        properties,
+        timestamp,
+        type: 'capture'
+    };
+}
+exports.buildPostHogCaptureEvents = __webpack_exports__.buildPostHogCaptureEvents;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "buildPostHogCaptureEvents"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/posthog-events.mjs

@@ -0,0 +1,109 @@
+import { POSTHOG_MCP_ANALYTICS_SOURCE, PostHogMCPAnalyticsEvent, PostHogMCPAnalyticsProperty } from "./constants.mjs";
+import { MCPAnalyticsEventType } from "./event-types.mjs";
+const BUILT_IN_EVENT_NAME_BY_TYPE = {
+    [MCPAnalyticsEventType.custom]: PostHogMCPAnalyticsEvent.Custom,
+    [MCPAnalyticsEventType.identify]: PostHogMCPAnalyticsEvent.Identify,
+    [MCPAnalyticsEventType.mcpMissingCapability]: PostHogMCPAnalyticsEvent.MissingCapability,
+    [MCPAnalyticsEventType.mcpInitialize]: PostHogMCPAnalyticsEvent.Initialize,
+    [MCPAnalyticsEventType.mcpPromptsGet]: PostHogMCPAnalyticsEvent.PromptGet,
+    [MCPAnalyticsEventType.mcpPromptsList]: PostHogMCPAnalyticsEvent.PromptsList,
+    [MCPAnalyticsEventType.mcpResourcesList]: PostHogMCPAnalyticsEvent.ResourcesList,
+    [MCPAnalyticsEventType.mcpResourcesRead]: PostHogMCPAnalyticsEvent.ResourceRead,
+    [MCPAnalyticsEventType.mcpToolsCall]: PostHogMCPAnalyticsEvent.ToolCall,
+    [MCPAnalyticsEventType.mcpToolsList]: PostHogMCPAnalyticsEvent.ToolsList
+};
+function getDistinctId(event) {
+    return event.identifyActorGivenId || event.sessionId || 'anonymous';
+}
+function getTimestamp(event) {
+    return event.timestamp ? event.timestamp.toISOString() : new Date().toISOString();
+}
+function buildPostHogCaptureEvents(event, options = {}) {
+    const batch = [
+        buildCaptureEvent(event)
+    ];
+    if (event.isError && event.error && false !== options.enableExceptionAutocapture) batch.push(buildExceptionEvent(event));
+    return batch;
+}
+function buildCaptureEvent(event) {
+    const distinctId = getDistinctId(event);
+    const timestamp = getTimestamp(event);
+    const properties = {
+        [PostHogMCPAnalyticsProperty.SessionId]: event.sessionId,
+        [PostHogMCPAnalyticsProperty.Source]: POSTHOG_MCP_ANALYTICS_SOURCE
+    };
+    addConversationIdProperty(event, properties);
+    addPersonProcessingProperty(event, properties);
+    addGroupsProperty(event, properties);
+    addCommonEventProperties(event, properties);
+    addCustomEventProperties(event, properties);
+    return {
+        event: event.eventName ?? BUILT_IN_EVENT_NAME_BY_TYPE[event.eventType],
+        distinct_id: distinctId,
+        properties,
+        timestamp,
+        type: 'capture'
+    };
+}
+function addConversationIdProperty(event, properties) {
+    if (void 0 !== event.conversationId && '' !== event.conversationId) properties[PostHogMCPAnalyticsProperty.ConversationId] = event.conversationId;
+}
+function addGroupsProperty(event, properties) {
+    if (event.groups && Object.keys(event.groups).length > 0) properties.$groups = event.groups;
+}
+function addPersonProcessingProperty(event, properties) {
+    if (!event.identifyActorGivenId) properties.$process_person_profile = false;
+}
+function addCommonEventProperties(event, properties) {
+    if (event.resourceName) {
+        properties[PostHogMCPAnalyticsProperty.ResourceName] = event.resourceName;
+        if (event.eventType === MCPAnalyticsEventType.mcpToolsCall) properties[PostHogMCPAnalyticsProperty.ToolName] = event.resourceName;
+    }
+    if (event.toolDescription && event.eventType === MCPAnalyticsEventType.mcpToolsCall) properties[PostHogMCPAnalyticsProperty.ToolDescription] = event.toolDescription;
+    if (event.listedToolNames && event.listedToolNames.length > 0 && event.eventType === MCPAnalyticsEventType.mcpToolsList) properties[PostHogMCPAnalyticsProperty.ListedToolNames] = event.listedToolNames;
+    if (void 0 !== event.duration) properties[PostHogMCPAnalyticsProperty.DurationMs] = event.duration;
+    if (event.serverName) properties[PostHogMCPAnalyticsProperty.ServerName] = event.serverName;
+    if (event.serverVersion) properties[PostHogMCPAnalyticsProperty.ServerVersion] = event.serverVersion;
+    if (event.clientName) properties[PostHogMCPAnalyticsProperty.ClientName] = event.clientName;
+    if (event.clientVersion) properties[PostHogMCPAnalyticsProperty.ClientVersion] = event.clientVersion;
+    if (event.userIntent) properties[PostHogMCPAnalyticsProperty.Intent] = event.userIntent;
+    if (event.userIntentSource) properties[PostHogMCPAnalyticsProperty.IntentSource] = event.userIntentSource;
+    if (void 0 !== event.isError) properties[PostHogMCPAnalyticsProperty.IsError] = event.isError;
+    if (void 0 !== event.parameters) properties[PostHogMCPAnalyticsProperty.Parameters] = event.parameters;
+    if (void 0 !== event.response) properties[PostHogMCPAnalyticsProperty.Response] = event.response;
+    if (event.identifyActorData && Object.keys(event.identifyActorData).length > 0) properties.$set = {
+        ...event.identifyActorData
+    };
+}
+function addCustomEventProperties(event, properties) {
+    if (event.properties) for (const [key, value] of Object.entries(event.properties))properties[key] = value;
+}
+function buildExceptionEvent(event) {
+    const distinctId = getDistinctId(event);
+    const timestamp = getTimestamp(event);
+    const properties = {
+        [PostHogMCPAnalyticsProperty.SessionId]: event.sessionId
+    };
+    addConversationIdProperty(event, properties);
+    addPersonProcessingProperty(event, properties);
+    addGroupsProperty(event, properties);
+    if (event.error) Object.assign(properties, event.error);
+    if (event.resourceName) {
+        properties[PostHogMCPAnalyticsProperty.ResourceName] = event.resourceName;
+        if (event.eventType === MCPAnalyticsEventType.mcpToolsCall) properties[PostHogMCPAnalyticsProperty.ToolName] = event.resourceName;
+    }
+    if (event.toolDescription && event.eventType === MCPAnalyticsEventType.mcpToolsCall) properties[PostHogMCPAnalyticsProperty.ToolDescription] = event.toolDescription;
+    if (event.serverName) properties[PostHogMCPAnalyticsProperty.ServerName] = event.serverName;
+    if (event.serverVersion) properties[PostHogMCPAnalyticsProperty.ServerVersion] = event.serverVersion;
+    if (event.clientName) properties[PostHogMCPAnalyticsProperty.ClientName] = event.clientName;
+    if (event.clientVersion) properties[PostHogMCPAnalyticsProperty.ClientVersion] = event.clientVersion;
+    addCustomEventProperties(event, properties);
+    return {
+        event: PostHogMCPAnalyticsEvent.Exception,
+        distinct_id: distinctId,
+        properties,
+        timestamp,
+        type: 'capture'
+    };
+}
+export { buildPostHogCaptureEvents };

package/dist/extensions/sanitization.d.ts

@@ -0,0 +1,10 @@
+import type { Event, McpEvent } from '../types';
+/**
+ * Sanitizes an event by redacting non-text content blocks from responses
+ * and large base64-encoded strings from parameters.
+ *
+ * This is a synchronous operation that returns a new object without mutating the original.
+ * It should run after customer redaction in the event pipeline.
+ */
+export declare function sanitizeEvent<T extends Event | McpEvent>(event: T): T;
+//# sourceMappingURL=sanitization.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sanitization.d.ts","sourceRoot":"","sources":["../../src/extensions/sanitization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAS/C;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,KAAK,GAAG,QAAQ,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAYrE"}

package/dist/extensions/sanitization.js

@@ -0,0 +1,96 @@
+"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__, {
+    sanitizeEvent: ()=>sanitizeEvent
+});
+const external_mcp_payloads_js_namespaceObject = require("./mcp-payloads.js");
+function isRecord(value) {
+    return !!value && 'object' == typeof value && !Array.isArray(value);
+}
+function sanitizeEvent(event) {
+    const result = {
+        ...event
+    };
+    if (null != result.response) result.response = sanitizeResponse(result.response);
+    if (null != result.parameters) result.parameters = sanitizeParameters(result.parameters);
+    return result;
+}
+function sanitizeResponse(response) {
+    if (null == response || 'object' != typeof response) return (0, external_mcp_payloads_js_namespaceObject.sanitizeCapturedValue)(response);
+    const sanitized = (0, external_mcp_payloads_js_namespaceObject.sanitizeCapturedValue)(response);
+    if (!isRecord(sanitized)) return sanitized;
+    const result = {
+        ...sanitized
+    };
+    const content = result.content;
+    if (Array.isArray(content)) result.content = content.map(sanitizeContentBlock);
+    if (null != result.structuredContent && 'object' == typeof result.structuredContent) result.structuredContent = (0, external_mcp_payloads_js_namespaceObject.sanitizeCapturedValue)(result.structuredContent);
+    return result;
+}
+function sanitizeContentBlock(block) {
+    if (null == block || 'object' != typeof block) return block;
+    if (!isRecord(block)) return block;
+    switch(block.type){
+        case 'text':
+            return (0, external_mcp_payloads_js_namespaceObject.sanitizeCapturedValue)(block);
+        case 'image':
+            return {
+                type: 'text',
+                text: '[image content redacted - not supported by PostHog MCP analytics]'
+            };
+        case 'audio':
+            return {
+                type: 'text',
+                text: '[audio content redacted - not supported by PostHog MCP analytics]'
+            };
+        case 'resource':
+            return sanitizeResourceBlock(block);
+        case 'resource_link':
+            return (0, external_mcp_payloads_js_namespaceObject.sanitizeCapturedValue)(block);
+        default:
+            return {
+                type: 'text',
+                text: `[unsupported content type "${block.type}" redacted - not supported by PostHog MCP analytics]`
+            };
+    }
+}
+function sanitizeResourceBlock(block) {
+    if (isRecord(block.resource) && 'blob' in block.resource) return {
+        type: 'text',
+        text: '[binary resource content redacted - not supported by PostHog MCP analytics]'
+    };
+    return (0, external_mcp_payloads_js_namespaceObject.sanitizeCapturedValue)(block);
+}
+function sanitizeParameters(obj) {
+    return (0, external_mcp_payloads_js_namespaceObject.sanitizeCapturedValue)(obj);
+}
+exports.sanitizeEvent = __webpack_exports__.sanitizeEvent;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "sanitizeEvent"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/sanitization.mjs

@@ -0,0 +1,62 @@
+import { sanitizeCapturedValue } from "./mcp-payloads.mjs";
+function isRecord(value) {
+    return !!value && 'object' == typeof value && !Array.isArray(value);
+}
+function sanitizeEvent(event) {
+    const result = {
+        ...event
+    };
+    if (null != result.response) result.response = sanitizeResponse(result.response);
+    if (null != result.parameters) result.parameters = sanitizeParameters(result.parameters);
+    return result;
+}
+function sanitizeResponse(response) {
+    if (null == response || 'object' != typeof response) return sanitizeCapturedValue(response);
+    const sanitized = sanitizeCapturedValue(response);
+    if (!isRecord(sanitized)) return sanitized;
+    const result = {
+        ...sanitized
+    };
+    const content = result.content;
+    if (Array.isArray(content)) result.content = content.map(sanitizeContentBlock);
+    if (null != result.structuredContent && 'object' == typeof result.structuredContent) result.structuredContent = sanitizeCapturedValue(result.structuredContent);
+    return result;
+}
+function sanitizeContentBlock(block) {
+    if (null == block || 'object' != typeof block) return block;
+    if (!isRecord(block)) return block;
+    switch(block.type){
+        case 'text':
+            return sanitizeCapturedValue(block);
+        case 'image':
+            return {
+                type: 'text',
+                text: '[image content redacted - not supported by PostHog MCP analytics]'
+            };
+        case 'audio':
+            return {
+                type: 'text',
+                text: '[audio content redacted - not supported by PostHog MCP analytics]'
+            };
+        case 'resource':
+            return sanitizeResourceBlock(block);
+        case 'resource_link':
+            return sanitizeCapturedValue(block);
+        default:
+            return {
+                type: 'text',
+                text: `[unsupported content type "${block.type}" redacted - not supported by PostHog MCP analytics]`
+            };
+    }
+}
+function sanitizeResourceBlock(block) {
+    if (isRecord(block.resource) && 'blob' in block.resource) return {
+        type: 'text',
+        text: '[binary resource content redacted - not supported by PostHog MCP analytics]'
+    };
+    return sanitizeCapturedValue(block);
+}
+function sanitizeParameters(obj) {
+    return sanitizeCapturedValue(obj);
+}
+export { sanitizeEvent };

package/dist/extensions/session.d.ts

@@ -0,0 +1,20 @@
+import type { CompatibleRequestHandlerExtra, MCPAnalyticsData, MCPServerLike, SessionInfo } from '../types';
+export declare function newSessionId(): string;
+/**
+ * Derives the SDK session id deterministically from the MCP sessionId, so the
+ * same MCP session correlates to one SDK session across server restarts.
+ */
+export declare function deriveSessionIdFromMCPSession(mcpSessionId: string): string;
+/**
+ * Resolves the session id for a request, preferring the MCP protocol sessionId
+ * over an SDK-generated one so a transport-supplied session wins.
+ */
+export declare function getServerSessionId(server: MCPServerLike, extra?: CompatibleRequestHandlerExtra): string;
+export declare function setLastActivity(server: MCPServerLike): void;
+/**
+ * Builds the session metadata stamped onto an event. The caller passes the
+ * session id resolved for *this* request so identity attribution can't be
+ * clobbered by a concurrent request mutating shared `data.sessionId`.
+ */
+export declare function getSessionInfo(server: MCPServerLike, data: MCPAnalyticsData | undefined, sessionId?: string): SessionInfo;
+//# sourceMappingURL=session.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/extensions/session.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,6BAA6B,EAC7B,gBAAgB,EAChB,aAAa,EAEb,WAAW,EACZ,MAAM,UAAU,CAAA;AAKjB,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAE1E;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,CAAC,EAAE,6BAA6B,GAAG,MAAM,CAoCvG;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAS3D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,gBAAgB,GAAG,SAAS,EAClC,SAAS,CAAC,EAAE,MAAM,GACjB,WAAW,CA8Bb"}

package/dist/extensions/session.js

@@ -0,0 +1,113 @@
+"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__, {
+    setLastActivity: ()=>setLastActivity,
+    getServerSessionId: ()=>getServerSessionId,
+    deriveSessionIdFromMCPSession: ()=>deriveSessionIdFromMCPSession,
+    getSessionInfo: ()=>getSessionInfo,
+    newSessionId: ()=>newSessionId
+});
+const external_version_js_namespaceObject = require("../version.js");
+const external_constants_js_namespaceObject = require("./constants.js");
+const external_ids_js_namespaceObject = require("./ids.js");
+const external_internal_js_namespaceObject = require("./internal.js");
+function newSessionId() {
+    return (0, external_ids_js_namespaceObject.newPrefixedId)('ses');
+}
+function deriveSessionIdFromMCPSession(mcpSessionId) {
+    return (0, external_ids_js_namespaceObject.deterministicPrefixedId)('ses', mcpSessionId);
+}
+function getServerSessionId(server, extra) {
+    const data = (0, external_internal_js_namespaceObject.getServerTrackingData)(server);
+    if (!data) throw new Error('Server tracking data not found');
+    const mcpSessionId = extra?.sessionId;
+    if (mcpSessionId) {
+        data.sessionId = deriveSessionIdFromMCPSession(mcpSessionId);
+        data.lastMcpSessionId = mcpSessionId;
+        data.sessionSource = 'mcp';
+        (0, external_internal_js_namespaceObject.setServerTrackingData)(server, data);
+        setLastActivity(server);
+        return data.sessionId;
+    }
+    if ('mcp' === data.sessionSource && data.lastMcpSessionId) {
+        setLastActivity(server);
+        return data.sessionId;
+    }
+    const now = Date.now();
+    const timeoutMs = 60 * external_constants_js_namespaceObject.INACTIVITY_TIMEOUT_IN_MINUTES * 1000;
+    if (now - data.lastActivity.getTime() > timeoutMs) {
+        data.sessionId = newSessionId();
+        data.sessionSource = 'generated';
+        (0, external_internal_js_namespaceObject.setServerTrackingData)(server, data);
+    }
+    setLastActivity(server);
+    return data.sessionId;
+}
+function setLastActivity(server) {
+    const data = (0, external_internal_js_namespaceObject.getServerTrackingData)(server);
+    if (!data) throw new Error('Server tracking data not found');
+    data.lastActivity = new Date();
+    (0, external_internal_js_namespaceObject.setServerTrackingData)(server, data);
+}
+function getSessionInfo(server, data, sessionId) {
+    let clientInfo = {
+        name: void 0,
+        version: void 0
+    };
+    if (!data?.sessionInfo.clientName) clientInfo = server.getClientVersion();
+    const actorInfo = data?.identifiedSessions.get(sessionId ?? data.sessionId);
+    const sessionInfo = {
+        ipAddress: void 0,
+        sdkLanguage: 'TypeScript',
+        sdkVersion: external_version_js_namespaceObject.version,
+        serverName: server._serverInfo?.name,
+        serverVersion: server._serverInfo?.version,
+        clientName: clientInfo?.name,
+        clientVersion: clientInfo?.version,
+        identifyActorGivenId: actorInfo?.distinctId,
+        identifyActorData: actorInfo?.properties || {},
+        identifyActorGroups: actorInfo?.groups
+    };
+    if (!data) return sessionInfo;
+    data.sessionInfo = sessionInfo;
+    (0, external_internal_js_namespaceObject.setServerTrackingData)(server, data);
+    return data.sessionInfo;
+}
+exports.deriveSessionIdFromMCPSession = __webpack_exports__.deriveSessionIdFromMCPSession;
+exports.getServerSessionId = __webpack_exports__.getServerSessionId;
+exports.getSessionInfo = __webpack_exports__.getSessionInfo;
+exports.newSessionId = __webpack_exports__.newSessionId;
+exports.setLastActivity = __webpack_exports__.setLastActivity;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "deriveSessionIdFromMCPSession",
+    "getServerSessionId",
+    "getSessionInfo",
+    "newSessionId",
+    "setLastActivity"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});