@posthog/mcp 0.0.8 → 0.1.16

package/dist/extensions/internal.js

@@ -0,0 +1,158 @@
+"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__, {
+    mergeIdentities: ()=>mergeIdentities,
+    areIdentitiesEqual: ()=>areIdentitiesEqual,
+    resolveEventProperties: ()=>resolveEventProperties,
+    handleIdentify: ()=>handleIdentify,
+    getServerTrackingData: ()=>getServerTrackingData,
+    IdentityCache: ()=>IdentityCache,
+    setServerTrackingData: ()=>setServerTrackingData
+});
+const external_event_types_js_namespaceObject = require("./event-types.js");
+const external_logger_js_namespaceObject = require("./logger.js");
+const external_capture_js_namespaceObject = require("./capture.js");
+class IdentityCache {
+    constructor(maxSize = 1000){
+        this._cache = new Map();
+        this._maxSize = maxSize;
+    }
+    get(sessionId) {
+        const identity = this._cache.get(sessionId);
+        if (void 0 === identity) return;
+        this._cache.delete(sessionId);
+        this._cache.set(sessionId, identity);
+        return identity;
+    }
+    set(sessionId, identity) {
+        this._cache.delete(sessionId);
+        if (this._cache.size >= this._maxSize) {
+            const oldestKey = this._cache.keys().next().value;
+            if (void 0 !== oldestKey) this._cache.delete(oldestKey);
+        }
+        this._cache.set(sessionId, identity);
+    }
+    has(sessionId) {
+        return this._cache.has(sessionId);
+    }
+    size() {
+        return this._cache.size;
+    }
+}
+const _serverTracking = new WeakMap();
+function getServerTrackingData(server) {
+    return _serverTracking.get(server);
+}
+function setServerTrackingData(server, data) {
+    _serverTracking.set(server, data);
+}
+function areIdentitiesEqual(a, b) {
+    if (a.distinctId !== b.distinctId) return false;
+    if (JSON.stringify(a.groups ?? {}) !== JSON.stringify(b.groups ?? {})) return false;
+    const aProps = a.properties || {};
+    const bProps = b.properties || {};
+    const aKeys = Object.keys(aProps);
+    const bKeys = Object.keys(bProps);
+    if (aKeys.length !== bKeys.length) return false;
+    for (const key of aKeys){
+        if (!(key in bProps)) return false;
+        if (JSON.stringify(aProps[key]) !== JSON.stringify(bProps[key])) return false;
+    }
+    return true;
+}
+function mergeIdentities(previous, next) {
+    if (!previous) return next;
+    return {
+        distinctId: next.distinctId,
+        properties: {
+            ...previous.properties || {},
+            ...next.properties || {}
+        },
+        groups: next.groups ?? previous.groups
+    };
+}
+async function handleIdentify(server, data, sessionId, request, extra) {
+    if (!data.options.identify) return;
+    const identifyEvent = {
+        sessionId,
+        resourceName: getRequestResourceName(request),
+        eventType: external_event_types_js_namespaceObject.MCPAnalyticsEventType.identify,
+        parameters: {
+            request,
+            extra
+        },
+        timestamp: new Date()
+    };
+    try {
+        const identityResult = 'function' == typeof data.options.identify ? await data.options.identify(request, extra) : data.options.identify;
+        if (identityResult) {
+            const previousIdentity = data.identifiedSessions.get(sessionId);
+            const mergedIdentity = mergeIdentities(previousIdentity, identityResult);
+            const hasChanged = !(previousIdentity && areIdentitiesEqual(previousIdentity, mergedIdentity));
+            data.identifiedSessions.set(sessionId, mergedIdentity);
+            if (hasChanged) {
+                (0, external_logger_js_namespaceObject.log)(`Identified session ${sessionId} with identity: ${JSON.stringify(mergedIdentity)}`);
+                (0, external_capture_js_namespaceObject.captureEvent)(server, identifyEvent);
+            }
+        } else (0, external_logger_js_namespaceObject.log)(`Warning: Supplied identify function returned null for session ${sessionId}`);
+    } catch (error) {
+        (0, external_logger_js_namespaceObject.log)(`Error: User supplied identify function threw an error while identifying session ${sessionId} - ${error}`);
+    }
+}
+async function resolveEventProperties(data, request, extra) {
+    if (!data.options.eventProperties) return null;
+    try {
+        return await data.options.eventProperties(request, extra) ?? null;
+    } catch (e) {
+        (0, external_logger_js_namespaceObject.log)(`eventProperties callback error: ${e}`);
+        return null;
+    }
+}
+function getRequestResourceName(request) {
+    if (!request || 'object' != typeof request || !('params' in request)) return 'Unknown';
+    const params = request.params;
+    if (!params || 'object' != typeof params || !('name' in params)) return 'Unknown';
+    return 'string' == typeof params.name ? params.name : 'Unknown';
+}
+exports.IdentityCache = __webpack_exports__.IdentityCache;
+exports.areIdentitiesEqual = __webpack_exports__.areIdentitiesEqual;
+exports.getServerTrackingData = __webpack_exports__.getServerTrackingData;
+exports.handleIdentify = __webpack_exports__.handleIdentify;
+exports.mergeIdentities = __webpack_exports__.mergeIdentities;
+exports.resolveEventProperties = __webpack_exports__.resolveEventProperties;
+exports.setServerTrackingData = __webpack_exports__.setServerTrackingData;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "IdentityCache",
+    "areIdentitiesEqual",
+    "getServerTrackingData",
+    "handleIdentify",
+    "mergeIdentities",
+    "resolveEventProperties",
+    "setServerTrackingData"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/internal.mjs

