@posthog/mcp 0.0.9 → 0.1.16

package/dist/extensions/context-parameters.mjs

@@ -0,0 +1,50 @@
+import { DEFAULT_CONTEXT_PARAMETER_DESCRIPTION } from "./constants.mjs";
+import { log } from "./logger.mjs";
+function isContextEnabled(context) {
+    return false !== context;
+}
+function getContextDescription(context) {
+    return 'object' == typeof context ? context.description : void 0;
+}
+function addContextParameterToTool(tool, contextDescriptionOverride) {
+    const modifiedTool = {
+        ...tool
+    };
+    const toolName = tool.name || 'unknown';
+    const schema = modifiedTool.inputSchema;
+    if (schema?.properties?.context) {
+        log(`WARN: Tool "${toolName}" already has 'context' parameter. Skipping context injection.`);
+        return modifiedTool;
+    }
+    if (schema?.oneOf || schema?.allOf || schema?.anyOf) {
+        log(`WARN: Tool "${toolName}" has complex schema (oneOf/allOf/anyOf). Skipping context injection.`);
+        return modifiedTool;
+    }
+    if (!modifiedTool.inputSchema) modifiedTool.inputSchema = {
+        type: 'object',
+        properties: {},
+        required: []
+    };
+    const contextDescription = contextDescriptionOverride || DEFAULT_CONTEXT_PARAMETER_DESCRIPTION;
+    modifiedTool.inputSchema = JSON.parse(JSON.stringify(modifiedTool.inputSchema));
+    const inputSchema = modifiedTool.inputSchema;
+    if (!inputSchema.properties) inputSchema.properties = {};
+    if (false === inputSchema.additionalProperties) inputSchema.additionalProperties = void 0;
+    inputSchema.properties.context = {
+        type: 'string',
+        description: contextDescription
+    };
+    if (Array.isArray(inputSchema.required)) {
+        if (!inputSchema.required.includes('context')) inputSchema.required.push('context');
+    } else inputSchema.required = [
+        'context'
+    ];
+    return modifiedTool;
+}
+function addContextParameterToTools(tools, contextDescriptionOverride) {
+    return tools.map((tool)=>{
+        if ('get_more_tools' === tool.name) return tool;
+        return addContextParameterToTool(tool, contextDescriptionOverride);
+    });
+}
+export { addContextParameterToTool, addContextParameterToTools, getContextDescription, isContextEnabled };

package/dist/extensions/conversation-id.d.ts

@@ -0,0 +1,52 @@
+export declare const CONVERSATION_ID_PARAM_NAME = "conversation_id";
+interface JsonSchema {
+    additionalProperties?: boolean;
+    allOf?: unknown;
+    anyOf?: unknown;
+    oneOf?: unknown;
+    properties?: Record<string, unknown>;
+    required?: string[];
+    type?: string;
+}
+export interface ConversationIdInjectableTool {
+    inputSchema?: JsonSchema;
+    name?: string;
+    [key: string]: unknown;
+}
+export declare function addConversationIdToTool<TTool extends ConversationIdInjectableTool>(tool: TTool): TTool;
+export declare function addConversationIdToTools<TTool extends ConversationIdInjectableTool>(tools: TTool[]): TTool[];
+export type ConversationIdResolution = {
+    minted: false;
+    conversationId: string | undefined;
+} | {
+    minted: true;
+    conversationId: string;
+};
+/**
+ * Decides which conversation_id to use for a tool call:
+ *   - disabled or get_more_tools → none
+ *   - agent supplied a value → use it
+ *   - agent omitted → mint a UUID
+ */
+export declare function resolveConversationId(enabled: boolean, args: unknown, toolName: string | undefined): ConversationIdResolution;
+/**
+ * Predicate matching the same eligibility checks injectConversationIdPromptBack uses,
+ * exposed so callers can pre-decide whether the prompt-back will actually land
+ * (and clear event.conversationId if not, to avoid orphan ids in analytics).
+ */
+export declare function canInjectConversationIdPromptBack(result: unknown): boolean;
+export declare function extractConversationId(args: unknown): string | undefined;
+export declare function cloneRequestWithoutConversationId<TRequest extends {
+    params?: {
+        arguments?: unknown;
+        [k: string]: unknown;
+    };
+}>(request: TRequest): TRequest;
+export declare function stripConversationId(args: unknown): unknown;
+export declare function buildConversationIdPromptBack(conversationId: string): {
+    type: 'text';
+    text: string;
+};
+export declare function injectConversationIdPromptBack(result: unknown, conversationId: string): unknown;
+export {};
+//# sourceMappingURL=conversation-id.d.ts.map

