@posthog/mcp 0.15.0 → 0.16.0

package/dist/extensions/feedback.mjs

@@ -0,0 +1,200 @@
+import { PostHogMCPAnalyticsProperty } from "./constants.mjs";
+import { log } from "./logger.mjs";
+import { sanitizeFreeText, sanitizeFreeTextValue } from "./mcp-payloads.mjs";
+const SEND_FEEDBACK_TOOL_NAME = 'send_feedback';
+const FEEDBACK_TYPES = [
+    'missing_capability',
+    'issue',
+    'praise',
+    'other'
+];
+const SENTIMENTS = [
+    'positive',
+    'neutral',
+    'negative',
+    'mixed'
+];
+const MAX_FEEDBACK_TEXT_LENGTH = 2048;
+const MAX_FEEDBACK_TOOL_NAME_LENGTH = 256;
+const TRUNCATION_SUFFIX = '...';
+const DEFAULT_FEEDBACK_DESCRIPTION = 'Send feedback about this server to its developers. Most important: report a missing capability whenever no available tool fits your task, even if you can work around it (feedback_type "missing_capability"). Also welcome: a tool that failed or confused you, an unhelpful error, or something that worked well. This records the feedback; it does not add or change tools. Do not include user PII or sensitive content.';
+const CORE_FEEDBACK_SCHEMA_PROPERTIES = {
+    feedback_type: {
+        type: 'string',
+        enum: [
+            ...FEEDBACK_TYPES
+        ],
+        description: "What kind of feedback this is. Use 'missing_capability' when the tool you needed does not exist in the tool list - nothing failed, the capability is absent (this is the most valuable report; send it even if you found a workaround). Use 'issue' when an existing tool behaved badly: it failed, returned a confusing error, or its description or schema misled you. Use 'praise' when something worked notably well. Use 'other' for anything else."
+    },
+    summary: {
+        type: 'string',
+        description: "One self-contained sentence. For 'missing_capability': the capability you needed, e.g. 'No tool to delete multiple cohorts in one call.' For 'issue': the tool and the problem, e.g. 'query-trends rejects relative date ranges with an unclear error.'"
+    },
+    details: {
+        type: 'string',
+        description: "Optional longer context: what you tried, exact parameter values, the error text you saw, and any workaround you used. Omit when the summary says it all."
+    },
+    friction_points: {
+        type: 'string',
+        description: "Optional: the specific moments that slowed you down, as short bullet-like sentences, quoting exact tool names, parameters, or error text."
+    },
+    suggested_improvement: {
+        type: 'string',
+        description: "Optional: the concrete change that would have helped, e.g. the tool to add, the description to reword, or the error message to improve."
+    },
+    tool_name: {
+        type: 'string',
+        description: "Optional: the existing tool this feedback is about (for 'issue' or 'praise'). Leave empty for 'missing_capability' - the point is that no tool fits."
+    },
+    sentiment: {
+        type: 'string',
+        enum: [
+            ...SENTIMENTS
+        ],
+        description: 'Optional: how the experience felt overall.'
+    },
+    task_completed: {
+        type: 'boolean',
+        description: "Optional: whether you still completed the user's task despite the problem."
+    }
+};
+const RESERVED_EXTRA_PROPERTY_KEYS = new Set([
+    ...Object.keys(CORE_FEEDBACK_SCHEMA_PROPERTIES),
+    'type',
+    'tool',
+    'context',
+    'conversation_id',
+    'llm_model'
+]);
+function resolveCollectFeedbackOptions(config) {
+    if (!config) return;
+    return true === config ? {} : config;
+}
+function getFeedbackToolDescriptor(options = {}) {
+    const extraProperties = options.extraProperties ?? {};
+    const extraRequired = options.extraRequired ?? [];
+    for (const key of Object.keys(extraProperties))if (RESERVED_EXTRA_PROPERTY_KEYS.has(key)) throw new Error(`collectFeedback.extraProperties key "${key}" collides with a core or SDK-reserved send_feedback field. Rename it.`);
+    for (const key of extraRequired)if (!Object.prototype.hasOwnProperty.call(extraProperties, key)) throw new Error(`collectFeedback.extraRequired key "${key}" is not declared in extraProperties.`);
+    const copiedExtras = Object.keys(extraProperties).length > 0 ? JSON.parse(JSON.stringify(extraProperties)) : void 0;
+    return {
+        name: options.toolName ?? SEND_FEEDBACK_TOOL_NAME,
+        description: options.description ?? DEFAULT_FEEDBACK_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ...JSON.parse(JSON.stringify(CORE_FEEDBACK_SCHEMA_PROPERTIES)),
+                ...copiedExtras
+            },
+            required: [
+                'feedback_type',
+                'summary',
+                ...extraRequired
+            ]
+        },
+        annotations: {
+            title: 'Send feedback',
+            readOnlyHint: true,
+            openWorldHint: true,
+            idempotentHint: true,
+            destructiveHint: false
+        }
+    };
+}
+function readString(value) {
+    return 'string' == typeof value && value.trim() ? value : void 0;
+}
+function parseFeedbackType(value) {
+    return FEEDBACK_TYPES.includes(value) ? value : 'other';
+}
+function parseSentiment(value) {
+    return SENTIMENTS.includes(value) ? value : void 0;
+}
+function matchesExtraSchema(value, schema) {
+    const type = Array.isArray(value) ? 'array' : null === value ? 'null' : typeof value;
+    if (schema.type !== type && !('integer' === schema.type && 'number' == typeof value)) return false;
+    return !Array.isArray(schema.enum) || schema.enum.includes(value);
+}
+function parseFeedbackReport(args, options = {}) {
+    const raw = args ?? {};
+    const extras = {};
+    for (const [key, schema] of Object.entries(options.extraProperties ?? {}))if (void 0 !== raw[key] && matchesExtraSchema(raw[key], schema)) extras[key] = raw[key];
+    return {
+        feedbackType: parseFeedbackType(raw.feedback_type),
+        summary: readString(raw.summary) ?? '',
+        sentiment: parseSentiment(raw.sentiment),
+        frictionPoints: readString(raw.friction_points),
+        suggestedImprovement: readString(raw.suggested_improvement),
+        details: readString(raw.details),
+        toolName: readString(raw.tool_name),
+        taskCompleted: 'boolean' == typeof raw.task_completed ? raw.task_completed : void 0,
+        extras,
+        raw
+    };
+}
+function buildFeedbackIntent(report) {
+    return [
+        report.summary,
+        report.details
+    ].filter(Boolean).join('\n\n');
+}
+function truncateFeedbackText(value, maxLength) {
+    return value.length > maxLength ? value.slice(0, maxLength) + TRUNCATION_SUFFIX : value;
+}
+function captureFreeText(value) {
+    return truncateFeedbackText(sanitizeFreeText(value), MAX_FEEDBACK_TEXT_LENGTH);
+}
+function captureExtraValue(value) {
+    const sanitized = sanitizeFreeTextValue(value);
+    if ('string' == typeof sanitized) return truncateFeedbackText(sanitized, MAX_FEEDBACK_TEXT_LENGTH);
+    if (null == sanitized || 'number' == typeof sanitized || 'boolean' == typeof sanitized) return sanitized;
+    try {
+        return truncateFeedbackText(JSON.stringify(sanitized), MAX_FEEDBACK_TEXT_LENGTH);
+    } catch  {
+        return;
+    }
+}
+function buildFeedbackEventProperties(report) {
+    const properties = {
+        [PostHogMCPAnalyticsProperty.FeedbackType]: report.feedbackType
+    };
+    if (report.summary) properties[PostHogMCPAnalyticsProperty.FeedbackSummary] = captureFreeText(report.summary);
+    if (report.sentiment) properties[PostHogMCPAnalyticsProperty.FeedbackSentiment] = report.sentiment;
+    if (report.frictionPoints) properties[PostHogMCPAnalyticsProperty.FeedbackFrictionPoints] = captureFreeText(report.frictionPoints);
+    if (report.suggestedImprovement) properties[PostHogMCPAnalyticsProperty.FeedbackSuggestedImprovement] = captureFreeText(report.suggestedImprovement);
+    if (report.details) properties[PostHogMCPAnalyticsProperty.FeedbackDetails] = captureFreeText(report.details);
+    if (report.toolName) properties[PostHogMCPAnalyticsProperty.FeedbackTool] = truncateFeedbackText(sanitizeFreeText(report.toolName), MAX_FEEDBACK_TOOL_NAME_LENGTH);
+    if (void 0 !== report.taskCompleted) properties[PostHogMCPAnalyticsProperty.FeedbackTaskCompleted] = report.taskCompleted;
+    for (const [key, value] of Object.entries(report.extras)){
+        const captured = captureExtraValue(value);
+        if (void 0 !== captured) properties[`$mcp_feedback_${key}`] = captured;
+    }
+    return properties;
+}
+function sendFeedbackResult() {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: "Your feedback was recorded for the server's developers. No additional tools are available - continue with the tools already listed."
+            }
+        ]
+    };
+}
+async function handleFeedback(report, options = {}, logger = log) {
+    logger(`Agent feedback reported (${report.feedbackType})`);
+    if (options.onFeedback) try {
+        const reply = await options.onFeedback(report);
+        if ('string' == typeof reply && reply.trim()) return {
+            content: [
+                {
+                    type: 'text',
+                    text: reply
+                }
+            ]
+        };
+    } catch (error) {
+        logger(`Warning: onFeedback handler threw; returning the default acknowledgement - ${error}`);
+    }
+    return sendFeedbackResult();
+}
+export { SEND_FEEDBACK_TOOL_NAME, buildFeedbackEventProperties, buildFeedbackIntent, getFeedbackToolDescriptor, handleFeedback, parseFeedbackReport, resolveCollectFeedbackOptions, sendFeedbackResult };

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

