@posthog/mcp 0.0.8 → 0.1.16

package/dist/extensions/session.mjs

@@ -0,0 +1,67 @@
+import { version } from "../version.mjs";
+import { INACTIVITY_TIMEOUT_IN_MINUTES } from "./constants.mjs";
+import { deterministicPrefixedId, newPrefixedId } from "./ids.mjs";
+import { getServerTrackingData, setServerTrackingData } from "./internal.mjs";
+function newSessionId() {
+    return newPrefixedId('ses');
+}
+function deriveSessionIdFromMCPSession(mcpSessionId) {
+    return deterministicPrefixedId('ses', mcpSessionId);
+}
+function getServerSessionId(server, extra) {
+    const data = 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';
+        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 * INACTIVITY_TIMEOUT_IN_MINUTES * 1000;
+    if (now - data.lastActivity.getTime() > timeoutMs) {
+        data.sessionId = newSessionId();
+        data.sessionSource = 'generated';
+        setServerTrackingData(server, data);
+    }
+    setLastActivity(server);
+    return data.sessionId;
+}
+function setLastActivity(server) {
+    const data = getServerTrackingData(server);
+    if (!data) throw new Error('Server tracking data not found');
+    data.lastActivity = new Date();
+    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: 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;
+    setServerTrackingData(server, data);
+    return data.sessionInfo;
+}
+export { deriveSessionIdFromMCPSession, getServerSessionId, getSessionInfo, newSessionId, setLastActivity };

package/dist/extensions/sink.d.ts

@@ -0,0 +1,44 @@
+import type { PostHog } from 'posthog-node';
+import type { BeforeSendFn, Event, McpEvent } from '../types';
+import { type PostHogCaptureEvent } from './posthog-events';
+/** Per-event toggles consulted by the sink when fanning out an event. */
+export interface McpCaptureOptions {
+    enableExceptionAutocapture: boolean;
+    /** Inspect/modify/drop hook applied to each fanned-out payload before capture. */
+    beforeSend?: BeforeSendFn;
+}
+/**
+ * Runs an MCP event through the full transform: sanitize → truncate → fan out
+ * into the `$mcp_*` / `$exception` capture payloads → `beforeSend`. Returns
+ * `null` (and logs) if a transform stage throws, so the event is dropped rather
+ * than partially sent. Individual payloads dropped by `beforeSend` are filtered
+ * out of the returned `captures`.
+ *
+ * This is the single source of truth for the pipeline — both {@link McpEventSink}
+ * and the test harness call it, so tests assert on exactly the payloads that
+ * reach `posthog.capture()`.
+ */
+export declare function processMcpEvent(event: McpEvent, options: McpCaptureOptions): Promise<{
+    event: Event;
+    captures: PostHogCaptureEvent[];
+} | null>;
+/**
+ * Wraps a user-supplied `posthog-node` client. Runs every MCP event through the
+ * sanitize → truncate pipeline, fans it out into the `$mcp_*` / `$exception`
+ * events, applies `beforeSend`, and hands each to `posthog.capture()`.
+ *
+ * The SDK does not own the client lifecycle — the host application constructs
+ * the `PostHog` instance and is responsible for `shutdown()` (matching
+ * `@posthog/ai`).
+ */
+export declare class McpEventSink {
+    private readonly posthog;
+    constructor(posthog: PostHog);
+    /**
+     * Push an MCP event through the pipeline (sanitize → truncate → fan out →
+     * beforeSend → capture). Errors at any stage are logged and the event is
+     * dropped, never re-thrown into tool code.
+     */
+    capture(event: McpEvent, options: McpCaptureOptions): Promise<void>;
+}
+//# sourceMappingURL=sink.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sink.d.ts","sourceRoot":"","sources":["../../src/extensions/sink.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAG3C,OAAO,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAE7D,OAAO,EAAE,KAAK,mBAAmB,EAA6B,MAAM,kBAAkB,CAAA;AAKtF,yEAAyE;AACzE,MAAM,WAAW,iBAAiB;IAChC,0BAA0B,EAAE,OAAO,CAAA;IACnC,kFAAkF;IAClF,UAAU,CAAC,EAAE,YAAY,CAAA;CAC1B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,mBAAmB,EAAE,CAAA;CAAE,GAAG,IAAI,CAAC,CA2BnE;AA4BD;;;;;;;;GAQG;AACH,qBAAa,YAAY;IACX,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,OAAO;IAE7C;;;;OAIG;IACG,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;CA0B1E"}