package/dist/extensions/conversation-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-id.d.ts","sourceRoot":"","sources":["../../src/extensions/conversation-id.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,0BAA0B,oBAAoB,CAAA;AAE3D,UAAU,UAAU;IAClB,oBAAoB,CAAC,EAAE,OAAO,CAAA;IAC9B,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACpC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,4BAA4B;IAC3C,WAAW,CAAC,EAAE,UAAU,CAAA;IACxB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAED,wBAAgB,uBAAuB,CAAC,KAAK,SAAS,4BAA4B,EAAE,IAAI,EAAE,KAAK,GAAG,KAAK,CA2CtG;AAED,wBAAgB,wBAAwB,CAAC,KAAK,SAAS,4BAA4B,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE,CAO5G;AAED,MAAM,MAAM,wBAAwB,GAChC;IAAE,MAAM,EAAE,KAAK,CAAC;IAAC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,GACrD;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,CAAA;AAE5C;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,OAAO,EACb,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B,wBAAwB,CAS1B;AAED;;;;GAIG;AACH,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAS1E;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAUvE;AAED,wBAAgB,iCAAiC,CAC/C,QAAQ,SAAS;IAAE,MAAM,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAA;CAAE,EAC3E,OAAO,EAAE,QAAQ,GAAG,QAAQ,CAe7B;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAM1D;AAED,wBAAgB,6BAA6B,CAAC,cAAc,EAAE,MAAM,GAAG;IACrE,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;CACb,CAKA;AAED,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAS/F"}

package/dist/extensions/conversation-id.js