@@ -0,0 +1,106 @@
+import { MCPAnalyticsEventType } from "./event-types.mjs";
+import { log } from "./logger.mjs";
+import { captureEvent } from "./capture.mjs";
+class IdentityCache {
+    constructor(maxSize = 1000){
+        this._cache = new Map();
+        this._maxSize = maxSize;
+    }
+    get(sessionId) {
+        const identity = this._cache.get(sessionId);
+        if (void 0 === identity) return;
+        this._cache.delete(sessionId);
+        this._cache.set(sessionId, identity);
+        return identity;
+    }
+    set(sessionId, identity) {
+        this._cache.delete(sessionId);
+        if (this._cache.size >= this._maxSize) {
+            const oldestKey = this._cache.keys().next().value;
+            if (void 0 !== oldestKey) this._cache.delete(oldestKey);
+        }
+        this._cache.set(sessionId, identity);
+    }
+    has(sessionId) {
+        return this._cache.has(sessionId);
+    }
+    size() {
+        return this._cache.size;
+    }
+}
+const _serverTracking = new WeakMap();
+function getServerTrackingData(server) {
+    return _serverTracking.get(server);
+}
+function setServerTrackingData(server, data) {
+    _serverTracking.set(server, data);
+}
+function areIdentitiesEqual(a, b) {
+    if (a.distinctId !== b.distinctId) return false;
+    if (JSON.stringify(a.groups ?? {}) !== JSON.stringify(b.groups ?? {})) return false;
+    const aProps = a.properties || {};
+    const bProps = b.properties || {};
+    const aKeys = Object.keys(aProps);
+    const bKeys = Object.keys(bProps);
+    if (aKeys.length !== bKeys.length) return false;
+    for (const key of aKeys){
+        if (!(key in bProps)) return false;
+        if (JSON.stringify(aProps[key]) !== JSON.stringify(bProps[key])) return false;
+    }
+    return true;
+}
+function mergeIdentities(previous, next) {
+    if (!previous) return next;
+    return {
+        distinctId: next.distinctId,
+        properties: {
+            ...previous.properties || {},
+            ...next.properties || {}
+        },
+        groups: next.groups ?? previous.groups
+    };
+}
+async function handleIdentify(server, data, sessionId, request, extra) {
+    if (!data.options.identify) return;
+    const identifyEvent = {
+        sessionId,
+        resourceName: getRequestResourceName(request),
+        eventType: MCPAnalyticsEventType.identify,
+        parameters: {
+            request,
+            extra
+        },
+        timestamp: new Date()
+    };
+    try {
+        const identityResult = 'function' == typeof data.options.identify ? await data.options.identify(request, extra) : data.options.identify;
+        if (identityResult) {
+            const previousIdentity = data.identifiedSessions.get(sessionId);
+            const mergedIdentity = mergeIdentities(previousIdentity, identityResult);
+            const hasChanged = !(previousIdentity && areIdentitiesEqual(previousIdentity, mergedIdentity));
+            data.identifiedSessions.set(sessionId, mergedIdentity);
+            if (hasChanged) {
+                log(`Identified session ${sessionId} with identity: ${JSON.stringify(mergedIdentity)}`);
+                captureEvent(server, identifyEvent);
+            }
+        } else log(`Warning: Supplied identify function returned null for session ${sessionId}`);
+    } catch (error) {
+        log(`Error: User supplied identify function threw an error while identifying session ${sessionId} - ${error}`);
+    }
+}
+async function resolveEventProperties(data, request, extra) {
+    if (!data.options.eventProperties) return null;
+    try {
+        return await data.options.eventProperties(request, extra) ?? null;
+    } catch (e) {
+        log(`eventProperties callback error: ${e}`);
+        return null;
+    }
+}
+function getRequestResourceName(request) {
+    if (!request || 'object' != typeof request || !('params' in request)) return 'Unknown';
+    const params = request.params;
+    if (!params || 'object' != typeof params || !('name' in params)) return 'Unknown';
+    return 'string' == typeof params.name ? params.name : 'Unknown';
+}
+export { IdentityCache, areIdentitiesEqual, getServerTrackingData, handleIdentify, mergeIdentities, resolveEventProperties, setServerTrackingData };

