@posthog/mcp 0.14.1 → 0.16.0

package/dist/extensions/instrumentation.js

@@ -37,7 +37,8 @@ __webpack_require__.d(__webpack_exports__, {
     isToolAdvertised: ()=>isToolAdvertised,
     patchRequestHandlers: ()=>patchRequestHandlers,
     readToolMetaCategory: ()=>readToolMetaCategory,
-    registerFallbackRequestHandler: ()=>registerFallbackRequestHandler
+    registerFallbackRequestHandler: ()=>registerFallbackRequestHandler,
+    traceResourceRequest: ()=>traceResourceRequest
 });
 const external_analytics_parameters_js_namespaceObject = require("./analytics-parameters.js");
 const external_context_parameters_js_namespaceObject = require("./context-parameters.js");
@@ -56,18 +57,25 @@ const external_mcp_sdk_compat_js_namespaceObject = require("./mcp-sdk-compat.js"
 const external_request_headers_js_namespaceObject = require("./request-headers.js");
 const external_session_js_namespaceObject = require("./session.js");
 const external_session_token_js_namespaceObject = require("./session-token.js");
+const external_feedback_js_namespaceObject = require("./feedback.js");
 const external_tools_js_namespaceObject = require("./tools.js");
 const external_tracing_helpers_js_namespaceObject = require("./tracing-helpers.js");
 async function captureToolCall(params) {
-    const { server, data, request, extra, execute, parameterOwnership, eventType, explicitContextIntent, takeCapturedError } = params;
+    const { server, data, request, extra, execute, parameterOwnership, eventType, explicitContextIntent, extraEventProperties, omitCapturedParameters, takeCapturedError } = params;
     const resolvedEventType = eventType ?? external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpToolsCall;
-    const ownership = getActiveAnalyticsParameterOwnership(data, request.params?.name, parameterOwnership, resolvedEventType === external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpMissingCapability);
-    const canCaptureContextIntent = resolvedEventType !== external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpMissingCapability && (0, external_context_parameters_js_namespaceObject.isContextEnabled)(data.options.context) && (ownership.context || !ownership.contextOwnershipKnown);
+    const isVirtualAnalyticsTool = resolvedEventType === external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpMissingCapability || resolvedEventType === external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpFeedback;
+    const ownership = getActiveAnalyticsParameterOwnership(data, request.params?.name, parameterOwnership, isVirtualAnalyticsTool);
+    const canCaptureContextIntent = !isVirtualAnalyticsTool && (0, external_context_parameters_js_namespaceObject.isContextEnabled)(data.options.context) && (ownership.context || !ownership.contextOwnershipKnown);
     const conversation = (0, external_conversation_id_js_namespaceObject.resolveConversationId)(ownership.conversationId, request.params?.arguments);
     const downstreamRequest = cloneRequestWithoutOwnedAnalyticsArguments(request, ownership);
     const startTime = new Date();
     const preparedEvent = await prepareToolCallEvent(server, data, request, downstreamRequest, extra, startTime, conversation, ownership, resolvedEventType, canCaptureContextIntent);
     if (preparedEvent && explicitContextIntent) (0, external_intent_js_namespaceObject.setExplicitContextIntent)(preparedEvent.event, explicitContextIntent);
+    if (preparedEvent && extraEventProperties) preparedEvent.event.properties = {
+        ...preparedEvent.event.properties,
+        ...extraEventProperties
+    };
+    if (preparedEvent && omitCapturedParameters) preparedEvent.event.parameters = void 0;
     let result;
     try {
         result = await execute(downstreamRequest);
@@ -79,12 +87,12 @@ async function captureToolCall(params) {
     publishSuccessfulToolEvent(server, preparedEvent, finalResult, startTime, data.logger, takeCapturedError, result);
     return finalResult;
 }
-function getActiveAnalyticsParameterOwnership(data, toolName, override, isMissingCapabilityTool) {
+function getActiveAnalyticsParameterOwnership(data, toolName, override, isVirtualAnalyticsTool) {
     const listed = toolName ? data.toolAnalyticsParameterOwnership.get(toolName) : void 0;
     const ownership = override ?? listed;
     return {
         contextOwnershipKnown: void 0 !== ownership,
-        context: !isMissingCapabilityTool && (0, external_context_parameters_js_namespaceObject.isContextEnabled)(data.options.context) && ownership?.context === true,
+        context: !isVirtualAnalyticsTool && (0, external_context_parameters_js_namespaceObject.isContextEnabled)(data.options.context) && ownership?.context === true,
         conversationId: true === data.options.enableConversationId && ownership?.conversationId === true,
         llmModel: (0, external_model_parameters_js_namespaceObject.isCaptureModelEnabled)(data.options.captureModel) && ownership?.llmModel === true,
         outputInstructions: true === data.options.enableConversationId && listed?.outputInstructions === true
@@ -182,6 +190,77 @@ function publishFailedToolEvent(server, preparedEvent, error, startTime, convers
         logger(`Warning: PostHog MCP analytics failed to publish failed tool event - ${publishError}`);
     }
 }
+function publishResourceEvent(server, preparedEvent, startTime, params, outcome) {
+    if (!preparedEvent) return;
+    const { event, requestAttribution } = preparedEvent;
+    try {
+        if ('error' in outcome) {
+            event.isError = true;
+            event.error = (0, external_exceptions_js_namespaceObject.captureException)(outcome.error);
+        } else {
+            event.isError = false;
+            if (params.eventType === external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpResourcesList) event.response = outcome.result;
+        }
+        event.duration = Date.now() - startTime.getTime();
+        (0, external_capture_js_namespaceObject.captureEvent)(server, event, params.logger, requestAttribution);
+    } catch (error) {
+        params.logger(`Warning: PostHog MCP analytics failed to publish ${params.request.method} analytics - ${error}`);
+    }
+}
+function traceResourceRequest(eventType, logger) {
+    return (server, originalHandler, request, extra)=>captureResourceRequest({
+            server,
+            originalHandler,
+            request,
+            extra,
+            eventType,
+            logger
+        });
+}
+async function captureResourceRequest(params) {
+    const { server, originalHandler, request, extra, eventType, logger } = params;
+    const data = (0, external_internal_js_namespaceObject.getServerTrackingData)(server);
+    if (!data) {
+        logger('Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using resources.');
+        return await originalHandler(request, extra);
+    }
+    const startTime = new Date();
+    let preparedEvent = null;
+    try {
+        const sessionId = (0, external_session_js_namespaceObject.getSessionId)(server, extra);
+        const sessionInfo = (0, external_session_js_namespaceObject.getSessionInfo)(server, data, sessionId);
+        const event = {
+            sessionId,
+            eventType,
+            parameters: (0, external_mcp_payloads_js_namespaceObject.buildCapturedMcpParameters)(request),
+            resourceName: eventType === external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpResourcesRead ? request.params?.uri : void 0,
+            timestamp: startTime
+        };
+        (0, external_client_identity_js_namespaceObject.stampClientIdentity)(event, request, extra, server);
+        (0, external_transport_identity_js_namespaceObject.stampTransportIdentity)(event, extra);
+        const identity = await (0, external_internal_js_namespaceObject.handleIdentify)(server, data, sessionId, request, sessionInfo, extra);
+        await (0, external_tracing_helpers_js_namespaceObject.applyResolvedMetadata)(event, data, request, extra);
+        preparedEvent = {
+            event,
+            requestAttribution: (0, external_internal_js_namespaceObject.withIdentity)(sessionInfo, identity)
+        };
+    } catch (error) {
+        logger(`Warning: PostHog MCP analytics could not prepare ${request.method} analytics - ${error}`);
+    }
+    let result;
+    try {
+        result = await originalHandler(request, extra);
+    } catch (error) {
+        publishResourceEvent(server, preparedEvent, startTime, params, {
+            error
+        });
+        throw error;
+    }
+    publishResourceEvent(server, preparedEvent, startTime, params, {
+        result
+    });
+    return result;
+}
 const originalRequestHandlers = new WeakMap();
 function rememberOriginalRequestHandler(server, handlerName, originalHandler) {
     let handlers = originalRequestHandlers.get(server);
@@ -217,9 +296,9 @@ function patchRequestHandlers(server, patches) {
         return result;
     };
 }
-function getVirtualToolParameterOwnership(data, toolName) {
+function getVirtualToolParameterOwnership(data, toolName, virtualToolInputSchema) {
     return {
-        ...(0, external_analytics_parameters_js_namespaceObject.getAnalyticsParameterOwnership)((0, external_tools_js_namespaceObject.getReportMissingToolDescriptor)(toolName).inputSchema),
+        ...(0, external_analytics_parameters_js_namespaceObject.getAnalyticsParameterOwnership)(virtualToolInputSchema),
         conversationId: data.toolAnalyticsParameterOwnership.get(toolName)?.conversationId === true
     };
 }
@@ -305,6 +384,19 @@ async function getTracedToolsList(server, originalListToolsHandler, request, ext
                     ]);
                 }
             }
+            const feedbackOptions = (0, external_feedback_js_namespaceObject.resolveCollectFeedbackOptions)(data.options.collectFeedback);
+            if (feedbackOptions) {
+                const feedbackToolName = feedbackOptions.toolName ?? external_feedback_js_namespaceObject.SEND_FEEDBACK_TOOL_NAME;
+                const alreadyPresent = tools.some((tool)=>tool?.name === feedbackToolName);
+                if (alreadyPresent) data.logger(`Warning: Cannot inject agent-feedback tool "${feedbackToolName}" because a real tool already uses that name. The real tool will not be intercepted.`);
+                else {
+                    const virtualTool = (0, external_feedback_js_namespaceObject.getFeedbackToolDescriptor)(feedbackOptions);
+                    tools.push(virtualTool);
+                    cacheToolAnalyticsParameterOwnership(data.toolAnalyticsParameterOwnership, [
+                        virtualTool
+                    ]);
+                }
+            }
             if ((0, external_model_parameters_js_namespaceObject.isCaptureModelEnabled)(data.options.captureModel)) tools = (0, external_model_parameters_js_namespaceObject.addModelParameterToTools)(tools, (0, external_model_parameters_js_namespaceObject.getModelDescription)(data.options.captureModel), data.logger);
             if (data.options.enableConversationId) {
                 tools = (0, external_conversation_id_js_namespaceObject.addConversationIdToTools)(tools, data.logger);
@@ -461,6 +553,7 @@ exports.isToolAdvertised = __webpack_exports__.isToolAdvertised;
 exports.patchRequestHandlers = __webpack_exports__.patchRequestHandlers;
 exports.readToolMetaCategory = __webpack_exports__.readToolMetaCategory;
 exports.registerFallbackRequestHandler = __webpack_exports__.registerFallbackRequestHandler;
+exports.traceResourceRequest = __webpack_exports__.traceResourceRequest;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "cacheToolCategories",
     "cacheToolDescriptions",
@@ -471,7 +564,8 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "isToolAdvertised",
     "patchRequestHandlers",
     "readToolMetaCategory",
-    "registerFallbackRequestHandler"
+    "registerFallbackRequestHandler",
+    "traceResourceRequest"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/extensions/instrumentation.mjs

@@ -15,18 +15,25 @@ import { readRequestHandlerMethod } from "./mcp-sdk-compat.mjs";
 import { getRequestHeaders } from "./request-headers.mjs";
 import { getSessionId, getSessionInfo, isModernEraRequest, newSessionId } from "./session.mjs";
 import { encodeSessionId, readMcpSessionHeader, writeSessionIdToTransport } from "./session-token.mjs";
+import { SEND_FEEDBACK_TOOL_NAME, getFeedbackToolDescriptor, resolveCollectFeedbackOptions } from "./feedback.mjs";
 import { getReportMissingToolDescriptor, resolveMissingCapabilityToolName } from "./tools.mjs";
 import { applyResolvedMetadata, isToolResultError } from "./tracing-helpers.mjs";
 async function captureToolCall(params) {
-    const { server, data, request, extra, execute, parameterOwnership, eventType, explicitContextIntent, takeCapturedError } = params;
+    const { server, data, request, extra, execute, parameterOwnership, eventType, explicitContextIntent, extraEventProperties, omitCapturedParameters, takeCapturedError } = params;
     const resolvedEventType = eventType ?? MCPAnalyticsEventType.mcpToolsCall;
-    const ownership = getActiveAnalyticsParameterOwnership(data, request.params?.name, parameterOwnership, resolvedEventType === MCPAnalyticsEventType.mcpMissingCapability);
-    const canCaptureContextIntent = resolvedEventType !== MCPAnalyticsEventType.mcpMissingCapability && isContextEnabled(data.options.context) && (ownership.context || !ownership.contextOwnershipKnown);
+    const isVirtualAnalyticsTool = resolvedEventType === MCPAnalyticsEventType.mcpMissingCapability || resolvedEventType === MCPAnalyticsEventType.mcpFeedback;
+    const ownership = getActiveAnalyticsParameterOwnership(data, request.params?.name, parameterOwnership, isVirtualAnalyticsTool);
+    const canCaptureContextIntent = !isVirtualAnalyticsTool && isContextEnabled(data.options.context) && (ownership.context || !ownership.contextOwnershipKnown);
     const conversation = resolveConversationId(ownership.conversationId, request.params?.arguments);
     const downstreamRequest = cloneRequestWithoutOwnedAnalyticsArguments(request, ownership);
     const startTime = new Date();
     const preparedEvent = await prepareToolCallEvent(server, data, request, downstreamRequest, extra, startTime, conversation, ownership, resolvedEventType, canCaptureContextIntent);
     if (preparedEvent && explicitContextIntent) setExplicitContextIntent(preparedEvent.event, explicitContextIntent);
+    if (preparedEvent && extraEventProperties) preparedEvent.event.properties = {
+        ...preparedEvent.event.properties,
+        ...extraEventProperties
+    };
+    if (preparedEvent && omitCapturedParameters) preparedEvent.event.parameters = void 0;
     let result;
     try {
         result = await execute(downstreamRequest);
@@ -38,12 +45,12 @@ async function captureToolCall(params) {
     publishSuccessfulToolEvent(server, preparedEvent, finalResult, startTime, data.logger, takeCapturedError, result);
     return finalResult;
 }
-function getActiveAnalyticsParameterOwnership(data, toolName, override, isMissingCapabilityTool) {
+function getActiveAnalyticsParameterOwnership(data, toolName, override, isVirtualAnalyticsTool) {
     const listed = toolName ? data.toolAnalyticsParameterOwnership.get(toolName) : void 0;
     const ownership = override ?? listed;
     return {
         contextOwnershipKnown: void 0 !== ownership,
-        context: !isMissingCapabilityTool && isContextEnabled(data.options.context) && ownership?.context === true,
+        context: !isVirtualAnalyticsTool && isContextEnabled(data.options.context) && ownership?.context === true,
         conversationId: true === data.options.enableConversationId && ownership?.conversationId === true,
         llmModel: isCaptureModelEnabled(data.options.captureModel) && ownership?.llmModel === true,
         outputInstructions: true === data.options.enableConversationId && listed?.outputInstructions === true
@@ -141,6 +148,77 @@ function publishFailedToolEvent(server, preparedEvent, error, startTime, convers
         logger(`Warning: PostHog MCP analytics failed to publish failed tool event - ${publishError}`);
     }
 }
+function publishResourceEvent(server, preparedEvent, startTime, params, outcome) {
+    if (!preparedEvent) return;
+    const { event, requestAttribution } = preparedEvent;
+    try {
+        if ('error' in outcome) {
+            event.isError = true;
+            event.error = captureException(outcome.error);
+        } else {
+            event.isError = false;
+            if (params.eventType === MCPAnalyticsEventType.mcpResourcesList) event.response = outcome.result;
+        }
+        event.duration = Date.now() - startTime.getTime();
+        captureEvent(server, event, params.logger, requestAttribution);
+    } catch (error) {
+        params.logger(`Warning: PostHog MCP analytics failed to publish ${params.request.method} analytics - ${error}`);
+    }
+}
+function traceResourceRequest(eventType, logger) {
+    return (server, originalHandler, request, extra)=>captureResourceRequest({
+            server,
+            originalHandler,
+            request,
+            extra,
+            eventType,
+            logger
+        });
+}
+async function captureResourceRequest(params) {
+    const { server, originalHandler, request, extra, eventType, logger } = params;
+    const data = getServerTrackingData(server);
+    if (!data) {
+        logger('Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using resources.');
+        return await originalHandler(request, extra);
+    }
+    const startTime = new Date();
+    let preparedEvent = null;
+    try {
+        const sessionId = getSessionId(server, extra);
+        const sessionInfo = getSessionInfo(server, data, sessionId);
+        const event = {
+            sessionId,
+            eventType,
+            parameters: buildCapturedMcpParameters(request),
+            resourceName: eventType === MCPAnalyticsEventType.mcpResourcesRead ? request.params?.uri : void 0,
+            timestamp: startTime
+        };
+        stampClientIdentity(event, request, extra, server);
+        stampTransportIdentity(event, extra);
+        const identity = await handleIdentify(server, data, sessionId, request, sessionInfo, extra);
+        await applyResolvedMetadata(event, data, request, extra);
+        preparedEvent = {
+            event,
+            requestAttribution: withIdentity(sessionInfo, identity)
+        };
+    } catch (error) {
+        logger(`Warning: PostHog MCP analytics could not prepare ${request.method} analytics - ${error}`);
+    }
+    let result;
+    try {
+        result = await originalHandler(request, extra);
+    } catch (error) {
+        publishResourceEvent(server, preparedEvent, startTime, params, {
+            error
+        });
+        throw error;
+    }
+    publishResourceEvent(server, preparedEvent, startTime, params, {
+        result
+    });
+    return result;
+}
 const originalRequestHandlers = new WeakMap();
 function rememberOriginalRequestHandler(server, handlerName, originalHandler) {
     let handlers = originalRequestHandlers.get(server);
@@ -176,9 +254,9 @@ function patchRequestHandlers(server, patches) {
         return result;
     };
 }
-function getVirtualToolParameterOwnership(data, toolName) {
+function getVirtualToolParameterOwnership(data, toolName, virtualToolInputSchema) {
     return {
-        ...getAnalyticsParameterOwnership(getReportMissingToolDescriptor(toolName).inputSchema),
+        ...getAnalyticsParameterOwnership(virtualToolInputSchema),
         conversationId: data.toolAnalyticsParameterOwnership.get(toolName)?.conversationId === true
     };
 }
@@ -264,6 +342,19 @@ async function getTracedToolsList(server, originalListToolsHandler, request, ext
                     ]);
                 }
             }
+            const feedbackOptions = resolveCollectFeedbackOptions(data.options.collectFeedback);
+            if (feedbackOptions) {
+                const feedbackToolName = feedbackOptions.toolName ?? SEND_FEEDBACK_TOOL_NAME;
+                const alreadyPresent = tools.some((tool)=>tool?.name === feedbackToolName);
+                if (alreadyPresent) data.logger(`Warning: Cannot inject agent-feedback tool "${feedbackToolName}" because a real tool already uses that name. The real tool will not be intercepted.`);
+                else {
+                    const virtualTool = getFeedbackToolDescriptor(feedbackOptions);
+                    tools.push(virtualTool);
+                    cacheToolAnalyticsParameterOwnership(data.toolAnalyticsParameterOwnership, [
+                        virtualTool
+                    ]);
+                }
+            }
             if (isCaptureModelEnabled(data.options.captureModel)) tools = addModelParameterToTools(tools, getModelDescription(data.options.captureModel), data.logger);
             if (data.options.enableConversationId) {
                 tools = addConversationIdToTools(tools, data.logger);
@@ -410,4 +501,4 @@ function readProtocolVersion(result, request) {
     const requested = request.params?.protocolVersion;
     return 'string' == typeof requested && requested.length > 0 ? requested : void 0;
 }
-export { cacheToolCategories, cacheToolDescriptions, captureToolCall, getVirtualToolParameterOwnership, handleInitializeRequest, handleListToolsRequest, isToolAdvertised, patchRequestHandlers, readToolMetaCategory, registerFallbackRequestHandler };
+export { cacheToolCategories, cacheToolDescriptions, captureToolCall, getVirtualToolParameterOwnership, handleInitializeRequest, handleListToolsRequest, isToolAdvertised, patchRequestHandlers, readToolMetaCategory, registerFallbackRequestHandler, traceResourceRequest };

package/dist/extensions/internal.js

@@ -158,8 +158,15 @@ async function resolveEventProperties(data, request, extra) {
 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';
+    if (!params || 'object' != typeof params) return 'Unknown';
+    for (const key of [
+        'name',
+        'uri'
+    ]){
+        const value = params[key];
+        if ('string' == typeof value) return value;
+    }
+    return 'Unknown';
 }
 exports.IdentityCache = __webpack_exports__.IdentityCache;
 exports.areIdentitiesEqual = __webpack_exports__.areIdentitiesEqual;

package/dist/extensions/internal.mjs

@@ -119,7 +119,14 @@ async function resolveEventProperties(data, request, extra) {
 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';
+    if (!params || 'object' != typeof params) return 'Unknown';
+    for (const key of [
+        'name',
+        'uri'
+    ]){
+        const value = params[key];
+        if ('string' == typeof value) return value;
+    }
+    return 'Unknown';
 }
 export { IdentityCache, areIdentitiesEqual, getServerTrackingData, handleIdentify, mergeIdentities, resolveEventProperties, setServerTrackingData, withIdentity };

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

@@ -1,4 +1,17 @@
 type JsonRecord = Record<string, unknown>;
+/**
+ * Sanitizes agent-narrated free text (`$mcp_intent`, the `send_feedback`
+ * fields): structured PII on top of the passes every captured string gets.
+ *
+ * Every step of the order is load-bearing. The binary gate reads the value as it
+ * arrived, because splicing `[redacted]` into a blob — a Luhn-valid run inside
+ * base64 is enough — stops it looking like base64 and would ship it whole.
+ * Credentials go before PII, because a PII pattern can cut a token in half (a
+ * phone-shaped run inside one) and leave the halves behind. PII goes before the
+ * URL pass, because the URL rewrite percent-encodes the `@` that the email
+ * pattern anchors on.
+ */
+export declare function sanitizeFreeText(value: string): string;
 /**
  * Redacts structured personal identifiers (emails, IP addresses, credit-card
  * numbers, US SSNs, and phone numbers) from a free-text string. Intended for the
@@ -10,6 +23,12 @@ type JsonRecord = Record<string, unknown>;
  */
 export declare function redactPii(value: string): string;
 export declare function sanitizeCapturedValue(value: unknown): unknown;
+/**
+ * {@link sanitizeCapturedValue} with the intent-grade string pass
+ * ({@link sanitizeFreeText}) on every string leaf, so nested agent-narrated
+ * values get structured-PII redaction in the load-bearing order too.
+ */
+export declare function sanitizeFreeTextValue(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

@@ -1 +1 @@
-{"version":3,"file":"mcp-payloads.d.ts","sourceRoot":"","sources":["../../src/extensions/mcp-payloads.ts"],"names":[],"mappings":"AAmEA,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAiGzC;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAU/C;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CA0B7D;AA6BD,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,UAAU,CAiBvE"}
+{"version":3,"file":"mcp-payloads.d.ts","sourceRoot":"","sources":["../../src/extensions/mcp-payloads.ts"],"names":[],"mappings":"AAoHA,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAyYzC;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKtD;AA6DD;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAU/C;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE7D;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE7D;AAyDD,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,UAAU,CAiBvE"}