@@ -0,0 +1,164 @@
+"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__, {
+    CONVERSATION_ID_PARAM_NAME: ()=>CONVERSATION_ID_PARAM_NAME,
+    resolveConversationId: ()=>resolveConversationId,
+    buildConversationIdPromptBack: ()=>buildConversationIdPromptBack,
+    addConversationIdToTool: ()=>addConversationIdToTool,
+    addConversationIdToTools: ()=>addConversationIdToTools,
+    extractConversationId: ()=>extractConversationId,
+    injectConversationIdPromptBack: ()=>injectConversationIdPromptBack,
+    cloneRequestWithoutConversationId: ()=>cloneRequestWithoutConversationId,
+    stripConversationId: ()=>stripConversationId,
+    canInjectConversationIdPromptBack: ()=>canInjectConversationIdPromptBack
+});
+const core_namespaceObject = require("@posthog/core");
+const external_constants_js_namespaceObject = require("./constants.js");
+const external_logger_js_namespaceObject = require("./logger.js");
+const external_tools_js_namespaceObject = require("./tools.js");
+const CONVERSATION_ID_PARAM_NAME = 'conversation_id';
+function addConversationIdToTool(tool) {
+    const modifiedTool = {
+        ...tool
+    };
+    const toolName = tool.name || 'unknown';
+    const schema = modifiedTool.inputSchema;
+    if (schema?.properties?.[CONVERSATION_ID_PARAM_NAME]) {
+        (0, external_logger_js_namespaceObject.log)(`WARN: Tool "${toolName}" already has '${CONVERSATION_ID_PARAM_NAME}' parameter. Skipping conversation_id injection.`);
+        return modifiedTool;
+    }
+    if (schema?.oneOf || schema?.allOf || schema?.anyOf) {
+        (0, external_logger_js_namespaceObject.log)(`WARN: Tool "${toolName}" has complex schema (oneOf/allOf/anyOf). Skipping conversation_id injection.`);
+        return modifiedTool;
+    }
+    if (!modifiedTool.inputSchema) modifiedTool.inputSchema = {
+        type: 'object',
+        properties: {},
+        required: []
+    };
+    modifiedTool.inputSchema = JSON.parse(JSON.stringify(modifiedTool.inputSchema));
+    const inputSchema = modifiedTool.inputSchema;
+    if (!inputSchema.properties) inputSchema.properties = {};
+    if (false === inputSchema.additionalProperties) inputSchema.additionalProperties = void 0;
+    inputSchema.properties[CONVERSATION_ID_PARAM_NAME] = {
+        type: 'string',
+        description: external_constants_js_namespaceObject.DEFAULT_CONVERSATION_ID_DESCRIPTION
+    };
+    return modifiedTool;
+}
+function addConversationIdToTools(tools) {
+    return tools.map((tool)=>{
+        if (tool.name === external_tools_js_namespaceObject.GET_MORE_TOOLS_NAME) return tool;
+        return addConversationIdToTool(tool);
+    });
+}
+function resolveConversationId(enabled, args, toolName) {
+    if (!enabled || toolName === external_tools_js_namespaceObject.GET_MORE_TOOLS_NAME) return {
+        minted: false,
+        conversationId: void 0
+    };
+    const supplied = extractConversationId(args);
+    if (supplied) return {
+        minted: false,
+        conversationId: supplied
+    };
+    return {
+        minted: true,
+        conversationId: (0, core_namespaceObject.uuidv7)()
+    };
+}
+function canInjectConversationIdPromptBack(result) {
+    if (!(result && 'object' == typeof result)) return false;
+    const resultObj = result;
+    if (true === resultObj.isError) return false;
+    return Array.isArray(resultObj.content);
+}
+function extractConversationId(args) {
+    if (!(args && 'object' == typeof args)) return;
+    const value = args[CONVERSATION_ID_PARAM_NAME];
+    if ('string' != typeof value) return;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+}
+function cloneRequestWithoutConversationId(request) {
+    if (!request.params || 'object' != typeof request.params) return request;
+    const args = request.params.arguments;
+    if (!(args && 'object' == typeof args)) return request;
+    return {
+        ...request,
+        params: {
+            ...request.params,
+            arguments: stripConversationId(args)
+        }
+    };
+}
+function stripConversationId(args) {
+    if (!args || 'object' != typeof args || !(CONVERSATION_ID_PARAM_NAME in args)) return args;
+    const { [CONVERSATION_ID_PARAM_NAME]: _omit, ...rest } = args;
+    return rest;
+}
+function buildConversationIdPromptBack(conversationId) {
+    return {
+        type: 'text',
+        text: `[SERVER]: Reuse conversation_id=${conversationId} on every subsequent tool call in this conversation. Required for the server to correlate calls and provide context-aware results.`
+    };
+}
+function injectConversationIdPromptBack(result, conversationId) {
+    if (!canInjectConversationIdPromptBack(result)) return result;
+    const resultObj = result;
+    return {
+        ...resultObj,
+        content: [
+            ...resultObj.content,
+            buildConversationIdPromptBack(conversationId)
+        ]
+    };
+}
+exports.CONVERSATION_ID_PARAM_NAME = __webpack_exports__.CONVERSATION_ID_PARAM_NAME;
+exports.addConversationIdToTool = __webpack_exports__.addConversationIdToTool;
+exports.addConversationIdToTools = __webpack_exports__.addConversationIdToTools;
+exports.buildConversationIdPromptBack = __webpack_exports__.buildConversationIdPromptBack;
+exports.canInjectConversationIdPromptBack = __webpack_exports__.canInjectConversationIdPromptBack;
+exports.cloneRequestWithoutConversationId = __webpack_exports__.cloneRequestWithoutConversationId;
+exports.extractConversationId = __webpack_exports__.extractConversationId;
+exports.injectConversationIdPromptBack = __webpack_exports__.injectConversationIdPromptBack;
+exports.resolveConversationId = __webpack_exports__.resolveConversationId;
+exports.stripConversationId = __webpack_exports__.stripConversationId;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "CONVERSATION_ID_PARAM_NAME",
+    "addConversationIdToTool",
+    "addConversationIdToTools",
+    "buildConversationIdPromptBack",
+    "canInjectConversationIdPromptBack",
+    "cloneRequestWithoutConversationId",
+    "extractConversationId",
+    "injectConversationIdPromptBack",
+    "resolveConversationId",
+    "stripConversationId"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/conversation-id.mjs

