@posthog/mcp 0.0.8 → 0.1.16

package/dist/extensions/truncation.js

@@ -0,0 +1,277 @@
+"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__, {
+    MAX_BREADTH: ()=>MAX_BREADTH,
+    MAX_DEPTH: ()=>MAX_DEPTH,
+    MAX_EVENT_BYTES: ()=>MAX_EVENT_BYTES,
+    MAX_STRING_LENGTH: ()=>MAX_STRING_LENGTH,
+    normalize: ()=>normalize,
+    truncateEvent: ()=>truncateEvent
+});
+const MAX_DEPTH = 10;
+const MAX_BREADTH = 100;
+const MAX_STRING_LENGTH = 32768;
+const MAX_EVENT_BYTES = 102400;
+const MAX_USER_INTENT_LENGTH = 2048;
+const MAX_ERROR_MESSAGE_LENGTH = 2048;
+const MAX_RESOURCE_NAME_LENGTH = 256;
+const MAX_METADATA_LENGTH = 256;
+const MAX_STACK_FRAMES = 50;
+const MAX_CONTENT_TEXT_LENGTH = 32768;
+const TRUNCATION_SUFFIX = '...';
+function normalize(input, depth = MAX_DEPTH, maxBreadth = MAX_BREADTH, maxStringLength = MAX_STRING_LENGTH) {
+    const memo = new WeakSet();
+    return visit(input, depth, maxBreadth, maxStringLength, memo);
+}
+function visit(value, remainingDepth, maxBreadth, maxStringLength, memo) {
+    if (null === value) return null;
+    if (void 0 === value) return '[undefined]';
+    if ('boolean' == typeof value) return value;
+    if ('number' == typeof value) {
+        if (Number.isNaN(value)) return '[NaN]';
+        if (!Number.isFinite(value)) return value > 0 ? '[Infinity]' : '[-Infinity]';
+        return value;
+    }
+    if ('bigint' == typeof value) return `[BigInt: ${value}]`;
+    if ('string' == typeof value) {
+        if (value.length > maxStringLength) return value.slice(0, maxStringLength) + TRUNCATION_SUFFIX;
+        return value;
+    }
+    if ('symbol' == typeof value) {
+        const desc = value.description;
+        return desc ? `[Symbol(${desc})]` : '[Symbol()]';
+    }
+    if ('function' == typeof value) {
+        const name = value.name || '<anonymous>';
+        return `[Function: ${name}]`;
+    }
+    if (value instanceof Date) return Number.isNaN(value.getTime()) ? '[Invalid Date]' : value.toISOString();
+    if ('object' == typeof value) {
+        if (memo.has(value)) return '[Circular ~]';
+        if (remainingDepth <= 0) return Array.isArray(value) ? '[Array]' : '[Object]';
+        memo.add(value);
+        let result;
+        result = Array.isArray(value) ? visitArray(value, remainingDepth - 1, maxBreadth, maxStringLength, memo) : visitObject(value, remainingDepth - 1, maxBreadth, maxStringLength, memo);
+        memo.delete(value);
+        return result;
+    }
+    return String(value);
+}
+function visitArray(arr, remainingDepth, maxBreadth, maxStringLength, memo) {
+    const result = [];
+    for(let i = 0; i < arr.length; i++){
+        if (i >= maxBreadth) {
+            result.push('[MaxProperties ~]');
+            break;
+        }
+        result.push(visit(arr[i], remainingDepth, maxBreadth, maxStringLength, memo));
+    }
+    return result;
+}
+function visitObject(obj, remainingDepth, maxBreadth, maxStringLength, memo) {
+    const result = {};
+    const keys = Object.keys(obj);
+    let count = 0;
+    for (const key of keys){
+        if (count >= maxBreadth) {
+            result['...'] = '[MaxProperties ~]';
+            break;
+        }
+        if (void 0 !== obj[key]) {
+            result[key] = visit(obj[key], remainingDepth, maxBreadth, maxStringLength, memo);
+            count++;
+        }
+    }
+    return result;
+}
+function truncateString(str, maxLength) {
+    if (null == str) return str;
+    if (str.length <= maxLength) return str;
+    return str.slice(0, maxLength) + TRUNCATION_SUFFIX;
+}
+function truncateStackFrames(frames) {
+    if (!frames || frames.length <= MAX_STACK_FRAMES) return frames;
+    const half = Math.floor(MAX_STACK_FRAMES / 2);
+    return [
+        ...frames.slice(0, half),
+        ...frames.slice(-half)
+    ];
+}
+function truncateExceptionList(error) {
+    if (!Array.isArray(error.$exception_list)) return error;
+    return {
+        ...error,
+        $exception_list: error.$exception_list.map((exception)=>{
+            const next = {
+                ...exception
+            };
+            if ('string' == typeof next.value) next.value = truncateString(next.value, MAX_ERROR_MESSAGE_LENGTH);
+            if (next.stacktrace?.frames) next.stacktrace = {
+                ...next.stacktrace,
+                frames: truncateStackFrames(next.stacktrace.frames)
+            };
+            return next;
+        })
+    };
+}
+function truncateResponseContent(response) {
+    if (null == response || 'object' != typeof response) return response;
+    const result = {
+        ...response
+    };
+    if (Array.isArray(result.content)) result.content = result.content.map((block)=>{
+        if (null != block && 'object' == typeof block && 'type' in block && 'text' in block && block?.type === 'text' && 'string' == typeof block.text && block.text.length > MAX_CONTENT_TEXT_LENGTH) return {
+            ...block,
+            text: block.text.slice(0, MAX_CONTENT_TEXT_LENGTH) + TRUNCATION_SUFFIX
+        };
+        return block;
+    });
+    return result;
+}
+const textEncoder = new TextEncoder();
+function jsonByteSize(value) {
+    return textEncoder.encode(JSON.stringify(value)).length;
+}
+function truncateLargestFields(obj, maxBytes) {
+    const result = structuredClone(obj);
+    for(let attempt = 0; attempt < 10; attempt++){
+        const currentSize = jsonByteSize(result);
+        if (currentSize <= maxBytes) break;
+        const excess = currentSize - maxBytes;
+        const stringPaths = [];
+        collectStringPaths(result, [], stringPaths);
+        stringPaths.sort((a, b)=>b.length - a.length);
+        if (0 === stringPaths.length) break;
+        let remaining = excess + 200;
+        let truncated = false;
+        for (const { path, length } of stringPaths){
+            if (remaining <= 0) break;
+            const reduction = Math.min(remaining, Math.floor(0.5 * length));
+            if (reduction < 10) continue;
+            const newLength = length - reduction;
+            const currentValue = getNestedValue(result, path);
+            if ('string' == typeof currentValue) {
+                setNestedValue(result, path, currentValue.slice(0, newLength) + TRUNCATION_SUFFIX);
+                remaining -= reduction;
+                truncated = true;
+            }
+        }
+        if (!truncated) break;
+    }
+    return result;
+}
+function collectStringPaths(obj, currentPath, results) {
+    if ('string' == typeof obj && obj.length > 100) return void results.push({
+        path: [
+            ...currentPath
+        ],
+        length: obj.length
+    });
+    if (Array.isArray(obj)) {
+        for (const [i, item] of obj.entries())collectStringPaths(item, [
+            ...currentPath,
+            String(i)
+        ], results);
+        return;
+    }
+    if (null != obj && 'object' == typeof obj) for (const [key, value] of Object.entries(obj))collectStringPaths(value, [
+        ...currentPath,
+        key
+    ], results);
+}
+function getNestedValue(obj, path) {
+    let current = obj;
+    for (const key of path){
+        if (null == current || 'object' != typeof current) return;
+        current = current[key];
+    }
+    return current;
+}
+function setNestedValue(obj, path, value) {
+    let current = obj;
+    for(let i = 0; i < path.length - 1; i++){
+        if (null == current || 'object' != typeof current) return;
+        current = current[path[i]];
+    }
+    const finalKey = path.at(-1);
+    if (void 0 !== finalKey && null != current && 'object' == typeof current) current[finalKey] = value;
+}
+function truncateToSize(event) {
+    if (jsonByteSize(event) <= MAX_EVENT_BYTES) return event;
+    for(let depth = MAX_DEPTH - 1; depth >= 1; depth--){
+        const reduced = {
+            ...event
+        };
+        if (null != reduced.parameters) reduced.parameters = normalize(reduced.parameters, depth);
+        if (null != reduced.response) reduced.response = normalize(reduced.response, depth);
+        if (null != reduced.identifyActorData) reduced.identifyActorData = normalize(reduced.identifyActorData, depth);
+        if (null != reduced.error) reduced.error = normalize(reduced.error, depth);
+        if (jsonByteSize(reduced) <= MAX_EVENT_BYTES) return reduced;
+    }
+    const minimal = {
+        ...event
+    };
+    if (null != minimal.parameters) minimal.parameters = normalize(minimal.parameters, 1);
+    if (null != minimal.response) minimal.response = normalize(minimal.response, 1);
+    if (null != minimal.identifyActorData) minimal.identifyActorData = normalize(minimal.identifyActorData, 1);
+    if (null != minimal.error) minimal.error = normalize(minimal.error, 1);
+    return truncateLargestFields(minimal, MAX_EVENT_BYTES);
+}
+function truncateEvent(event) {
+    const result = {
+        ...event
+    };
+    result.userIntent = truncateString(result.userIntent, MAX_USER_INTENT_LENGTH);
+    result.resourceName = truncateString(result.resourceName, MAX_RESOURCE_NAME_LENGTH);
+    result.serverName = truncateString(result.serverName, MAX_METADATA_LENGTH);
+    result.serverVersion = truncateString(result.serverVersion, MAX_METADATA_LENGTH);
+    result.clientName = truncateString(result.clientName, MAX_METADATA_LENGTH);
+    result.clientVersion = truncateString(result.clientVersion, MAX_METADATA_LENGTH);
+    if (null != result.error && 'object' == typeof result.error) result.error = truncateExceptionList(result.error);
+    result.response = truncateResponseContent(result.response);
+    if (null != result.parameters) result.parameters = normalize(result.parameters);
+    if (null != result.response) result.response = normalize(result.response);
+    if (null != result.identifyActorData) result.identifyActorData = normalize(result.identifyActorData);
+    if (null != result.error) result.error = normalize(result.error);
+    return truncateToSize(result);
+}
+exports.MAX_BREADTH = __webpack_exports__.MAX_BREADTH;
+exports.MAX_DEPTH = __webpack_exports__.MAX_DEPTH;
+exports.MAX_EVENT_BYTES = __webpack_exports__.MAX_EVENT_BYTES;
+exports.MAX_STRING_LENGTH = __webpack_exports__.MAX_STRING_LENGTH;
+exports.normalize = __webpack_exports__.normalize;
+exports.truncateEvent = __webpack_exports__.truncateEvent;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "MAX_BREADTH",
+    "MAX_DEPTH",
+    "MAX_EVENT_BYTES",
+    "MAX_STRING_LENGTH",
+    "normalize",
+    "truncateEvent"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/truncation.mjs