package/dist/extensions/logger.d.ts

@@ -0,0 +1,14 @@
+/**
+ * STDIO-safe logger.
+ *
+ * MCP servers running over the STDIO transport use stdout/stderr to exchange
+ * protocol messages, so we cannot use the default `console.log`. We accept a
+ * `logger` option on the public API; when omitted, log calls are silently
+ * dropped. Errors that affect tracking should still be observable in apps that
+ * want them, so the consumer can plug in any function (e.g. `console.error`
+ * for non-STDIO transports, a file logger, etc.).
+ */
+export type LoggerFn = (message: string) => void;
+export declare function setLogger(logger: LoggerFn | undefined): void;
+export declare function log(message: string): void;
+//# sourceMappingURL=logger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/extensions/logger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;AAIhD,wBAAgB,SAAS,CAAC,MAAM,EAAE,QAAQ,GAAG,SAAS,GAAG,IAAI,CAE5D;AAED,wBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAQzC"}

package/dist/extensions/logger.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__, {
+    log: ()=>log,
+    setLogger: ()=>setLogger
+});
+let activeLogger;
+function setLogger(logger) {
+    activeLogger = logger;
+}
+function log(message) {
+    if (activeLogger) try {
+        activeLogger(message);
+    } catch  {}
+}
+exports.log = __webpack_exports__.log;
+exports.setLogger = __webpack_exports__.setLogger;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "log",
+    "setLogger"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/logger.mjs

@@ -0,0 +1,10 @@
+let activeLogger;
+function setLogger(logger) {
+    activeLogger = logger;
+}
+function log(message) {
+    if (activeLogger) try {
+        activeLogger(message);
+    } catch  {}
+}
+export { log, setLogger };

package/dist/extensions/mcp-payloads.d.ts

@@ -0,0 +1,5 @@
+type JsonRecord = Record<string, unknown>;
+export declare function sanitizeCapturedValue(value: unknown): unknown;
+export declare function buildCapturedMcpParameters(request: unknown): JsonRecord;
+export {};
+//# sourceMappingURL=mcp-payloads.d.ts.map

package/dist/extensions/mcp-payloads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-payloads.d.ts","sourceRoot":"","sources":["../../src/extensions/mcp-payloads.ts"],"names":[],"mappings":"AAQA,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAiBzC,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CA0B7D;AA6BD,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,UAAU,CAiBvE"}

package/dist/extensions/mcp-payloads.js