@@ -0,0 +1,103 @@
+import { uuidv7 } from "@posthog/core";
+import { DEFAULT_CONVERSATION_ID_DESCRIPTION } from "./constants.mjs";
+import { log } from "./logger.mjs";
+import { GET_MORE_TOOLS_NAME } from "./tools.mjs";
+const CONVERSATION_ID_PARAM_NAME = 'conversation_id';
+function addConversationIdToTool(tool) {
+    const modifiedTool = {
+        ...tool
+    };
+    const toolName = tool.name || 'unknown';
+    const schema = modifiedTool.inputSchema;
+    if (schema?.properties?.[CONVERSATION_ID_PARAM_NAME]) {
+        log(`WARN: Tool "${toolName}" already has '${CONVERSATION_ID_PARAM_NAME}' parameter. Skipping conversation_id injection.`);
+        return modifiedTool;
+    }
+    if (schema?.oneOf || schema?.allOf || schema?.anyOf) {
+        log(`WARN: Tool "${toolName}" has complex schema (oneOf/allOf/anyOf). Skipping conversation_id injection.`);
+        return modifiedTool;
+    }
+    if (!modifiedTool.inputSchema) modifiedTool.inputSchema = {
+        type: 'object',
+        properties: {},
+        required: []
+    };
+    modifiedTool.inputSchema = JSON.parse(JSON.stringify(modifiedTool.inputSchema));
+    const inputSchema = modifiedTool.inputSchema;
+    if (!inputSchema.properties) inputSchema.properties = {};
+    if (false === inputSchema.additionalProperties) inputSchema.additionalProperties = void 0;
+    inputSchema.properties[CONVERSATION_ID_PARAM_NAME] = {
+        type: 'string',
+        description: DEFAULT_CONVERSATION_ID_DESCRIPTION
+    };
+    return modifiedTool;
+}
+function addConversationIdToTools(tools) {
+    return tools.map((tool)=>{
+        if (tool.name === GET_MORE_TOOLS_NAME) return tool;
+        return addConversationIdToTool(tool);
+    });
+}
+function resolveConversationId(enabled, args, toolName) {
+    if (!enabled || toolName === GET_MORE_TOOLS_NAME) return {
+        minted: false,
+        conversationId: void 0
+    };
+    const supplied = extractConversationId(args);
+    if (supplied) return {
+        minted: false,
+        conversationId: supplied
+    };
+    return {
+        minted: true,
+        conversationId: uuidv7()
+    };
+}
+function canInjectConversationIdPromptBack(result) {
+    if (!(result && 'object' == typeof result)) return false;
+    const resultObj = result;
+    if (true === resultObj.isError) return false;
+    return Array.isArray(resultObj.content);
+}
+function extractConversationId(args) {
+    if (!(args && 'object' == typeof args)) return;
+    const value = args[CONVERSATION_ID_PARAM_NAME];
+    if ('string' != typeof value) return;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+}
+function cloneRequestWithoutConversationId(request) {
+    if (!request.params || 'object' != typeof request.params) return request;
+    const args = request.params.arguments;
+    if (!(args && 'object' == typeof args)) return request;
+    return {
+        ...request,
+        params: {
+            ...request.params,
+            arguments: stripConversationId(args)
+        }
+    };
+}
+function stripConversationId(args) {
+    if (!args || 'object' != typeof args || !(CONVERSATION_ID_PARAM_NAME in args)) return args;
+    const { [CONVERSATION_ID_PARAM_NAME]: _omit, ...rest } = args;
+    return rest;
+}
+function buildConversationIdPromptBack(conversationId) {
+    return {
+        type: 'text',
+        text: `[SERVER]: Reuse conversation_id=${conversationId} on every subsequent tool call in this conversation. Required for the server to correlate calls and provide context-aware results.`
+    };
+}
+function injectConversationIdPromptBack(result, conversationId) {
+    if (!canInjectConversationIdPromptBack(result)) return result;
+    const resultObj = result;
+    return {
+        ...resultObj,
+        content: [
+            ...resultObj.content,
+            buildConversationIdPromptBack(conversationId)
+        ]
+    };
+}
+export { CONVERSATION_ID_PARAM_NAME, addConversationIdToTool, addConversationIdToTools, buildConversationIdPromptBack, canInjectConversationIdPromptBack, cloneRequestWithoutConversationId, extractConversationId, injectConversationIdPromptBack, resolveConversationId, stripConversationId };