@@ -0,0 +1,228 @@
+const MAX_DEPTH = 10;
+const MAX_BREADTH = 100;
+const MAX_STRING_LENGTH = 32768;
+const MAX_EVENT_BYTES = 102400;
+const MAX_USER_INTENT_LENGTH = 2048;
+const MAX_ERROR_MESSAGE_LENGTH = 2048;
+const MAX_RESOURCE_NAME_LENGTH = 256;
+const MAX_METADATA_LENGTH = 256;
+const MAX_STACK_FRAMES = 50;
+const MAX_CONTENT_TEXT_LENGTH = 32768;
+const TRUNCATION_SUFFIX = '...';
+function normalize(input, depth = MAX_DEPTH, maxBreadth = MAX_BREADTH, maxStringLength = MAX_STRING_LENGTH) {
+    const memo = new WeakSet();
+    return visit(input, depth, maxBreadth, maxStringLength, memo);
+}
+function visit(value, remainingDepth, maxBreadth, maxStringLength, memo) {
+    if (null === value) return null;
+    if (void 0 === value) return '[undefined]';
+    if ('boolean' == typeof value) return value;
+    if ('number' == typeof value) {
+        if (Number.isNaN(value)) return '[NaN]';
+        if (!Number.isFinite(value)) return value > 0 ? '[Infinity]' : '[-Infinity]';
+        return value;
+    }
+    if ('bigint' == typeof value) return `[BigInt: ${value}]`;
+    if ('string' == typeof value) {
+        if (value.length > maxStringLength) return value.slice(0, maxStringLength) + TRUNCATION_SUFFIX;
+        return value;
+    }
+    if ('symbol' == typeof value) {
+        const desc = value.description;
+        return desc ? `[Symbol(${desc})]` : '[Symbol()]';
+    }
+    if ('function' == typeof value) {
+        const name = value.name || '<anonymous>';
+        return `[Function: ${name}]`;
+    }
+    if (value instanceof Date) return Number.isNaN(value.getTime()) ? '[Invalid Date]' : value.toISOString();
+    if ('object' == typeof value) {
+        if (memo.has(value)) return '[Circular ~]';
+        if (remainingDepth <= 0) return Array.isArray(value) ? '[Array]' : '[Object]';
+        memo.add(value);
+        let result;
+        result = Array.isArray(value) ? visitArray(value, remainingDepth - 1, maxBreadth, maxStringLength, memo) : visitObject(value, remainingDepth - 1, maxBreadth, maxStringLength, memo);
+        memo.delete(value);
+        return result;
+    }
+    return String(value);
+}
+function visitArray(arr, remainingDepth, maxBreadth, maxStringLength, memo) {
+    const result = [];
+    for(let i = 0; i < arr.length; i++){
+        if (i >= maxBreadth) {
+            result.push('[MaxProperties ~]');
+            break;
+        }
+        result.push(visit(arr[i], remainingDepth, maxBreadth, maxStringLength, memo));
+    }
+    return result;
+}
+function visitObject(obj, remainingDepth, maxBreadth, maxStringLength, memo) {
+    const result = {};
+    const keys = Object.keys(obj);
+    let count = 0;
+    for (const key of keys){
+        if (count >= maxBreadth) {
+            result['...'] = '[MaxProperties ~]';
+            break;
+        }
+        if (void 0 !== obj[key]) {
+            result[key] = visit(obj[key], remainingDepth, maxBreadth, maxStringLength, memo);
+            count++;
+        }
+    }
+    return result;
+}
+function truncateString(str, maxLength) {
+    if (null == str) return str;
+    if (str.length <= maxLength) return str;
+    return str.slice(0, maxLength) + TRUNCATION_SUFFIX;
+}
+function truncateStackFrames(frames) {
+    if (!frames || frames.length <= MAX_STACK_FRAMES) return frames;
+    const half = Math.floor(MAX_STACK_FRAMES / 2);
+    return [
+        ...frames.slice(0, half),
+        ...frames.slice(-half)
+    ];
+}
+function truncateExceptionList(error) {
+    if (!Array.isArray(error.$exception_list)) return error;
+    return {
+        ...error,
+        $exception_list: error.$exception_list.map((exception)=>{
+            const next = {
+                ...exception
+            };
+            if ('string' == typeof next.value) next.value = truncateString(next.value, MAX_ERROR_MESSAGE_LENGTH);
+            if (next.stacktrace?.frames) next.stacktrace = {
+                ...next.stacktrace,
+                frames: truncateStackFrames(next.stacktrace.frames)
+            };
+            return next;
+        })
+    };
+}
+function truncateResponseContent(response) {
+    if (null == response || 'object' != typeof response) return response;
+    const result = {
+        ...response
+    };
+    if (Array.isArray(result.content)) result.content = result.content.map((block)=>{
+        if (null != block && 'object' == typeof block && 'type' in block && 'text' in block && block?.type === 'text' && 'string' == typeof block.text && block.text.length > MAX_CONTENT_TEXT_LENGTH) return {
+            ...block,
+            text: block.text.slice(0, MAX_CONTENT_TEXT_LENGTH) + TRUNCATION_SUFFIX
+        };
+        return block;
+    });
+    return result;
+}
+const textEncoder = new TextEncoder();
+function jsonByteSize(value) {
+    return textEncoder.encode(JSON.stringify(value)).length;
+}
+function truncateLargestFields(obj, maxBytes) {
+    const result = structuredClone(obj);
+    for(let attempt = 0; attempt < 10; attempt++){
+        const currentSize = jsonByteSize(result);
+        if (currentSize <= maxBytes) break;
+        const excess = currentSize - maxBytes;
+        const stringPaths = [];
+        collectStringPaths(result, [], stringPaths);
+        stringPaths.sort((a, b)=>b.length - a.length);
+        if (0 === stringPaths.length) break;
+        let remaining = excess + 200;
+        let truncated = false;
+        for (const { path, length } of stringPaths){
+            if (remaining <= 0) break;
+            const reduction = Math.min(remaining, Math.floor(0.5 * length));
+            if (reduction < 10) continue;
+            const newLength = length - reduction;
+            const currentValue = getNestedValue(result, path);
+            if ('string' == typeof currentValue) {
+                setNestedValue(result, path, currentValue.slice(0, newLength) + TRUNCATION_SUFFIX);
+                remaining -= reduction;
+                truncated = true;
+            }
+        }
+        if (!truncated) break;
+    }
+    return result;
+}
+function collectStringPaths(obj, currentPath, results) {
+    if ('string' == typeof obj && obj.length > 100) return void results.push({
+        path: [
+            ...currentPath
+        ],
+        length: obj.length
+    });
+    if (Array.isArray(obj)) {
+        for (const [i, item] of obj.entries())collectStringPaths(item, [
+            ...currentPath,
+            String(i)
+        ], results);
+        return;
+    }
+    if (null != obj && 'object' == typeof obj) for (const [key, value] of Object.entries(obj))collectStringPaths(value, [
+        ...currentPath,
+        key
+    ], results);
+}
+function getNestedValue(obj, path) {
+    let current = obj;
+    for (const key of path){
+        if (null == current || 'object' != typeof current) return;
+        current = current[key];
+    }
+    return current;
+}
+function setNestedValue(obj, path, value) {
+    let current = obj;
+    for(let i = 0; i < path.length - 1; i++){
+        if (null == current || 'object' != typeof current) return;
+        current = current[path[i]];
+    }
+    const finalKey = path.at(-1);
+    if (void 0 !== finalKey && null != current && 'object' == typeof current) current[finalKey] = value;
+}
+function truncateToSize(event) {
+    if (jsonByteSize(event) <= MAX_EVENT_BYTES) return event;
+    for(let depth = MAX_DEPTH - 1; depth >= 1; depth--){
+        const reduced = {
+            ...event
+        };
+        if (null != reduced.parameters) reduced.parameters = normalize(reduced.parameters, depth);
+        if (null != reduced.response) reduced.response = normalize(reduced.response, depth);
+        if (null != reduced.identifyActorData) reduced.identifyActorData = normalize(reduced.identifyActorData, depth);
+        if (null != reduced.error) reduced.error = normalize(reduced.error, depth);
+        if (jsonByteSize(reduced) <= MAX_EVENT_BYTES) return reduced;
+    }
+    const minimal = {
+        ...event
+    };
+    if (null != minimal.parameters) minimal.parameters = normalize(minimal.parameters, 1);
+    if (null != minimal.response) minimal.response = normalize(minimal.response, 1);
+    if (null != minimal.identifyActorData) minimal.identifyActorData = normalize(minimal.identifyActorData, 1);
+    if (null != minimal.error) minimal.error = normalize(minimal.error, 1);
+    return truncateLargestFields(minimal, MAX_EVENT_BYTES);
+}
+function truncateEvent(event) {
+    const result = {
+        ...event
+    };
+    result.userIntent = truncateString(result.userIntent, MAX_USER_INTENT_LENGTH);
+    result.resourceName = truncateString(result.resourceName, MAX_RESOURCE_NAME_LENGTH);
+    result.serverName = truncateString(result.serverName, MAX_METADATA_LENGTH);
+    result.serverVersion = truncateString(result.serverVersion, MAX_METADATA_LENGTH);
+    result.clientName = truncateString(result.clientName, MAX_METADATA_LENGTH);
+    result.clientVersion = truncateString(result.clientVersion, MAX_METADATA_LENGTH);
+    if (null != result.error && 'object' == typeof result.error) result.error = truncateExceptionList(result.error);
+    result.response = truncateResponseContent(result.response);
+    if (null != result.parameters) result.parameters = normalize(result.parameters);
+    if (null != result.response) result.response = normalize(result.response);
+    if (null != result.identifyActorData) result.identifyActorData = normalize(result.identifyActorData);
+    if (null != result.error) result.error = normalize(result.error);
+    return truncateToSize(result);
+}
+export { MAX_BREADTH, MAX_DEPTH, MAX_EVENT_BYTES, MAX_STRING_LENGTH, normalize, truncateEvent };

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+import type { PostHog } from 'posthog-node';
+import { deriveSessionIdFromMCPSession } from './extensions/session';
+import type { McpAnalytics, MCPAnalyticsOptions } from './types';
+/**
+ * Instruments an MCP server so PostHog auto-captures tool calls, tool listings, initialize
+ * requests, identity, and exceptions. Returns a handle whose `capture()` method records
+ * custom events, so you don't pass the server around after wiring it up.
+ *
+ * **Idempotent per server instance.** Per-server tracking state lives in a module-level
+ * `WeakMap<MCPServerLike, MCPAnalyticsData>` (`internal.ts`); a second `instrument()` call
+ * on the same server reuses it rather than double-wrapping handlers.
+ *
+ * @param server - The MCP server to instrument (low-level `Server` or high-level `McpServer`).
+ * @param posthog - A `posthog-node` client you construct and own (matching `@posthog/ai`); call `posthog.shutdown()` on exit to flush.
+ * @param options - Optional configuration. See `MCPAnalyticsOptions`.
+ *
+ * @example
+ * ```ts
+ * import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"
+ * import { PostHog } from "posthog-node"
+ * import { instrument } from "@posthog/mcp"
+ *
+ * const posthog = new PostHog(process.env.POSTHOG_PROJECT_TOKEN, { host: "https://us.i.posthog.com" })
+ * const server = new McpServer({ name: "my-mcp", version: "1.0.0" })
+ * const analytics = instrument(server, posthog)
+ *
+ * await analytics.capture({ event: "feedback_submitted", properties: { rating: 5 } })
+ * ```
+ */
+declare function instrument(server: unknown, posthog: PostHog, options?: MCPAnalyticsOptions): McpAnalytics;
+export { deriveSessionIdFromMCPSession };
+export { POSTHOG_MCP_ANALYTICS_SOURCE, PostHogMCPAnalyticsEvent, PostHogMCPAnalyticsProperty, } from './extensions/constants';
+export type { BeforeSendFn, CaptureEventData, McpAnalytics, MCPAnalyticsContextOptions, MCPAnalyticsIntentSource, MCPAnalyticsOptions, UserIdentity, } from './types';
+export type IdentifyFunction = MCPAnalyticsOptions['identify'];
+export { instrument };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAO3C,OAAO,EAAE,6BAA6B,EAAgC,MAAM,sBAAsB,CAAA;AAGlG,OAAO,KAAK,EAGV,YAAY,EAEZ,mBAAmB,EAGpB,MAAM,SAAS,CAAA;AAEhB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,iBAAS,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAE,mBAAwB,GAAG,YAAY,CA6BtG;AAkFD,OAAO,EAAE,6BAA6B,EAAE,CAAA;AACxC,OAAO,EACL,4BAA4B,EAC5B,wBAAwB,EACxB,2BAA2B,GAC5B,MAAM,wBAAwB,CAAA;AAC/B,YAAY,EACV,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,0BAA0B,EAC1B,wBAAwB,EACxB,mBAAmB,EACnB,YAAY,GACb,MAAM,SAAS,CAAA;AAChB,MAAM,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,UAAU,CAAC,CAAA;AAC9D,OAAO,EAAE,UAAU,EAAE,CAAA"}