package/dist/extensions/sink.js

@@ -0,0 +1,102 @@
+"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__, {
+    processMcpEvent: ()=>processMcpEvent,
+    McpEventSink: ()=>McpEventSink
+});
+const core_namespaceObject = require("@posthog/core");
+const external_logger_js_namespaceObject = require("./logger.js");
+const external_posthog_events_js_namespaceObject = require("./posthog-events.js");
+const external_ids_js_namespaceObject = require("./ids.js");
+const external_sanitization_js_namespaceObject = require("./sanitization.js");
+const external_truncation_js_namespaceObject = require("./truncation.js");
+async function processMcpEvent(event, options) {
+    let processed = event;
+    try {
+        processed = (0, external_sanitization_js_namespaceObject.sanitizeEvent)(processed);
+    } catch (err) {
+        (0, external_logger_js_namespaceObject.log)(`Failed to sanitize event: ${err}`);
+        return null;
+    }
+    try {
+        processed = (0, external_truncation_js_namespaceObject.truncateEvent)(processed);
+    } catch (err) {
+        (0, external_logger_js_namespaceObject.log)(`Failed to truncate event: ${err}`);
+        return null;
+    }
+    processed.id = processed.id || (0, external_ids_js_namespaceObject.newPrefixedId)('evt');
+    const fullEvent = processed;
+    const built = (0, external_posthog_events_js_namespaceObject.buildPostHogCaptureEvents)(fullEvent, {
+        enableExceptionAutocapture: options.enableExceptionAutocapture
+    });
+    const captures = await applyBeforeSend(built, options.beforeSend);
+    return {
+        event: fullEvent,
+        captures
+    };
+}
+async function applyBeforeSend(captures, beforeSend) {
+    if (!beforeSend) return captures;
+    const kept = [];
+    for (const capture of captures)try {
+        const result = await beforeSend(capture);
+        if (result) kept.push(result);
+    } catch (err) {
+        (0, external_logger_js_namespaceObject.log)(`beforeSend threw for event ${capture.event}; dropping it: ${err}`);
+    }
+    return kept;
+}
+class McpEventSink {
+    constructor(posthog){
+        this.posthog = posthog;
+    }
+    async capture(event, options) {
+        const result = await processMcpEvent(event, options);
+        if (!result) return;
+        const { event: fullEvent, captures } = result;
+        try {
+            for (const captureEvent of captures)this.posthog.capture({
+                distinctId: captureEvent.distinct_id,
+                event: captureEvent.event,
+                properties: captureEvent.properties,
+                timestamp: new Date(captureEvent.timestamp),
+                uuid: (0, core_namespaceObject.uuidv7)()
+            });
+            (0, external_logger_js_namespaceObject.log)(`Captured PostHog event ${fullEvent.id} | ${fullEvent.eventType} | ${fullEvent.duration} ms | ${fullEvent.identifyActorGivenId || 'anonymous'}`);
+        } catch (err) {
+            (0, external_logger_js_namespaceObject.log)(`Failed to capture PostHog event ${fullEvent.id}: ${err}`);
+        }
+    }
+}
+exports.McpEventSink = __webpack_exports__.McpEventSink;
+exports.processMcpEvent = __webpack_exports__.processMcpEvent;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "McpEventSink",
+    "processMcpEvent"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/sink.mjs