package/dist/extensions/event-types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Internal SDK event vocabulary.
+ *
+ * These values are not imported from `@modelcontextprotocol/sdk`; they are the
+ * protocol-shaped event types this SDK observes before mapping them to PostHog
+ * event names.
+ */
+export declare const MCPAnalyticsEventType: {
+    readonly identify: "posthog:identify";
+    readonly custom: "posthog:custom";
+    readonly mcpMissingCapability: "mcp:missing_capability";
+    readonly mcpInitialize: "mcp:initialize";
+    readonly mcpPromptsGet: "mcp:prompts/get";
+    readonly mcpPromptsList: "mcp:prompts/list";
+    readonly mcpResourcesList: "mcp:resources/list";
+    readonly mcpResourcesRead: "mcp:resources/read";
+    readonly mcpToolsCall: "mcp:tools/call";
+    readonly mcpToolsList: "mcp:tools/list";
+};
+export type MCPAnalyticsEventType = (typeof MCPAnalyticsEventType)[keyof typeof MCPAnalyticsEventType];
+//# sourceMappingURL=event-types.d.ts.map

package/dist/extensions/event-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-types.d.ts","sourceRoot":"","sources":["../../src/extensions/event-types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;CAWxB,CAAA;AAEV,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,OAAO,qBAAqB,CAAC,CAAA"}

package/dist/extensions/event-types.js

@@ -0,0 +1,47 @@
+"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__, {
+    MCPAnalyticsEventType: ()=>MCPAnalyticsEventType
+});
+const MCPAnalyticsEventType = {
+    identify: 'posthog:identify',
+    custom: 'posthog:custom',
+    mcpMissingCapability: 'mcp:missing_capability',
+    mcpInitialize: 'mcp:initialize',
+    mcpPromptsGet: 'mcp:prompts/get',
+    mcpPromptsList: 'mcp:prompts/list',
+    mcpResourcesList: 'mcp:resources/list',
+    mcpResourcesRead: 'mcp:resources/read',
+    mcpToolsCall: 'mcp:tools/call',
+    mcpToolsList: 'mcp:tools/list'
+};
+exports.MCPAnalyticsEventType = __webpack_exports__.MCPAnalyticsEventType;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "MCPAnalyticsEventType"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/event-types.mjs

@@ -0,0 +1,13 @@
+const MCPAnalyticsEventType = {
+    identify: 'posthog:identify',
+    custom: 'posthog:custom',
+    mcpMissingCapability: 'mcp:missing_capability',
+    mcpInitialize: 'mcp:initialize',
+    mcpPromptsGet: 'mcp:prompts/get',
+    mcpPromptsList: 'mcp:prompts/list',
+    mcpResourcesList: 'mcp:resources/list',
+    mcpResourcesRead: 'mcp:resources/read',
+    mcpToolsCall: 'mcp:tools/call',
+    mcpToolsList: 'mcp:tools/list'
+};
+export { MCPAnalyticsEventType };

package/dist/extensions/exceptions.d.ts