package/dist/index.js

@@ -0,0 +1,132 @@
+"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__, {
+    instrument: ()=>instrument,
+    PostHogMCPAnalyticsEvent: ()=>constants_js_namespaceObject.PostHogMCPAnalyticsEvent,
+    POSTHOG_MCP_ANALYTICS_SOURCE: ()=>constants_js_namespaceObject.POSTHOG_MCP_ANALYTICS_SOURCE,
+    deriveSessionIdFromMCPSession: ()=>session_js_namespaceObject.deriveSessionIdFromMCPSession,
+    PostHogMCPAnalyticsProperty: ()=>constants_js_namespaceObject.PostHogMCPAnalyticsProperty
+});
+const compatibility_js_namespaceObject = require("./extensions/compatibility.js");
+const sink_js_namespaceObject = require("./extensions/sink.js");
+const event_types_js_namespaceObject = require("./extensions/event-types.js");
+const internal_js_namespaceObject = require("./extensions/internal.js");
+const logger_js_namespaceObject = require("./extensions/logger.js");
+const capture_js_namespaceObject = require("./extensions/capture.js");
+const session_js_namespaceObject = require("./extensions/session.js");
+const instrument_lowlevel_js_namespaceObject = require("./extensions/instrument-lowlevel.js");
+const instrument_highlevel_js_namespaceObject = require("./extensions/instrument-highlevel.js");
+const constants_js_namespaceObject = require("./extensions/constants.js");
+function instrument(server, posthog, options = {}) {
+    try {
+        if (options.logger) (0, logger_js_namespaceObject.setLogger)(options.logger);
+        if (!posthog) (0, logger_js_namespaceObject.log)('Warning: No PostHog client passed to instrument(). Events will not be sent anywhere.');
+        const validatedServer = (0, compatibility_js_namespaceObject.isCompatibleServerType)(server);
+        const lowLevelServer = getLowLevelServer(validatedServer);
+        if ((0, internal_js_namespaceObject.getServerTrackingData)(lowLevelServer)) {
+            (0, logger_js_namespaceObject.log)('instrument() - Server already instrumented, skipping initialization');
+            return createAnalyticsHandle(lowLevelServer);
+        }
+        const sink = posthog ? new sink_js_namespaceObject.McpEventSink(posthog) : void 0;
+        const mcpAnalyticsData = buildTrackingData(lowLevelServer, options, sink);
+        (0, internal_js_namespaceObject.setServerTrackingData)(lowLevelServer, mcpAnalyticsData);
+        setupTrackedServer(validatedServer, lowLevelServer);
+        return createAnalyticsHandle(lowLevelServer);
+    } catch (error) {
+        (0, logger_js_namespaceObject.log)(`Warning: Failed to instrument server - ${error}`);
+        return {
+            capture: async ()=>void 0
+        };
+    }
+}
+function createAnalyticsHandle(lowLevelServer) {
+    return {
+        capture: (eventData)=>captureCustomEvent(lowLevelServer, eventData)
+    };
+}
+function getLowLevelServer(server) {
+    return (0, compatibility_js_namespaceObject.isHighLevelServer)(server) ? server.server : server;
+}
+const DEFAULT_OPTIONS = {
+    reportMissing: false,
+    enableConversationId: false
+};
+function buildTrackingData(lowLevelServer, options, sink) {
+    return {
+        sink,
+        sessionId: (0, session_js_namespaceObject.newSessionId)(),
+        lastActivity: new Date(),
+        identifiedSessions: new internal_js_namespaceObject.IdentityCache(),
+        toolDescriptions: new Map(),
+        sessionInfo: (0, session_js_namespaceObject.getSessionInfo)(lowLevelServer, void 0),
+        options: {
+            ...DEFAULT_OPTIONS,
+            ...options
+        },
+        sessionSource: 'generated'
+    };
+}
+function setupTrackedServer(validatedServer, lowLevelServer) {
+    if ((0, compatibility_js_namespaceObject.isHighLevelServer)(validatedServer)) {
+        const highLevelServer = validatedServer;
+        (0, instrument_highlevel_js_namespaceObject.instrumentHighLevelServer)(highLevelServer);
+        return;
+    }
+    try {
+        (0, instrument_lowlevel_js_namespaceObject.instrumentLowLevelServer)(lowLevelServer);
+    } catch (error) {
+        (0, logger_js_namespaceObject.log)(`Warning: Failed to setup tool call instrumentation - ${error}`);
+    }
+}
+async function captureCustomEvent(lowLevelServer, eventData) {
+    if (!eventData || 'string' != typeof eventData.event || 0 === eventData.event.length) throw new Error('`capture` requires an `event` name, e.g. analytics.capture({ event: "feedback_submitted" })');
+    const trackingData = (0, internal_js_namespaceObject.getServerTrackingData)(lowLevelServer);
+    if (!trackingData) return;
+    const event = {
+        sessionId: trackingData.sessionId,
+        eventType: event_types_js_namespaceObject.MCPAnalyticsEventType.custom,
+        eventName: eventData.event,
+        timestamp: new Date(),
+        properties: eventData.properties
+    };
+    await (0, capture_js_namespaceObject.captureEvent)(lowLevelServer, event);
+    (0, logger_js_namespaceObject.log)(`Captured event "${eventData.event}" for session ${trackingData.sessionId}`);
+}
+exports.POSTHOG_MCP_ANALYTICS_SOURCE = __webpack_exports__.POSTHOG_MCP_ANALYTICS_SOURCE;
+exports.PostHogMCPAnalyticsEvent = __webpack_exports__.PostHogMCPAnalyticsEvent;
+exports.PostHogMCPAnalyticsProperty = __webpack_exports__.PostHogMCPAnalyticsProperty;
+exports.deriveSessionIdFromMCPSession = __webpack_exports__.deriveSessionIdFromMCPSession;
+exports.instrument = __webpack_exports__.instrument;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "POSTHOG_MCP_ANALYTICS_SOURCE",
+    "PostHogMCPAnalyticsEvent",
+    "PostHogMCPAnalyticsProperty",
+    "deriveSessionIdFromMCPSession",
+    "instrument"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});