@@ -1 +1 @@
-{"version":3,"file":"instrument-highlevel.d.ts","sourceRoot":"","sources":["../../src/extensions/instrument-highlevel.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAGV,sBAAsB,EAIvB,MAAM,UAAU,CAAA;AAUjB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAoQxC,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,sBAAsB,EAAE,MAAM,EAAE,QAAQ,GAAG,IAAI,CA+BhG"}
+{"version":3,"file":"instrument-highlevel.d.ts","sourceRoot":"","sources":["../../src/extensions/instrument-highlevel.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAGV,sBAAsB,EAIvB,MAAM,UAAU,CAAA;AAmBjB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAgSxC,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,sBAAsB,EAAE,MAAM,EAAE,QAAQ,GAAG,IAAI,CA+BhG"}

package/dist/extensions/instrument-highlevel.js

@@ -30,6 +30,7 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     instrumentHighLevelServer: ()=>instrumentHighLevelServer
 });
+const external_feedback_js_namespaceObject = require("./feedback.js");
 const external_analytics_parameters_js_namespaceObject = require("./analytics-parameters.js");
 const external_context_parameters_js_namespaceObject = require("./context-parameters.js");
 const external_model_parameters_js_namespaceObject = require("./model-parameters.js");
@@ -171,12 +172,29 @@ async function handleToolCallRequest(highLevelServer, server, originalCallToolHa
             extra,
             eventType: external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpMissingCapability,
             explicitContextIntent: context,
-            parameterOwnership: (0, external_instrumentation_js_namespaceObject.getVirtualToolParameterOwnership)(data, toolName),
+            parameterOwnership: (0, external_instrumentation_js_namespaceObject.getVirtualToolParameterOwnership)(data, toolName, (0, external_tools_js_namespaceObject.getReportMissingToolDescriptor)(toolName).inputSchema),
             execute: async ()=>(0, external_tools_js_namespaceObject.handleReportMissing)({
                     context
                 }, data.logger)
         });
     }