@@ -0,0 +1,13 @@
+import { ErrorTracking as CoreErrorTracking } from '@posthog/core';
+/**
+ * Captures structured exception properties from any thrown value.
+ *
+ * Returns the `$exception_list` shape PostHog error tracking expects, so MCP
+ * tool failures group and (with uploaded source maps) symbolicate the same way
+ * as exceptions from any other PostHog SDK.
+ *
+ * @param error - The thrown value (Error, string, object, CallToolResult, or anything).
+ * @returns Core `ErrorProperties` ready to spread onto a `$exception` event.
+ */
+export declare function captureException(error: unknown): CoreErrorTracking.ErrorProperties;
+//# sourceMappingURL=exceptions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"exceptions.d.ts","sourceRoot":"","sources":["../../src/extensions/exceptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,IAAI,iBAAiB,EAAE,MAAM,eAAe,CAAA;AA8BlE;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,iBAAiB,CAAC,eAAe,CAMlF"}

package/dist/extensions/exceptions.js

@@ -0,0 +1,58 @@
+"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__, {
+    captureException: ()=>captureException
+});
+const core_namespaceObject = require("@posthog/core");
+const errorPropertiesBuilder = new core_namespaceObject.ErrorTracking.ErrorPropertiesBuilder([
+    new core_namespaceObject.ErrorTracking.EventCoercer(),
+    new core_namespaceObject.ErrorTracking.ErrorCoercer(),
+    new core_namespaceObject.ErrorTracking.ObjectCoercer(),
+    new core_namespaceObject.ErrorTracking.StringCoercer(),
+    new core_namespaceObject.ErrorTracking.PrimitiveCoercer()
+], core_namespaceObject.ErrorTracking.createStackParser("node:javascript", core_namespaceObject.ErrorTracking.nodeStackLineParser));
+function captureException(error) {
+    const normalized = isCallToolResult(error) ? extractCallToolResultMessage(error) : error;
+    return errorPropertiesBuilder.buildFromUnknown(normalized);
+}
+function isCallToolResult(value) {
+    return null !== value && 'object' == typeof value && 'isError' in value && 'content' in value && Array.isArray(value.content);
+}
+function isTextContentPart(value) {
+    if (null === value || 'object' != typeof value) return false;
+    const contentPart = value;
+    return 'text' === contentPart.type && 'string' == typeof contentPart.text;
+}
+function extractCallToolResultMessage(result) {
+    return result.content.filter(isTextContentPart).map((contentPart)=>contentPart.text).join(' ').trim() || 'Unknown error';
+}
+exports.captureException = __webpack_exports__.captureException;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "captureException"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/exceptions.mjs

@@ -0,0 +1,24 @@
+import { ErrorTracking } from "@posthog/core";
+const errorPropertiesBuilder = new ErrorTracking.ErrorPropertiesBuilder([
+    new ErrorTracking.EventCoercer(),
+    new ErrorTracking.ErrorCoercer(),
+    new ErrorTracking.ObjectCoercer(),
+    new ErrorTracking.StringCoercer(),
+    new ErrorTracking.PrimitiveCoercer()
+], ErrorTracking.createStackParser("node:javascript", ErrorTracking.nodeStackLineParser));
+function captureException(error) {
+    const normalized = isCallToolResult(error) ? extractCallToolResultMessage(error) : error;
+    return errorPropertiesBuilder.buildFromUnknown(normalized);
+}
+function isCallToolResult(value) {
+    return null !== value && 'object' == typeof value && 'isError' in value && 'content' in value && Array.isArray(value.content);
+}
+function isTextContentPart(value) {
+    if (null === value || 'object' != typeof value) return false;
+    const contentPart = value;
+    return 'text' === contentPart.type && 'string' == typeof contentPart.text;
+}
+function extractCallToolResultMessage(result) {
+    return result.content.filter(isTextContentPart).map((contentPart)=>contentPart.text).join(' ').trim() || 'Unknown error';
+}
+export { captureException };

package/dist/extensions/ids.d.ts