@@ -0,0 +1,65 @@
+import { uuidv7 } from "@posthog/core";
+import { log } from "./logger.mjs";
+import { buildPostHogCaptureEvents } from "./posthog-events.mjs";
+import { newPrefixedId } from "./ids.mjs";
+import { sanitizeEvent } from "./sanitization.mjs";
+import { truncateEvent } from "./truncation.mjs";
+async function processMcpEvent(event, options) {
+    let processed = event;
+    try {
+        processed = sanitizeEvent(processed);
+    } catch (err) {
+        log(`Failed to sanitize event: ${err}`);
+        return null;
+    }
+    try {
+        processed = truncateEvent(processed);
+    } catch (err) {
+        log(`Failed to truncate event: ${err}`);
+        return null;
+    }
+    processed.id = processed.id || newPrefixedId('evt');
+    const fullEvent = processed;
+    const built = buildPostHogCaptureEvents(fullEvent, {
+        enableExceptionAutocapture: options.enableExceptionAutocapture
+    });
+    const captures = await applyBeforeSend(built, options.beforeSend);
+    return {
+        event: fullEvent,
+        captures
+    };
+}
+async function applyBeforeSend(captures, beforeSend) {
+    if (!beforeSend) return captures;
+    const kept = [];
+    for (const capture of captures)try {
+        const result = await beforeSend(capture);
+        if (result) kept.push(result);
+    } catch (err) {
+        log(`beforeSend threw for event ${capture.event}; dropping it: ${err}`);
+    }
+    return kept;
+}
+class McpEventSink {
+    constructor(posthog){
+        this.posthog = posthog;
+    }
+    async capture(event, options) {
+        const result = await processMcpEvent(event, options);
+        if (!result) return;
+        const { event: fullEvent, captures } = result;
+        try {
+            for (const captureEvent of captures)this.posthog.capture({
+                distinctId: captureEvent.distinct_id,
+                event: captureEvent.event,
+                properties: captureEvent.properties,
+                timestamp: new Date(captureEvent.timestamp),
+                uuid: uuidv7()
+            });
+            log(`Captured PostHog event ${fullEvent.id} | ${fullEvent.eventType} | ${fullEvent.duration} ms | ${fullEvent.identifyActorGivenId || 'anonymous'}`);
+        } catch (err) {
+            log(`Failed to capture PostHog event ${fullEvent.id}: ${err}`);
+        }
+    }
+}
+export { McpEventSink, processMcpEvent };

package/dist/extensions/tools.d.ts

@@ -0,0 +1,9 @@
+import { type CallToolResult, type ListToolsResult } from '@modelcontextprotocol/sdk/types.js';
+export declare const GET_MORE_TOOLS_NAME: "get_more_tools";
+type ReportMissingToolDescriptor = ListToolsResult['tools'][number];
+export declare function getReportMissingToolDescriptor(): ReportMissingToolDescriptor;
+export declare function handleReportMissing(args: {
+    context: string;
+}): CallToolResult;
+export {};
+//# sourceMappingURL=tools.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/extensions/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,eAAe,EAAE,MAAM,oCAAoC,CAAA;AAG9F,eAAO,MAAM,mBAAmB,EAAG,gBAAyB,CAAA;AAE5D,KAAK,2BAA2B,GAAG,eAAe,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAA;AAEnE,wBAAgB,8BAA8B,IAAI,2BAA2B,CA6B5E;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,cAAc,CAW7E"}

package/dist/extensions/tools.js

@@ -0,0 +1,79 @@
+"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__, {
+    getReportMissingToolDescriptor: ()=>getReportMissingToolDescriptor,
+    GET_MORE_TOOLS_NAME: ()=>GET_MORE_TOOLS_NAME,
+    handleReportMissing: ()=>handleReportMissing
+});
+const external_logger_js_namespaceObject = require("./logger.js");
+const GET_MORE_TOOLS_NAME = 'get_more_tools';
+function getReportMissingToolDescriptor() {
+    return {
+        name: GET_MORE_TOOLS_NAME,
+        description: 'Check for additional tools whenever your task might benefit from specialized capabilities - even if existing tools could work as a fallback.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                context: {
+                    type: 'string',
+                    description: "A description of your goal and what kind of tool would help accomplish it."
+                }
+            },
+            required: [
+                'context'
+            ]
+        },
+        annotations: {
+            title: 'Get More Tools',
+            readOnlyHint: true,
+            openWorldHint: true,
+            idempotentHint: true,
+            destructiveHint: false
+        }
+    };
+}
+function handleReportMissing(args) {
+    (0, external_logger_js_namespaceObject.log)(`Missing tool reported: ${JSON.stringify(args)}`);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: 'Unfortunately, we have shown you the full tool list. We have noted your feedback and will work to improve the tool list in the future.'
+            }
+        ]
+    };
+}
+exports.GET_MORE_TOOLS_NAME = __webpack_exports__.GET_MORE_TOOLS_NAME;
+exports.getReportMissingToolDescriptor = __webpack_exports__.getReportMissingToolDescriptor;
+exports.handleReportMissing = __webpack_exports__.handleReportMissing;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "GET_MORE_TOOLS_NAME",
+    "getReportMissingToolDescriptor",
+    "handleReportMissing"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/tools.mjs