@@ -0,0 +1,91 @@
+"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__, {
+    buildCapturedMcpParameters: ()=>buildCapturedMcpParameters,
+    sanitizeCapturedValue: ()=>sanitizeCapturedValue
+});
+const CONTEXT_ARGUMENT_NAME = 'context';
+const REDACTED_VALUE = '[redacted]';
+const BASE64_PATTERN = /^[A-Za-z0-9+/\n\r]+=*$/;
+const SIZE_GATE = 10240;
+const POSTHOG_TOKEN_PATTERN = /\bph[a-z]_[A-Za-z0-9_-]{20,}\b/g;
+const SENSITIVE_KEY_PATTERN = /^(authorization|cookie|set-cookie|x-api-key|api[-_]?key|api[-_]?token|access[-_]?token|refresh[-_]?token|token|password|secret|client[-_]?secret|private[-_]?key)$/i;
+function isRecord(value) {
+    return !!value && 'object' == typeof value && !Array.isArray(value);
+}
+function shouldRedactKey(key) {
+    return SENSITIVE_KEY_PATTERN.test(key);
+}
+function sanitizeString(value) {
+    if (value.length >= SIZE_GATE && BASE64_PATTERN.test(value)) return '[binary data redacted - not supported by PostHog MCP analytics]';
+    return value.replace(POSTHOG_TOKEN_PATTERN, REDACTED_VALUE);
+}
+function sanitizeCapturedValue(value) {
+    if (null == value) return value;
+    if ('string' == typeof value) return sanitizeString(value);
+    if (Array.isArray(value)) return value.map(sanitizeCapturedValue);
+    if (value instanceof Date) return value;
+    if ('object' != typeof value) return value;
+    const result = {};
+    for (const [key, nestedValue] of Object.entries(value))result[key] = shouldRedactKey(key) ? REDACTED_VALUE : sanitizeCapturedValue(nestedValue);
+    return result;
+}
+function buildCapturedMcpArguments(argumentsValue) {
+    if (!isRecord(argumentsValue)) return sanitizeCapturedValue(argumentsValue);
+    const capturedArguments = {};
+    for (const [key, value] of Object.entries(argumentsValue))if (key !== CONTEXT_ARGUMENT_NAME) capturedArguments[key] = sanitizeCapturedValue(value);
+    return capturedArguments;
+}
+function buildCapturedMcpParams(params) {
+    if (!isRecord(params)) return sanitizeCapturedValue(params);
+    const capturedParams = {};
+    for (const [key, value] of Object.entries(params))capturedParams[key] = 'arguments' === key ? buildCapturedMcpArguments(value) : sanitizeCapturedValue(value);
+    return capturedParams;
+}
+function buildCapturedMcpParameters(request) {
+    if (!isRecord(request)) return {
+        request: sanitizeCapturedValue(request)
+    };
+    const capturedRequest = {};
+    for (const key of [
+        'id',
+        'jsonrpc',
+        'method'
+    ])if (key in request) capturedRequest[key] = sanitizeCapturedValue(request[key]);
+    if ('params' in request) capturedRequest.params = buildCapturedMcpParams(request.params);
+    return {
+        request: capturedRequest
+    };
+}
+exports.buildCapturedMcpParameters = __webpack_exports__.buildCapturedMcpParameters;
+exports.sanitizeCapturedValue = __webpack_exports__.sanitizeCapturedValue;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "buildCapturedMcpParameters",
+    "sanitizeCapturedValue"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/mcp-payloads.mjs

@@ -0,0 +1,54 @@
+const CONTEXT_ARGUMENT_NAME = 'context';
+const REDACTED_VALUE = '[redacted]';
+const BASE64_PATTERN = /^[A-Za-z0-9+/\n\r]+=*$/;
+const SIZE_GATE = 10240;
+const POSTHOG_TOKEN_PATTERN = /\bph[a-z]_[A-Za-z0-9_-]{20,}\b/g;
+const SENSITIVE_KEY_PATTERN = /^(authorization|cookie|set-cookie|x-api-key|api[-_]?key|api[-_]?token|access[-_]?token|refresh[-_]?token|token|password|secret|client[-_]?secret|private[-_]?key)$/i;
+function isRecord(value) {
+    return !!value && 'object' == typeof value && !Array.isArray(value);
+}
+function shouldRedactKey(key) {
+    return SENSITIVE_KEY_PATTERN.test(key);
+}
+function sanitizeString(value) {
+    if (value.length >= SIZE_GATE && BASE64_PATTERN.test(value)) return '[binary data redacted - not supported by PostHog MCP analytics]';
+    return value.replace(POSTHOG_TOKEN_PATTERN, REDACTED_VALUE);
+}
+function sanitizeCapturedValue(value) {
+    if (null == value) return value;
+    if ('string' == typeof value) return sanitizeString(value);
+    if (Array.isArray(value)) return value.map(sanitizeCapturedValue);
+    if (value instanceof Date) return value;
+    if ('object' != typeof value) return value;
+    const result = {};
+    for (const [key, nestedValue] of Object.entries(value))result[key] = shouldRedactKey(key) ? REDACTED_VALUE : sanitizeCapturedValue(nestedValue);
+    return result;
+}
+function buildCapturedMcpArguments(argumentsValue) {
+    if (!isRecord(argumentsValue)) return sanitizeCapturedValue(argumentsValue);
+    const capturedArguments = {};
+    for (const [key, value] of Object.entries(argumentsValue))if (key !== CONTEXT_ARGUMENT_NAME) capturedArguments[key] = sanitizeCapturedValue(value);
+    return capturedArguments;
+}
+function buildCapturedMcpParams(params) {
+    if (!isRecord(params)) return sanitizeCapturedValue(params);
+    const capturedParams = {};
+    for (const [key, value] of Object.entries(params))capturedParams[key] = 'arguments' === key ? buildCapturedMcpArguments(value) : sanitizeCapturedValue(value);
+    return capturedParams;
+}
+function buildCapturedMcpParameters(request) {
+    if (!isRecord(request)) return {
+        request: sanitizeCapturedValue(request)
+    };
+    const capturedRequest = {};
+    for (const key of [
+        'id',
+        'jsonrpc',
+        'method'
+    ])if (key in request) capturedRequest[key] = sanitizeCapturedValue(request[key]);
+    if ('params' in request) capturedRequest.params = buildCapturedMcpParams(request.params);
+    return {
+        request: capturedRequest
+    };
+}
+export { buildCapturedMcpParameters, sanitizeCapturedValue };