@@ -0,0 +1,13 @@
+export type MCPAnalyticsIDPrefix = 'evt' | 'ses';
+export declare function newPrefixedId(prefix: MCPAnalyticsIDPrefix): string;
+/**
+ * Deterministic id derived from an arbitrary string. Used to map MCP protocol
+ * session ids to SDK session ids so the same MCP session reuses the same
+ * `$session_id` across server restarts.
+ *
+ * Uses the FNV-1a 64-bit hash (mixed twice to fill 32 hex chars), which works
+ * everywhere — no `node:crypto`, no Web Crypto async API. Not cryptographic; we
+ * only need stable, low-collision input → output mapping.
+ */
+export declare function deterministicPrefixedId(prefix: MCPAnalyticsIDPrefix, input: string): string;
+//# sourceMappingURL=ids.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../src/extensions/ids.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,oBAAoB,GAAG,KAAK,GAAG,KAAK,CAAA;AAEhD,wBAAgB,aAAa,CAAC,MAAM,EAAE,oBAAoB,GAAG,MAAM,CAElE;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,oBAAoB,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAE3F"}

package/dist/extensions/ids.js

@@ -0,0 +1,55 @@
+"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__, {
+    deterministicPrefixedId: ()=>deterministicPrefixedId,
+    newPrefixedId: ()=>newPrefixedId
+});
+const core_namespaceObject = require("@posthog/core");
+function newPrefixedId(prefix) {
+    return `${prefix}_${(0, core_namespaceObject.uuidv7)()}`;
+}
+function deterministicPrefixedId(prefix, input) {
+    return `${prefix}_${fnv1aHex(input)}${fnv1aHex(`${input}::salt`)}`;
+}
+function fnv1aHex(input) {
+    let h1 = 0x84222325;
+    let h2 = 0xcbf29ce4;
+    for(let i = 0; i < input.length; i++){
+        const c = input.charCodeAt(i);
+        h1 = Math.imul(h1 ^ c, 0x000001b3);
+        h2 = Math.imul(h2 ^ c, 0x00000193);
+    }
+    return (h1 >>> 0).toString(16).padStart(8, '0') + (h2 >>> 0).toString(16).padStart(8, '0');
+}
+exports.deterministicPrefixedId = __webpack_exports__.deterministicPrefixedId;
+exports.newPrefixedId = __webpack_exports__.newPrefixedId;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "deterministicPrefixedId",
+    "newPrefixedId"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/ids.mjs

@@ -0,0 +1,18 @@
+import { uuidv7 } from "@posthog/core";
+function newPrefixedId(prefix) {
+    return `${prefix}_${uuidv7()}`;
+}
+function deterministicPrefixedId(prefix, input) {
+    return `${prefix}_${fnv1aHex(input)}${fnv1aHex(`${input}::salt`)}`;
+}
+function fnv1aHex(input) {
+    let h1 = 0x84222325;
+    let h2 = 0xcbf29ce4;
+    for(let i = 0; i < input.length; i++){
+        const c = input.charCodeAt(i);
+        h1 = Math.imul(h1 ^ c, 0x000001b3);
+        h2 = Math.imul(h2 ^ c, 0x00000193);
+    }
+    return (h1 >>> 0).toString(16).padStart(8, '0') + (h2 >>> 0).toString(16).padStart(8, '0');
+}
+export { deterministicPrefixedId, newPrefixedId };

package/dist/extensions/instrument-highlevel.d.ts

@@ -0,0 +1,3 @@
+import type { HighLevelMCPServerLike } from '../types';
+export declare function instrumentHighLevelServer(server: HighLevelMCPServerLike): void;
+//# sourceMappingURL=instrument-highlevel.d.ts.map

package/dist/extensions/instrument-highlevel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrument-highlevel.d.ts","sourceRoot":"","sources":["../../src/extensions/instrument-highlevel.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAiC,sBAAsB,EAAiC,MAAM,UAAU,CAAA;AA2QpH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,sBAAsB,GAAG,IAAI,CAoB9E"}