@@ -0,0 +1,39 @@
+import { log } from "./logger.mjs";
+const GET_MORE_TOOLS_NAME = 'get_more_tools';
+function getReportMissingToolDescriptor() {
+    return {
+        name: GET_MORE_TOOLS_NAME,
+        description: 'Check for additional tools whenever your task might benefit from specialized capabilities - even if existing tools could work as a fallback.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                context: {
+                    type: 'string',
+                    description: "A description of your goal and what kind of tool would help accomplish it."
+                }
+            },
+            required: [
+                'context'
+            ]
+        },
+        annotations: {
+            title: 'Get More Tools',
+            readOnlyHint: true,
+            openWorldHint: true,
+            idempotentHint: true,
+            destructiveHint: false
+        }
+    };
+}
+function handleReportMissing(args) {
+    log(`Missing tool reported: ${JSON.stringify(args)}`);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: 'Unfortunately, we have shown you the full tool list. We have noted your feedback and will work to improve the tool list in the future.'
+            }
+        ]
+    };
+}
+export { GET_MORE_TOOLS_NAME, getReportMissingToolDescriptor, handleReportMissing };

package/dist/extensions/tracing-helpers.d.ts

@@ -0,0 +1,29 @@
+import type { CompatibleRequestHandlerExtra, MCPAnalyticsData, MCPRequestLike, McpEvent } from '../types';
+/**
+ * Helpers shared by the low-level (`instrument-lowlevel.ts`) and high-level
+ * (`instrument-highlevel.ts`) MCP server wrappers. Extracted so both paths stay in sync — any change to
+ * "what counts as an error result", "how do we resolve customer event
+ * properties", "where do we find the context argument", or "how do we measure
+ * duration" needs to land in one place.
+ */
+/**
+ * MCP tool results signal errors by setting `isError: true` on the result
+ * object rather than throwing. Detect that consistently.
+ */
+export declare function isToolResultError(result: unknown): boolean;
+/**
+ * Resolves the `eventProperties` callback (if configured) and stamps the
+ * result onto the event. No-op when the callback is absent or returns nullish.
+ */
+export declare function applyResolvedMetadata(event: McpEvent, data: MCPAnalyticsData, request: MCPRequestLike, extra?: CompatibleRequestHandlerExtra): Promise<void>;
+/**
+ * Reads the SDK-injected `context` argument off a tool-call request. Returns
+ * the trimmed string when present, otherwise `undefined`.
+ */
+export declare function getContextArgument(request: MCPRequestLike): string | undefined;
+/**
+ * Wall-clock duration of a tracked operation in milliseconds, from `event.timestamp`
+ * to now. Returns `0` when timestamp is missing so callers don't have to null-check.
+ */
+export declare function getEventDuration(event: McpEvent): number;
+//# sourceMappingURL=tracing-helpers.d.ts.map

package/dist/extensions/tracing-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracing-helpers.d.ts","sourceRoot":"","sources":["../../src/extensions/tracing-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,gBAAgB,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGzG;;;;;;GAMG;AAEH;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAE1D;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,cAAc,EACvB,KAAK,CAAC,EAAE,6BAA6B,GACpC,OAAO,CAAC,IAAI,CAAC,CAKf;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM,GAAG,SAAS,CAG9E;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAExD"}

package/dist/extensions/tracing-helpers.js