+    const feedbackOptions = (0, external_feedback_js_namespaceObject.resolveCollectFeedbackOptions)(data.options.collectFeedback);
+    const isFeedbackCandidate = void 0 !== feedbackOptions && toolName === (feedbackOptions.toolName ?? external_feedback_js_namespaceObject.SEND_FEEDBACK_TOOL_NAME);
+    if (isFeedbackCandidate && await (0, external_instrumentation_js_namespaceObject.isToolAdvertised)(server, toolName, extra, data.logger) === false) {
+        const report = (0, external_feedback_js_namespaceObject.parseFeedbackReport)(request.params?.arguments, feedbackOptions);
+        return await (0, external_instrumentation_js_namespaceObject.captureToolCall)({
+            server,
+            data,
+            request,
+            extra,
+            eventType: external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpFeedback,
+            explicitContextIntent: (0, external_feedback_js_namespaceObject.buildFeedbackIntent)(report),
+            omitCapturedParameters: true,
+            extraEventProperties: (0, external_feedback_js_namespaceObject.buildFeedbackEventProperties)(report),
+            parameterOwnership: (0, external_instrumentation_js_namespaceObject.getVirtualToolParameterOwnership)(data, toolName, (0, external_feedback_js_namespaceObject.getFeedbackToolDescriptor)(feedbackOptions).inputSchema),
+            execute: async ()=>(0, external_feedback_js_namespaceObject.handleFeedback)(report, feedbackOptions, data.logger)
+        });
+    }
     const registeredTool = toolName ? highLevelServer._registeredTools[toolName] : void 0;
     return await (0, external_instrumentation_js_namespaceObject.captureToolCall)({
         server,

package/dist/extensions/instrument-highlevel.mjs

@@ -1,10 +1,11 @@
+import { SEND_FEEDBACK_TOOL_NAME, buildFeedbackEventProperties, buildFeedbackIntent, getFeedbackToolDescriptor, handleFeedback, parseFeedbackReport, resolveCollectFeedbackOptions } from "./feedback.mjs";
 import { analyticsOwnsParameter, getAnalyticsParameterOwnership, stripOwnedAnalyticsArguments } from "./analytics-parameters.mjs";
 import { isContextEnabled } from "./context-parameters.mjs";
 import { isCaptureModelEnabled } from "./model-parameters.mjs";
 import { MCPAnalyticsEventType } from "./event-types.mjs";
 import { getServerTrackingData } from "./internal.mjs";
 import { createWrappedTool, getToolFunction, hasToolFunction } from "./mcp-sdk-compat.mjs";
-import { handleReportMissing, resolveMissingCapabilityToolName } from "./tools.mjs";
+import { getReportMissingToolDescriptor, handleReportMissing, resolveMissingCapabilityToolName } from "./tools.mjs";
 import { captureToolCall, getVirtualToolParameterOwnership, handleInitializeRequest, handleListToolsRequest, isToolAdvertised, patchRequestHandlers, readToolMetaCategory, traceResourceRequest } from "./instrumentation.mjs";
 import { getContextArgument } from "./tracing-helpers.mjs";
 const wrappedCallbacks = new WeakMap();
@@ -139,12 +140,29 @@ async function handleToolCallRequest(highLevelServer, server, originalCallToolHa
             extra,
             eventType: MCPAnalyticsEventType.mcpMissingCapability,
             explicitContextIntent: context,
-            parameterOwnership: getVirtualToolParameterOwnership(data, toolName),
+            parameterOwnership: getVirtualToolParameterOwnership(data, toolName, getReportMissingToolDescriptor(toolName).inputSchema),
             execute: async ()=>handleReportMissing({
                     context
                 }, data.logger)
         });
     }