package/dist/extensions/mcp-sdk-compat.d.ts

@@ -0,0 +1,33 @@
+/**
+ * MCP SDK Compatibility Helpers
+ *
+ * Internal utilities for handling differences between MCP SDK versions.
+ * These helpers abstract away SDK-internal details like:
+ * - Tool callback/handler property names (changed in SDK 1.24)
+ * - Zod schema internal structures (v3 vs v4)
+ */
+import type { RegisteredTool, ToolCallback } from '../types';
+export type ToolFunctionKey = 'callback' | 'handler';
+/**
+ * Returns the tool function (callback/handler) from a RegisteredTool.
+ * Supports both MCP SDK 1.23- (callback) and 1.24+ (handler).
+ */
+export declare function getToolFunction(tool: RegisteredTool): ToolCallback;
+/**
+ * Returns the property key name used for the tool function ("callback" or "handler").
+ * This preserves the original property name when wrapping tools.
+ */
+export declare function getToolFunctionKey(tool: RegisteredTool): ToolFunctionKey;
+/**
+ * Returns true if the tool has a callback or handler property.
+ */
+export declare function hasToolFunction(tool: unknown): tool is RegisteredTool;
+/**
+ * Creates a new tool object with the wrapped function, preserving the original property name.
+ * This ensures MCP SDK 1.24+ gets back a tool with "handler" and 1.23- gets "callback".
+ */
+export declare function createWrappedTool(originalTool: RegisteredTool, wrappedFunction: ToolCallback): RegisteredTool;
+export declare function isZ4Schema(schema: unknown): boolean;
+export declare function getObjectShape(schema: unknown): Record<string, unknown> | undefined;
+export declare function getLiteralValue(schema: unknown): unknown;
+//# sourceMappingURL=mcp-sdk-compat.d.ts.map

package/dist/extensions/mcp-sdk-compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-sdk-compat.d.ts","sourceRoot":"","sources":["../../src/extensions/mcp-sdk-compat.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAK5D,MAAM,MAAM,eAAe,GAAG,UAAU,GAAG,SAAS,CAAA;AAEpD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,cAAc,GAAG,YAAY,CAQlE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,eAAe,CAKxE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,cAAc,CAMrE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,YAAY,GAAG,cAAc,CAM7G;AAyBD,wBAAgB,UAAU,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAKnD;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CA6BnF;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAkCxD"}

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

@@ -0,0 +1,112 @@
+"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__, {
+    createWrappedTool: ()=>createWrappedTool,
+    getLiteralValue: ()=>getLiteralValue,
+    getObjectShape: ()=>getObjectShape,
+    getToolFunction: ()=>getToolFunction,
+    getToolFunctionKey: ()=>getToolFunctionKey,
+    hasToolFunction: ()=>hasToolFunction,
+    isZ4Schema: ()=>isZ4Schema
+});
+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;
+}
+exports.createWrappedTool = __webpack_exports__.createWrappedTool;
+exports.getLiteralValue = __webpack_exports__.getLiteralValue;
+exports.getObjectShape = __webpack_exports__.getObjectShape;
+exports.getToolFunction = __webpack_exports__.getToolFunction;
+exports.getToolFunctionKey = __webpack_exports__.getToolFunctionKey;
+exports.hasToolFunction = __webpack_exports__.hasToolFunction;
+exports.isZ4Schema = __webpack_exports__.isZ4Schema;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createWrappedTool",
+    "getLiteralValue",
+    "getObjectShape",
+    "getToolFunction",
+    "getToolFunctionKey",
+    "hasToolFunction",
+    "isZ4Schema"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});