@@ -0,0 +1,59 @@
+"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__, {
+    getEventDuration: ()=>getEventDuration,
+    isToolResultError: ()=>isToolResultError,
+    applyResolvedMetadata: ()=>applyResolvedMetadata,
+    getContextArgument: ()=>getContextArgument
+});
+const external_internal_js_namespaceObject = require("./internal.js");
+function isToolResultError(result) {
+    return !!result && 'object' == typeof result && 'isError' in result && true === result.isError;
+}
+async function applyResolvedMetadata(event, data, request, extra) {
+    const resolvedProperties = await (0, external_internal_js_namespaceObject.resolveEventProperties)(data, request, extra);
+    if (resolvedProperties) event.properties = resolvedProperties;
+}
+function getContextArgument(request) {
+    const context = request.params?.arguments?.context;
+    return 'string' == typeof context ? context : void 0;
+}
+function getEventDuration(event) {
+    return event.timestamp ? Date.now() - event.timestamp.getTime() : 0;
+}
+exports.applyResolvedMetadata = __webpack_exports__.applyResolvedMetadata;
+exports.getContextArgument = __webpack_exports__.getContextArgument;
+exports.getEventDuration = __webpack_exports__.getEventDuration;
+exports.isToolResultError = __webpack_exports__.isToolResultError;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "applyResolvedMetadata",
+    "getContextArgument",
+    "getEventDuration",
+    "isToolResultError"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/tracing-helpers.mjs

@@ -0,0 +1,16 @@
+import { resolveEventProperties } from "./internal.mjs";
+function isToolResultError(result) {
+    return !!result && 'object' == typeof result && 'isError' in result && true === result.isError;
+}
+async function applyResolvedMetadata(event, data, request, extra) {
+    const resolvedProperties = await resolveEventProperties(data, request, extra);
+    if (resolvedProperties) event.properties = resolvedProperties;
+}
+function getContextArgument(request) {
+    const context = request.params?.arguments?.context;
+    return 'string' == typeof context ? context : void 0;
+}
+function getEventDuration(event) {
+    return event.timestamp ? Date.now() - event.timestamp.getTime() : 0;
+}
+export { applyResolvedMetadata, getContextArgument, getEventDuration, isToolResultError };

package/dist/extensions/truncation.d.ts

@@ -0,0 +1,25 @@
+import type { Event, McpEvent } from '../types';
+export declare const MAX_DEPTH = 10;
+export declare const MAX_BREADTH = 100;
+export declare const MAX_STRING_LENGTH = 32768;
+export declare const MAX_EVENT_BYTES = 102400;
+/**
+ * Recursively normalizes a value, handling:
+ * - String truncation (> MAX_STRING_LENGTH)
+ * - Non-serializable values (functions, symbols, undefined, BigInt, NaN, Infinity)
+ * - Date objects -> ISO string
+ * - Circular reference detection
+ * - Depth limiting
+ * - Breadth limiting
+ */
+export declare function normalize(input: unknown, depth?: number, maxBreadth?: number, maxStringLength?: number): unknown;
+/**
+ * Applies layered truncation to an event:
+ * 1. Field-level string limits (userIntent, resourceName, metadata fields, error.message)
+ * 2. Error frame limiting (first 25 + last 25 if > 50)
+ * 3. Response content text limits (32KB per text block)
+ * 4. Recursive normalization on user-controlled fields
+ * 5. Size-targeted truncation (progressive depth reduction + last-resort string truncation)
+ */
+export declare function truncateEvent<T extends Event | McpEvent>(event: T): T;
+//# sourceMappingURL=truncation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"truncation.d.ts","sourceRoot":"","sources":["../../src/extensions/truncation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,KAAK,EAAc,QAAQ,EAAE,MAAM,UAAU,CAAA;AAG5E,eAAO,MAAM,SAAS,KAAK,CAAA;AAC3B,eAAO,MAAM,WAAW,MAAM,CAAA;AAC9B,eAAO,MAAM,iBAAiB,QAAS,CAAA;AACvC,eAAO,MAAM,eAAe,SAAU,CAAA;AAgBtC;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,OAAO,EACd,KAAK,GAAE,MAAkB,EACzB,UAAU,GAAE,MAAoB,EAChC,eAAe,GAAE,MAA0B,GAC1C,OAAO,CAGT;AAkXD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,KAAK,GAAG,QAAQ,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAmCrE"}