+    const feedbackOptions = resolveCollectFeedbackOptions(data.options.collectFeedback);
+    const isFeedbackCandidate = void 0 !== feedbackOptions && toolName === (feedbackOptions.toolName ?? SEND_FEEDBACK_TOOL_NAME);
+    if (isFeedbackCandidate && await isToolAdvertised(server, toolName, extra, data.logger) === false) {
+        const report = parseFeedbackReport(request.params?.arguments, feedbackOptions);
+        return await captureToolCall({
+            server,
+            data,
+            request,
+            extra,
+            eventType: MCPAnalyticsEventType.mcpFeedback,
+            explicitContextIntent: buildFeedbackIntent(report),
+            omitCapturedParameters: true,
+            extraEventProperties: buildFeedbackEventProperties(report),
+            parameterOwnership: getVirtualToolParameterOwnership(data, toolName, getFeedbackToolDescriptor(feedbackOptions).inputSchema),
+            execute: async ()=>handleFeedback(report, feedbackOptions, data.logger)
+        });
+    }
     const registeredTool = toolName ? highLevelServer._registeredTools[toolName] : void 0;
     return await captureToolCall({
         server,

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

@@ -1 +1 @@
-{"version":3,"file":"instrument-lowlevel.d.ts","sourceRoot":"","sources":["../../src/extensions/instrument-lowlevel.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAiD,aAAa,EAAE,MAAM,UAAU,CAAA;AAG5F,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAqBxC;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,QAAQ,GAAG,IAAI,CA8BtF"}
+{"version":3,"file":"instrument-lowlevel.d.ts","sourceRoot":"","sources":["../../src/extensions/instrument-lowlevel.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAiD,aAAa,EAAE,MAAM,UAAU,CAAA;AAY5F,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAqBxC;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,QAAQ,GAAG,IAAI,CA8BtF"}

package/dist/extensions/instrument-lowlevel.js

@@ -30,6 +30,7 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     instrumentLowLevelServer: ()=>instrumentLowLevelServer
 });
+const external_feedback_js_namespaceObject = require("./feedback.js");
 const external_event_types_js_namespaceObject = require("./event-types.js");
 const external_internal_js_namespaceObject = require("./internal.js");
 const external_tools_js_namespaceObject = require("./tools.js");
@@ -74,12 +75,29 @@ async function handleToolCallRequest(server, originalCallToolHandler, request, e
             extra,
             eventType: external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpMissingCapability,
             explicitContextIntent: context,
-            parameterOwnership: (0, external_instrumentation_js_namespaceObject.getVirtualToolParameterOwnership)(data, toolName),
+            parameterOwnership: (0, external_instrumentation_js_namespaceObject.getVirtualToolParameterOwnership)(data, toolName, (0, external_tools_js_namespaceObject.getReportMissingToolDescriptor)(toolName).inputSchema),
             execute: async ()=>(0, external_tools_js_namespaceObject.handleReportMissing)({
                     context
                 }, data.logger)
         });
     }
+    const feedbackOptions = (0, external_feedback_js_namespaceObject.resolveCollectFeedbackOptions)(data.options.collectFeedback);
+    const isFeedbackCandidate = void 0 !== feedbackOptions && toolName === (feedbackOptions.toolName ?? external_feedback_js_namespaceObject.SEND_FEEDBACK_TOOL_NAME);
+    if (isFeedbackCandidate && await (0, external_instrumentation_js_namespaceObject.isToolAdvertised)(server, toolName, extra, data.logger) === false) {
+        const report = (0, external_feedback_js_namespaceObject.parseFeedbackReport)(request.params?.arguments, feedbackOptions);
+        return await (0, external_instrumentation_js_namespaceObject.captureToolCall)({
+            server,
+            data,
+            request,
+            extra,
+            eventType: external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpFeedback,
+            explicitContextIntent: (0, external_feedback_js_namespaceObject.buildFeedbackIntent)(report),
+            omitCapturedParameters: true,
+            extraEventProperties: (0, external_feedback_js_namespaceObject.buildFeedbackEventProperties)(report),
+            parameterOwnership: (0, external_instrumentation_js_namespaceObject.getVirtualToolParameterOwnership)(data, toolName, (0, external_feedback_js_namespaceObject.getFeedbackToolDescriptor)(feedbackOptions).inputSchema),
+            execute: async ()=>(0, external_feedback_js_namespaceObject.handleFeedback)(report, feedbackOptions, data.logger)
+        });
+    }
     return await (0, external_instrumentation_js_namespaceObject.captureToolCall)({
         server,
         data,

package/dist/extensions/instrument-lowlevel.mjs

@@ -1,6 +1,7 @@
+import { SEND_FEEDBACK_TOOL_NAME, buildFeedbackEventProperties, buildFeedbackIntent, getFeedbackToolDescriptor, handleFeedback, parseFeedbackReport, resolveCollectFeedbackOptions } from "./feedback.mjs";
 import { MCPAnalyticsEventType } from "./event-types.mjs";
 import { getServerTrackingData } from "./internal.mjs";
-import { handleReportMissing, resolveMissingCapabilityToolName } from "./tools.mjs";
+import { getReportMissingToolDescriptor, handleReportMissing, resolveMissingCapabilityToolName } from "./tools.mjs";
 import { captureToolCall, getVirtualToolParameterOwnership, handleInitializeRequest, handleListToolsRequest, isToolAdvertised, patchRequestHandlers, registerFallbackRequestHandler, traceResourceRequest } from "./instrumentation.mjs";
 import { getContextArgument } from "./tracing-helpers.mjs";
 function instrumentLowLevelServer(server, logger) {
@@ -42,12 +43,29 @@ async function handleToolCallRequest(server, originalCallToolHandler, request, e
             extra,
             eventType: MCPAnalyticsEventType.mcpMissingCapability,
             explicitContextIntent: context,
-            parameterOwnership: getVirtualToolParameterOwnership(data, toolName),
+            parameterOwnership: getVirtualToolParameterOwnership(data, toolName, getReportMissingToolDescriptor(toolName).inputSchema),
             execute: async ()=>handleReportMissing({
                     context
                 }, data.logger)
         });
     }
+    const feedbackOptions = resolveCollectFeedbackOptions(data.options.collectFeedback);
+    const isFeedbackCandidate = void 0 !== feedbackOptions && toolName === (feedbackOptions.toolName ?? SEND_FEEDBACK_TOOL_NAME);
+    if (isFeedbackCandidate && await isToolAdvertised(server, toolName, extra, data.logger) === false) {
+        const report = parseFeedbackReport(request.params?.arguments, feedbackOptions);
+        return await captureToolCall({
+            server,
+            data,
+            request,
+            extra,
+            eventType: MCPAnalyticsEventType.mcpFeedback,
+            explicitContextIntent: buildFeedbackIntent(report),
+            omitCapturedParameters: true,
+            extraEventProperties: buildFeedbackEventProperties(report),
+            parameterOwnership: getVirtualToolParameterOwnership(data, toolName, getFeedbackToolDescriptor(feedbackOptions).inputSchema),
+            execute: async ()=>handleFeedback(report, feedbackOptions, data.logger)
+        });
+    }
     return await captureToolCall({
         server,
         data,

package/dist/extensions/instrumentation.d.ts

@@ -1,4 +1,4 @@
-import type { AnalyticsParameterOwnership, CompatibleRequestHandlerExtra, CompatibleToolsListLike, MCPAnalyticsData, MCPRequestLike, MCPServerLike } from '../types';
+import type { AnalyticsParameterOwnership, CompatibleRequestHandlerExtra, CompatibleToolsListLike, JsonRecord, MCPAnalyticsData, MCPRequestLike, MCPServerLike } from '../types';
 import { MCPAnalyticsEventType } from './event-types';
 import type { LoggerFn } from './logger';
 /**
@@ -21,16 +21,29 @@ interface TraceToolCallParams {
     parameterOwnership?: AnalyticsParameterOwnership;
     /**
      * Event type to capture. Defaults to a tool call; the `get_more_tools` virtual
-     * tool passes `mcpMissingCapability` so it records a capability gap rather than
-     * a tool invocation.
+     * tool passes `mcpMissingCapability` and `send_feedback` passes
+     * `mcpFeedback`, so they record a capability gap / a feedback report
+     * rather than a tool invocation.
      */
     eventType?: MCPAnalyticsEventType;
     /**
      * When set, used verbatim as the captured intent (source `context_parameter`)
-     * instead of running `resolveToolCallIntent`. Used by the `get_more_tools`
-     * virtual tool, which carries its intent in the `context` argument.
+     * instead of running `resolveToolCallIntent`. Used by the virtual tools, which
+     * carry their intent in their own arguments.
      */
     explicitContextIntent?: string;
+    /**
+     * Extra event properties spread onto the captured event, after the host's
+     * `eventProperties`. Used by `send_feedback` for its `$mcp_feedback_*` fields.
+     */
+    extraEventProperties?: JsonRecord;
+    /**
+     * Drop the generically captured `$mcp_parameters` from the event. Used by
+     * `send_feedback`: its arguments are agent-narrated free text, so the
+     * PII-redacted `$mcp_feedback_*` properties are the captured surface — the
+     * raw arguments would bypass that redaction and record undeclared fields.
+     */
+    omitCapturedParameters?: boolean;
     /**
      * Optional accessor for an error the executor captured out-of-band. The
      * high-level SDK turns thrown tool errors into `isError: true` results before
@@ -88,21 +101,25 @@ export declare function registerFallbackRequestHandler(server: MCPServerLike, ha
  */
 export declare function patchRequestHandlers(server: MCPServerLike, patches: Record<string, HandlerPatch>): void;
 /**
- * Ownership for the `get_more_tools` virtual tool, resolved without the
- * `tools/list` cache.
+ * Ownership for an SDK-owned virtual tool (`get_more_tools`, `send_feedback`),
+ * resolved from its own descriptor rather than the `tools/list` cache.
  *
- * The missing-capability branch is only entered when the application does not
- * advertise a tool by this name, so the descriptor is the SDK's own and what it
- * declares is known statically. An instance that never served a listing — a
- * per-request `McpServer`/`Server`, the topology in ADR-0011 — would otherwise
- * read every injected parameter as not-ours and neither capture nor strip it.
+ * A virtual-tool branch is only entered when the application does not advertise
+ * a tool by this name, so the descriptor is the SDK's own and what it declares
+ * is known statically. An instance that never served a listing — a per-request
+ * `McpServer`/`Server`, the topology in ADR-0011 — would otherwise read every
+ * injected parameter as not-ours and neither capture nor strip it.
  *
  * `conversation_id` still comes from the cache on purpose: resolving it here too
  * would start minting a handle, and appending its prompt-back block, on
  * instances that today mint none. That changes session anchoring (ADR-0004)
  * rather than closing this gap.
+ *
+ * `virtualToolInputSchema` is required (not defaulted to one specific virtual
+ * tool's descriptor) so every call site names the tool it means; each caller
+ * passes its own descriptor's `inputSchema`.
  */
-export declare function getVirtualToolParameterOwnership(data: MCPAnalyticsData, toolName: string): AnalyticsParameterOwnership;
+export declare function getVirtualToolParameterOwnership(data: MCPAnalyticsData, toolName: string, virtualToolInputSchema: unknown): AnalyticsParameterOwnership;
 /**
  * Checks the server's raw listing for a real owner of a candidate virtual tool.
  * This does not depend on a previous client request and does not call the

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

@@ -1 +1 @@
-{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/extensions/instrumentation.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/extensions/instrumentation.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,2BAA2B,EAC3B,6BAA6B,EAC7B,uBAAuB,EACvB,UAAU,EACV,gBAAgB,EAChB,cAAc,EACd,aAAa,EAId,MAAM,UAAU,CAAA;AAqBjB,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAIrD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAUxC;;;;;;GAMG;AAEH,KAAK,iBAAiB,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,CAAC,EAAE,6BAA6B,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAE7G,2EAA2E;AAC3E,KAAK,YAAY,GAAG,CAAC,iBAAiB,EAAE,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAE3E,UAAU,mBAAmB;IAC3B,MAAM,EAAE,aAAa,CAAA;IACrB,IAAI,EAAE,gBAAgB,CAAA;IACtB,OAAO,EAAE,cAAc,CAAA;IACvB,KAAK,CAAC,EAAE,6BAA6B,CAAA;IACrC,OAAO,EAAE,YAAY,CAAA;IACrB,2FAA2F;IAC3F,kBAAkB,CAAC,EAAE,2BAA2B,CAAA;IAChD;;;;;OAKG;IACH,SAAS,CAAC,EAAE,qBAAqB,CAAA;IACjC;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B;;;OAGG;IACH,oBAAoB,CAAC,EAAE,UAAU,CAAA;IACjC;;;;;OAKG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,OAAO,CAAA;CAClC;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC,CA2EnF;AA4OD,KAAK,iBAAiB,GAAG,OAAO,qBAAqB,CAAC,gBAAgB,GAAG,OAAO,qBAAqB,CAAC,gBAAgB,CAAA;AAuDtH,sFAAsF;AACtF,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,iBAAiB,EAAE,MAAM,EAAE,QAAQ,GAAG,YAAY,CAGjG;AAgDD;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,CACzB,MAAM,EAAE,aAAa,EACrB,eAAe,EAAE,iBAAiB,EAClC,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,6BAA6B,GAAG,SAAS,KAC7C,OAAO,CAAC,OAAO,CAAC,CAAA;AAkBrB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,iBAAiB,EAClC,KAAK,EAAE,YAAY,GAClB,IAAI,CAGN;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,IAAI,CA0CvG;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,gBAAgB,EACtB,QAAQ,EAAE,MAAM,EAChB,sBAAsB,EAAE,OAAO,GAC9B,2BAA2B,CAK7B;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,6BAA6B,GAAG,SAAS,EAChD,MAAM,EAAE,QAAQ,GACf,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAoB9B;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,aAAa,EACrB,wBAAwB,EAAE,iBAAiB,EAC3C,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,6BAA6B,GAAG,SAAS,EAChD,MAAM,EAAE,QAAQ,GACf,OAAO,CAAC,uBAAuB,CAAC,CAmElC;AAgHD,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1B,KAAK,EAAE,uBAAuB,CAAC,OAAO,CAAC,GAAG,SAAS,GAClD,IAAI,CASN;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAGtE;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1B,KAAK,EAAE,uBAAuB,CAAC,OAAO,CAAC,GAAG,SAAS,GAClD,IAAI,CAUN;AAuHD;;;GAGG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,aAAa,EACrB,yBAAyB,EAAE,iBAAiB,EAC5C,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,6BAA6B,GAAG,SAAS,EAChD,MAAM,EAAE,QAAQ,GACf,OAAO,CAAC,OAAO,CAAC,CA2ElB"}

package/dist/extensions/instrumentation.js

@@ -57,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);
@@ -80,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
@@ -289,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
     };
 }
@@ -377,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);

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
@@ -247,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
     };
 }
@@ -335,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);