@posthog/mcp 0.15.0 → 0.16.1

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

@@ -1,7 +1,7 @@
 type JsonRecord = Record<string, unknown>;
 /**
- * Sanitizes the agent-narrated intent: structured PII on top of the passes every
- * captured string gets.
+ * 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
@@ -11,7 +11,7 @@ type JsonRecord = Record<string, unknown>;
  * URL pass, because the URL rewrite percent-encodes the `@` that the email
  * pattern anchors on.
  */
-export declare function sanitizeIntent(value: string): string;
+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
@@ -23,6 +23,12 @@ export declare function sanitizeIntent(value: string): string;
  */
 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":"AAoHA,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAyYzC;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKpD;AA6DD;;;;;;;;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"}

package/dist/extensions/mcp-payloads.js

@@ -262,7 +262,7 @@ function redactUrls(value) {
 function sanitizeString(value) {
     return isBinaryBlob(value) ? BINARY_REDACTED_VALUE : redactUrls(redactCredentials(value));
 }
-function sanitizeIntent(value) {
+function sanitizeFreeText(value) {
     if (isBinaryBlob(value)) return BINARY_REDACTED_VALUE;
     return redactUrls(redactPii(redactCredentials(value)));
 }
@@ -319,13 +319,19 @@ function redactPii(value) {
     return result;
 }
 function sanitizeCapturedValue(value) {
+    return sanitizeValueWith(value, sanitizeString);
+}
+function sanitizeFreeTextValue(value) {
+    return sanitizeValueWith(value, sanitizeFreeText);
+}
+function sanitizeValueWith(value, sanitizeStringFn) {
     if (null == value) return value;
-    if ('string' == typeof value) return sanitizeString(value);
-    if (Array.isArray(value)) return value.map(sanitizeCapturedValue);
+    if ('string' == typeof value) return sanitizeStringFn(value);
+    if (Array.isArray(value)) return value.map((item)=>sanitizeValueWith(item, sanitizeStringFn));
     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);
+    for (const [key, nestedValue] of Object.entries(value))result[key] = shouldRedactKey(key) ? REDACTED_VALUE : sanitizeValueWith(nestedValue, sanitizeStringFn);
     return result;
 }
 function buildCapturedMcpArguments(argumentsValue) {
@@ -359,17 +365,20 @@ __webpack_require__.d(__webpack_exports__, {
     buildCapturedMcpParameters: ()=>buildCapturedMcpParameters,
     redactPii: ()=>redactPii,
     sanitizeCapturedValue: ()=>sanitizeCapturedValue,
-    sanitizeIntent: ()=>sanitizeIntent
+    sanitizeFreeText: ()=>sanitizeFreeText,
+    sanitizeFreeTextValue: ()=>sanitizeFreeTextValue
 });
 exports.buildCapturedMcpParameters = __webpack_exports__.buildCapturedMcpParameters;
 exports.redactPii = __webpack_exports__.redactPii;
 exports.sanitizeCapturedValue = __webpack_exports__.sanitizeCapturedValue;
-exports.sanitizeIntent = __webpack_exports__.sanitizeIntent;
+exports.sanitizeFreeText = __webpack_exports__.sanitizeFreeText;
+exports.sanitizeFreeTextValue = __webpack_exports__.sanitizeFreeTextValue;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "buildCapturedMcpParameters",
     "redactPii",
     "sanitizeCapturedValue",
-    "sanitizeIntent"
+    "sanitizeFreeText",
+    "sanitizeFreeTextValue"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/extensions/mcp-payloads.mjs

@@ -233,7 +233,7 @@ function redactUrls(value) {
 function sanitizeString(value) {
     return isBinaryBlob(value) ? BINARY_REDACTED_VALUE : redactUrls(redactCredentials(value));
 }
-function sanitizeIntent(value) {
+function sanitizeFreeText(value) {
     if (isBinaryBlob(value)) return BINARY_REDACTED_VALUE;
     return redactUrls(redactPii(redactCredentials(value)));
 }
@@ -290,13 +290,19 @@ function redactPii(value) {
     return result;
 }
 function sanitizeCapturedValue(value) {
+    return sanitizeValueWith(value, sanitizeString);
+}
+function sanitizeFreeTextValue(value) {
+    return sanitizeValueWith(value, sanitizeFreeText);
+}
+function sanitizeValueWith(value, sanitizeStringFn) {
     if (null == value) return value;
-    if ('string' == typeof value) return sanitizeString(value);
-    if (Array.isArray(value)) return value.map(sanitizeCapturedValue);
+    if ('string' == typeof value) return sanitizeStringFn(value);
+    if (Array.isArray(value)) return value.map((item)=>sanitizeValueWith(item, sanitizeStringFn));
     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);
+    for (const [key, nestedValue] of Object.entries(value))result[key] = shouldRedactKey(key) ? REDACTED_VALUE : sanitizeValueWith(nestedValue, sanitizeStringFn);
     return result;
 }
 function buildCapturedMcpArguments(argumentsValue) {
@@ -326,4 +332,4 @@ function buildCapturedMcpParameters(request) {
         request: capturedRequest
     };
 }
-export { buildCapturedMcpParameters, redactPii, sanitizeCapturedValue, sanitizeIntent };
+export { buildCapturedMcpParameters, redactPii, sanitizeCapturedValue, sanitizeFreeText, sanitizeFreeTextValue };

package/dist/extensions/posthog-events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"posthog-events.d.ts","sourceRoot":"","sources":["../../src/extensions/posthog-events.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAyBrC,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACnC,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,SAAS,CAAA;CAChB;AAED,MAAM,WAAW,gCAAgC;IAC/C,2FAA2F;IAC3F,0BAA0B,CAAC,EAAE,OAAO,CAAA;CACrC;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,KAAK,EACZ,OAAO,GAAE,gCAAqC,GAC7C,mBAAmB,EAAE,CAQvB"}
+{"version":3,"file":"posthog-events.d.ts","sourceRoot":"","sources":["../../src/extensions/posthog-events.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AA0BrC,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACnC,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,SAAS,CAAA;CAChB;AAED,MAAM,WAAW,gCAAgC;IAC/C,2FAA2F;IAC3F,0BAA0B,CAAC,EAAE,OAAO,CAAA;CACrC;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,KAAK,EACZ,OAAO,GAAE,gCAAqC,GAC7C,mBAAmB,EAAE,CAQvB"}

package/dist/extensions/posthog-events.js

@@ -35,6 +35,7 @@ const external_event_types_js_namespaceObject = require("./event-types.js");
 const BUILT_IN_EVENT_NAME_BY_TYPE = {
     [external_event_types_js_namespaceObject.MCPAnalyticsEventType.custom]: external_constants_js_namespaceObject.PostHogMCPAnalyticsEvent.Custom,
     [external_event_types_js_namespaceObject.MCPAnalyticsEventType.identify]: external_constants_js_namespaceObject.PostHogMCPAnalyticsEvent.Identify,
+    [external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpFeedback]: external_constants_js_namespaceObject.PostHogMCPAnalyticsEvent.Feedback,
     [external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpMissingCapability]: external_constants_js_namespaceObject.PostHogMCPAnalyticsEvent.MissingCapability,
     [external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpInitialize]: external_constants_js_namespaceObject.PostHogMCPAnalyticsEvent.Initialize,
     [external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpPromptsGet]: external_constants_js_namespaceObject.PostHogMCPAnalyticsEvent.PromptGet,

package/dist/extensions/posthog-events.mjs

@@ -3,6 +3,7 @@ import { MCPAnalyticsEventType } from "./event-types.mjs";
 const BUILT_IN_EVENT_NAME_BY_TYPE = {
     [MCPAnalyticsEventType.custom]: PostHogMCPAnalyticsEvent.Custom,
     [MCPAnalyticsEventType.identify]: PostHogMCPAnalyticsEvent.Identify,
+    [MCPAnalyticsEventType.mcpFeedback]: PostHogMCPAnalyticsEvent.Feedback,
     [MCPAnalyticsEventType.mcpMissingCapability]: PostHogMCPAnalyticsEvent.MissingCapability,
     [MCPAnalyticsEventType.mcpInitialize]: PostHogMCPAnalyticsEvent.Initialize,
     [MCPAnalyticsEventType.mcpPromptsGet]: PostHogMCPAnalyticsEvent.PromptGet,

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

@@ -1,5 +1,5 @@
 import { PostHog, type PostHogOptions } from 'posthog-node';
-import type { InitializeCaptureData, MCPAnalyticsOptions, MissingCapabilityCaptureData, PreparedToolCall, PrepareToolCallOptions, PrepareToolListOptions, ToolCallCaptureData, ToolsListCaptureData } from '../types';
+import type { FeedbackCaptureData, CollectFeedbackConfig, InitializeCaptureData, MCPAnalyticsOptions, MissingCapabilityCaptureData, PreparedToolCall, PrepareToolCallOptions, PrepareToolListOptions, ToolCallCaptureData, ToolsListCaptureData } from '../types';
 import { type ContextInjectableTool } from './context-parameters';
 /**
  * Options for {@link PostHogMCP}. A superset of `posthog-node`'s options, plus
@@ -13,6 +13,17 @@ export interface PostHogMCPOptions extends PostHogOptions {
      * can't drift. Defaults to `get_more_tools`.
      */
     missingCapabilityToolName?: string;
+    /**
+     * Enable + configure the `send_feedback` virtual tool: injected by
+     * {@link PostHogMCP.prepareToolList} (when its `collectFeedback` toggle is on)
+     * and detected by {@link PostHogMCP.prepareToolCall}. Set once here so
+     * injection and detection can't drift — without this option, `prepareToolCall`
+     * never flags a call as feedback, so a real tool that uses the name is not
+     * shadowed. Pick a `toolName` no real tool uses. `onFeedback` is ignored on
+     * this path — the host dispatcher routes reports itself via
+     * {@link PreparedToolCall.feedbackReport}.
+     */
+    collectFeedback?: CollectFeedbackConfig;
     /**
      * Capture the calling model from recognized client metadata, with an injected
      * `llm_model` argument as fallback. Off by default.
@@ -73,8 +84,9 @@ export declare class PostHogMCP extends PostHog {
      * Decorate your `tools/list` response with PostHog's analytics affordances:
      * injects the `context` argument into every tool (so agents state their intent,
      * captured as `$mcp_intent`), injects `llm_model` when the constructor's
-     * `captureModel` option is enabled, and appends `get_more_tools` when
-     * `reportMissing` is on. Returns a new array; your tools are untouched.
+     * `captureModel` option is enabled, appends `get_more_tools` when
+     * `reportMissing` is on, and appends `send_feedback` when `collectFeedback` is
+     * on. Returns a new array; your tools are untouched.
      *
      * The appended `get_more_tools` descriptor carries only the base MCP tool fields
      * (name, description, input schema) — not any framework-specific fields your
@@ -111,8 +123,12 @@ export declare class PostHogMCP extends PostHog {
      *
      * @example
      * ```ts
+     * const originalTool = myTools.find((tool) => tool.name === name)
      * const { intent, intentSource, llmModel, llmModelSource, args, isMissingCapability } =
-     *   posthog.prepareToolCall(name, rawArgs, { requestMeta: request.params?._meta })
+     *   posthog.prepareToolCall(name, rawArgs, {
+     *     originalTool,
+     *     requestMeta: request.params?._meta,
+     *   })
      * if (isMissingCapability) {
      *   posthog.captureMissingCapability({ context: intent, llmModel, llmModelSource, ...identity })
      *   return getMoreToolsResult()
@@ -128,5 +144,13 @@ export declare class PostHogMCP extends PostHog {
      * to the agent with `getMoreToolsResult()`.
      */
     captureMissingCapability(data: MissingCapabilityCaptureData): void;
+    /**
+     * Capture a `send_feedback` call as an agent-feedback report. Emits
+     * `$mcp_feedback` with the report's `$mcp_feedback_*` properties and its
+     * summary/details as `$mcp_intent`. Reply to the agent with
+     * `sendFeedbackResult()` (or a custom text) after routing the report to your
+     * own feedback backend.
+     */
+    captureFeedback(data: FeedbackCaptureData): void;
 }
 //# sourceMappingURL=posthog-mcp.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"posthog-mcp.d.ts","sourceRoot":"","sources":["../../src/extensions/posthog-mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAA;AAE3D,OAAO,KAAK,EACV,qBAAqB,EAErB,mBAAmB,EAGnB,4BAA4B,EAC5B,gBAAgB,EAChB,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,UAAU,CAAA;AAEjB,OAAO,EAIL,KAAK,qBAAqB,EAC3B,MAAM,sBAAsB,CAAA;AAgB7B;;;GAGG;AACH,MAAM,WAAW,iBAAkB,SAAQ,cAAc;IACvD;;;;;OAKG;IACH,yBAAyB,CAAC,EAAE,MAAM,CAAA;IAClC;;;OAGG;IACH,YAAY,CAAC,EAAE,mBAAmB,CAAC,cAAc,CAAC,CAAA;CACnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,qBAAa,UAAW,SAAQ,OAAO;;gBASzB,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB;IAO3D,8FAA8F;IAC9F,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,IAAI;IAkBhD,iEAAiE;IACjE,iBAAiB,CAAC,IAAI,EAAE,qBAAqB,GAAG,IAAI;IAUpD;;;;;OAKG;IACH,gBAAgB,CAAC,IAAI,EAAE,oBAAoB,GAAG,IAAI;IAclD;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,eAAe,CAAC,KAAK,SAAS,qBAAqB,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,OAAO,GAAE,sBAA2B,GAAG,KAAK,EAAE;IAiCnH;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,eAAe,CACb,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,GAAE,sBAA2B,GACnC,gBAAgB;IA4BnB;;;;OAIG;IACH,wBAAwB,CAAC,IAAI,EAAE,4BAA4B,GAAG,IAAI;CAmBnE"}
+{"version":3,"file":"posthog-mcp.d.ts","sourceRoot":"","sources":["../../src/extensions/posthog-mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAA;AAE3D,OAAO,KAAK,EACV,mBAAmB,EAEnB,qBAAqB,EACrB,qBAAqB,EAErB,mBAAmB,EAGnB,4BAA4B,EAC5B,gBAAgB,EAChB,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,UAAU,CAAA;AAUjB,OAAO,EAIL,KAAK,qBAAqB,EAC3B,MAAM,sBAAsB,CAAA;AAgB7B;;;GAGG;AACH,MAAM,WAAW,iBAAkB,SAAQ,cAAc;IACvD;;;;;OAKG;IACH,yBAAyB,CAAC,EAAE,MAAM,CAAA;IAClC;;;;;;;;;OASG;IACH,eAAe,CAAC,EAAE,qBAAqB,CAAA;IACvC;;;OAGG;IACH,YAAY,CAAC,EAAE,mBAAmB,CAAC,cAAc,CAAC,CAAA;CACnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,qBAAa,UAAW,SAAQ,OAAO;;gBAazB,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB;IAoB3D,8FAA8F;IAC9F,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,IAAI;IAkBhD,iEAAiE;IACjE,iBAAiB,CAAC,IAAI,EAAE,qBAAqB,GAAG,IAAI;IAUpD;;;;;OAKG;IACH,gBAAgB,CAAC,IAAI,EAAE,oBAAoB,GAAG,IAAI;IAclD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,eAAe,CAAC,KAAK,SAAS,qBAAqB,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,OAAO,GAAE,sBAA2B,GAAG,KAAK,EAAE;IAyCnH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,eAAe,CACb,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,GAAE,sBAA2B,GACnC,gBAAgB;IAqCnB;;;;OAIG;IACH,wBAAwB,CAAC,IAAI,EAAE,4BAA4B,GAAG,IAAI;IASlE;;;;;;OAMG;IACH,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,IAAI;CAuBjD"}

package/dist/extensions/posthog-mcp.js

@@ -31,6 +31,7 @@ __webpack_require__.d(__webpack_exports__, {
     PostHogMCP: ()=>PostHogMCP
 });
 const external_posthog_node_namespaceObject = require("posthog-node");
+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_event_types_js_namespaceObject = require("./event-types.js");
@@ -44,14 +45,21 @@ const external_tools_js_namespaceObject = require("./tools.js");
 class PostHogMCP extends external_posthog_node_namespaceObject.PostHog {
     #sink;
     #missingCapabilityToolName;
+    #feedbackOptions;
     #captureModel;
     #modelParameterOwnership;
     constructor(apiKey, options = {}){
         super(apiKey, options), this.#sink = new external_sink_js_namespaceObject.McpEventSink(this), this.#modelParameterOwnership = new Map();
         this.#missingCapabilityToolName = options.missingCapabilityToolName ?? external_tools_js_namespaceObject.GET_MORE_TOOLS_NAME;
+        this.#feedbackOptions = (0, external_feedback_js_namespaceObject.resolveCollectFeedbackOptions)(options.collectFeedback);
+        (0, external_feedback_js_namespaceObject.getFeedbackToolDescriptor)(this.#feedbackOptions);
+        if (this.#feedbackOptions?.onFeedback) (0, external_logger_js_namespaceObject.log)('Warning: collectFeedback.onFeedback is ignored on the PostHogMCP path - route reports from your dispatcher via prepareToolCall().feedbackReport instead.');
         this.#captureModel = options.captureModel;
         (0, external_lib_identity_js_namespaceObject.applyMcpLibIdentity)(this);
     }
+    get #feedbackToolName() {
+        return this.#feedbackOptions?.toolName ?? external_feedback_js_namespaceObject.SEND_FEEDBACK_TOOL_NAME;
+    }
     captureToolCall(data) {
         const event = baseEvent(external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpToolsCall, data);
         event.resourceName = data.toolName;
@@ -96,6 +104,10 @@ class PostHogMCP extends external_posthog_node_namespaceObject.PostHog {
             ...prepared,
             (0, external_tools_js_namespaceObject.getReportMissingToolDescriptor)(this.#missingCapabilityToolName)
         ];
+        if (options.collectFeedback && void 0 !== this.#feedbackOptions && !prepared.some((tool)=>tool?.name === this.#feedbackToolName)) prepared = [
+            ...prepared,
+            (0, external_feedback_js_namespaceObject.getFeedbackToolDescriptor)(this.#feedbackOptions)
+        ];
         if ((0, external_model_parameters_js_namespaceObject.isCaptureModelEnabled)(this.#captureModel)) {
             this.#modelParameterOwnership.clear();
             const ownershipByName = new Map();
@@ -121,6 +133,7 @@ class PostHogMCP extends external_posthog_node_namespaceObject.PostHog {
             }
         }, ownsModel) : void 0;
         const strippedArgs = stripContext(args);
+        const isFeedback = void 0 !== this.#feedbackOptions && name === this.#feedbackToolName && null == options.originalTool;
         return {
             intent,
             intentSource: intent ? 'context_parameter' : void 0,
@@ -131,7 +144,9 @@ class PostHogMCP extends external_posthog_node_namespaceObject.PostHog {
                 conversationId: false,
                 llmModel: true
             }) : strippedArgs,
-            isMissingCapability: name === this.#missingCapabilityToolName
+            isMissingCapability: name === this.#missingCapabilityToolName,
+            isFeedback,
+            feedbackReport: isFeedback ? (0, external_feedback_js_namespaceObject.parseFeedbackReport)(args, this.#feedbackOptions) : void 0
         };
     }
     captureMissingCapability(data) {
@@ -142,6 +157,17 @@ class PostHogMCP extends external_posthog_node_namespaceObject.PostHog {
         (0, external_model_parameters_js_namespaceObject.setEventModel)(event, data.llmModel, data.llmModelSource);
         this.#emit(event);
     }
+    captureFeedback(data) {
+        const event = baseEvent(external_event_types_js_namespaceObject.MCPAnalyticsEventType.mcpFeedback, data);
+        event.resourceName = this.#feedbackToolName;
+        event.properties = {
+            ...event.properties,
+            ...(0, external_feedback_js_namespaceObject.buildFeedbackEventProperties)(data.report)
+        };
+        applyIntent(event, (0, external_feedback_js_namespaceObject.buildFeedbackIntent)(data.report), 'context_parameter');
+        (0, external_model_parameters_js_namespaceObject.setEventModel)(event, data.llmModel, data.llmModelSource);
+        this.#emit(event);
+    }
     #emit(event) {
         this.#sink.capture(event, {
             enableExceptionAutocapture: this.options.enableExceptionAutocapture ?? true

package/dist/extensions/posthog-mcp.mjs

@@ -1,4 +1,5 @@
 import { PostHog } from "posthog-node";
+import { SEND_FEEDBACK_TOOL_NAME, buildFeedbackEventProperties, buildFeedbackIntent, getFeedbackToolDescriptor, parseFeedbackReport, resolveCollectFeedbackOptions } from "./feedback.mjs";
 import { analyticsOwnsParameter, stripOwnedAnalyticsArguments } from "./analytics-parameters.mjs";
 import { addContextParameterToTools, getContextDescription, isContextEnabled } from "./context-parameters.mjs";
 import { MCPAnalyticsEventType } from "./event-types.mjs";
@@ -12,14 +13,21 @@ import { GET_MORE_TOOLS_NAME, getReportMissingToolDescriptor } from "./tools.mjs
 class PostHogMCP extends PostHog {
     #sink;
     #missingCapabilityToolName;
+    #feedbackOptions;
     #captureModel;
     #modelParameterOwnership;
     constructor(apiKey, options = {}){
         super(apiKey, options), this.#sink = new McpEventSink(this), this.#modelParameterOwnership = new Map();
         this.#missingCapabilityToolName = options.missingCapabilityToolName ?? GET_MORE_TOOLS_NAME;
+        this.#feedbackOptions = resolveCollectFeedbackOptions(options.collectFeedback);
+        getFeedbackToolDescriptor(this.#feedbackOptions);
+        if (this.#feedbackOptions?.onFeedback) log('Warning: collectFeedback.onFeedback is ignored on the PostHogMCP path - route reports from your dispatcher via prepareToolCall().feedbackReport instead.');
         this.#captureModel = options.captureModel;
         applyMcpLibIdentity(this);
     }
+    get #feedbackToolName() {
+        return this.#feedbackOptions?.toolName ?? SEND_FEEDBACK_TOOL_NAME;
+    }
     captureToolCall(data) {
         const event = baseEvent(MCPAnalyticsEventType.mcpToolsCall, data);
         event.resourceName = data.toolName;
@@ -64,6 +72,10 @@ class PostHogMCP extends PostHog {
             ...prepared,
             getReportMissingToolDescriptor(this.#missingCapabilityToolName)
         ];
+        if (options.collectFeedback && void 0 !== this.#feedbackOptions && !prepared.some((tool)=>tool?.name === this.#feedbackToolName)) prepared = [
+            ...prepared,
+            getFeedbackToolDescriptor(this.#feedbackOptions)
+        ];
         if (isCaptureModelEnabled(this.#captureModel)) {
             this.#modelParameterOwnership.clear();
             const ownershipByName = new Map();
@@ -89,6 +101,7 @@ class PostHogMCP extends PostHog {
             }
         }, ownsModel) : void 0;
         const strippedArgs = stripContext(args);
+        const isFeedback = void 0 !== this.#feedbackOptions && name === this.#feedbackToolName && null == options.originalTool;
         return {
             intent,
             intentSource: intent ? 'context_parameter' : void 0,
@@ -99,7 +112,9 @@ class PostHogMCP extends PostHog {
                 conversationId: false,
                 llmModel: true
             }) : strippedArgs,
-            isMissingCapability: name === this.#missingCapabilityToolName
+            isMissingCapability: name === this.#missingCapabilityToolName,
+            isFeedback,
+            feedbackReport: isFeedback ? parseFeedbackReport(args, this.#feedbackOptions) : void 0
         };
     }
     captureMissingCapability(data) {
@@ -110,6 +125,17 @@ class PostHogMCP extends PostHog {
         setEventModel(event, data.llmModel, data.llmModelSource);
         this.#emit(event);
     }
+    captureFeedback(data) {
+        const event = baseEvent(MCPAnalyticsEventType.mcpFeedback, data);
+        event.resourceName = this.#feedbackToolName;
+        event.properties = {
+            ...event.properties,
+            ...buildFeedbackEventProperties(data.report)
+        };
+        applyIntent(event, buildFeedbackIntent(data.report), 'context_parameter');
+        setEventModel(event, data.llmModel, data.llmModelSource);
+        this.#emit(event);
+    }
     #emit(event) {
         this.#sink.capture(event, {
             enableExceptionAutocapture: this.options.enableExceptionAutocapture ?? true

package/dist/extensions/sanitization.js

@@ -41,7 +41,7 @@ function sanitizeEvent(event) {
     if (null != result.response) result.response = sanitizeResponse(result.response);
     if (null != result.parameters) result.parameters = sanitizeParameters(result.parameters);
     if (null != result.resourceName) result.resourceName = (0, external_mcp_payloads_js_namespaceObject.sanitizeCapturedValue)(result.resourceName);
-    if (null != result.userIntent) result.userIntent = (0, external_mcp_payloads_js_namespaceObject.sanitizeIntent)(result.userIntent);
+    if (null != result.userIntent) result.userIntent = (0, external_mcp_payloads_js_namespaceObject.sanitizeFreeText)(result.userIntent);
     if (null != result.llmModel) result.llmModel = (0, external_mcp_payloads_js_namespaceObject.sanitizeCapturedValue)(result.llmModel);
     if (null != result.error) result.error = sanitizeExceptionValues(result.error);
     return result;

package/dist/extensions/sanitization.mjs

@@ -1,4 +1,4 @@
-import { sanitizeCapturedValue, sanitizeIntent } from "./mcp-payloads.mjs";
+import { sanitizeCapturedValue, sanitizeFreeText } from "./mcp-payloads.mjs";
 function isRecord(value) {
     return !!value && 'object' == typeof value && !Array.isArray(value);
 }
@@ -9,7 +9,7 @@ function sanitizeEvent(event) {
     if (null != result.response) result.response = sanitizeResponse(result.response);
     if (null != result.parameters) result.parameters = sanitizeParameters(result.parameters);
     if (null != result.resourceName) result.resourceName = sanitizeCapturedValue(result.resourceName);
-    if (null != result.userIntent) result.userIntent = sanitizeIntent(result.userIntent);
+    if (null != result.userIntent) result.userIntent = sanitizeFreeText(result.userIntent);
     if (null != result.llmModel) result.llmModel = sanitizeCapturedValue(result.llmModel);
     if (null != result.error) result.error = sanitizeExceptionValues(result.error);
     return result;

package/dist/index.d.ts

@@ -53,9 +53,10 @@ export { POSTHOG_MCP_ANALYTICS_SOURCE, PostHogMCPAnalyticsEvent, PostHogMCPAnaly
 export { getRequestHeaders } from './extensions/request-headers';
 export { PostHogMCP, type PostHogMCPOptions } from './extensions/posthog-mcp';
 export { getMoreToolsResult } from './extensions/tools';
+export { sendFeedbackResult, SEND_FEEDBACK_TOOL_NAME } from './extensions/feedback';
 export { setLogger } from './extensions/logger';
 export { PostHog, type PostHogOptions } from 'posthog-node';
-export type { BeforeSendFn, CaptureEventData, InitializeCaptureData, McpAnalytics, McpCaptureCommon, MCPAnalyticsContextOptions, MCPAnalyticsIntentSource, MCPAnalyticsModelOptions, MCPAnalyticsModelSource, MCPAnalyticsOptions, MissingCapabilityCaptureData, PreparedToolCall, PrepareToolCallOptions, PrepareToolListOptions, RequestHeaderBag, ToolCallCaptureData, ToolsListCaptureData, UserIdentity, } from './types';
+export type { FeedbackCaptureData, FeedbackExtraPropertySchema, CollectFeedbackOptions, FeedbackReport, FeedbackSentiment, FeedbackType, BeforeSendFn, CaptureEventData, CollectFeedbackConfig, InitializeCaptureData, McpAnalytics, McpCaptureCommon, MCPAnalyticsContextOptions, MCPAnalyticsIntentSource, MCPAnalyticsModelOptions, MCPAnalyticsModelSource, MCPAnalyticsOptions, MissingCapabilityCaptureData, PreparedToolCall, PrepareToolCallOptions, PrepareToolListOptions, RequestHeaderBag, ToolCallCaptureData, ToolsListCaptureData, UserIdentity, } from './types';
 export type IdentifyFunction = MCPAnalyticsOptions['identify'];
 export { instrument, instrumentMutator };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAQ3C,OAAO,EAAE,6BAA6B,EAAkB,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAGlG,OAAO,KAAK,EAGV,YAAY,EAEZ,mBAAmB,EAGpB,MAAM,SAAS,CAAA;AAEhB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,iBAAS,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAE,mBAAwB,GAAG,YAAY,CAiCtG;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,iBAAS,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAKjH;AAuFD,OAAO,EAAE,6BAA6B,EAAE,YAAY,EAAE,CAAA;AAItD,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,eAAe,EACf,KAAK,mBAAmB,GACzB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EACL,4BAA4B,EAC5B,wBAAwB,EACxB,2BAA2B,GAC5B,MAAM,wBAAwB,CAAA;AAG/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAA;AAChE,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAC7E,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAI/C,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAA;AAC3D,YAAY,EACV,YAAY,EACZ,gBAAgB,EAChB,qBAAqB,EACrB,YAAY,EACZ,gBAAgB,EAChB,0BAA0B,EAC1B,wBAAwB,EACxB,wBAAwB,EACxB,uBAAuB,EACvB,mBAAmB,EACnB,4BAA4B,EAC5B,gBAAgB,EAChB,sBAAsB,EACtB,sBAAsB,EACtB,gBAAgB,EAChB,mBAAmB,EACnB,oBAAoB,EACpB,YAAY,GACb,MAAM,SAAS,CAAA;AAChB,MAAM,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,UAAU,CAAC,CAAA;AAC9D,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAQ3C,OAAO,EAAE,6BAA6B,EAAkB,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAIlG,OAAO,KAAK,EAGV,YAAY,EAEZ,mBAAmB,EAGpB,MAAM,SAAS,CAAA;AAEhB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,iBAAS,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAE,mBAAwB,GAAG,YAAY,CA4CtG;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,iBAAS,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAKjH;AAwFD,OAAO,EAAE,6BAA6B,EAAE,YAAY,EAAE,CAAA;AAItD,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,eAAe,EACf,KAAK,mBAAmB,GACzB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EACL,4BAA4B,EAC5B,wBAAwB,EACxB,2BAA2B,GAC5B,MAAM,wBAAwB,CAAA;AAG/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAA;AAChE,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAC7E,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AACvD,OAAO,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AACnF,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAI/C,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAA;AAC3D,YAAY,EACV,mBAAmB,EACnB,2BAA2B,EAC3B,sBAAsB,EACtB,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,qBAAqB,EACrB,qBAAqB,EACrB,YAAY,EACZ,gBAAgB,EAChB,0BAA0B,EAC1B,wBAAwB,EACxB,wBAAwB,EACxB,uBAAuB,EACvB,mBAAmB,EACnB,4BAA4B,EAC5B,gBAAgB,EAChB,sBAAsB,EACtB,sBAAsB,EACtB,gBAAgB,EAChB,mBAAmB,EACnB,oBAAoB,EACpB,YAAY,GACb,MAAM,SAAS,CAAA;AAChB,MAAM,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,UAAU,CAAC,CAAA;AAC9D,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAAA"}

package/dist/index.js

@@ -34,6 +34,7 @@ __webpack_require__.d(__webpack_exports__, {
     PostHogMCP: ()=>posthog_mcp_js_namespaceObject.PostHogMCP,
     PostHogMCPAnalyticsEvent: ()=>constants_js_namespaceObject.PostHogMCPAnalyticsEvent,
     PostHogMCPAnalyticsProperty: ()=>constants_js_namespaceObject.PostHogMCPAnalyticsProperty,
+    SEND_FEEDBACK_TOOL_NAME: ()=>feedback_js_namespaceObject.SEND_FEEDBACK_TOOL_NAME,
     decodeSessionId: ()=>session_token_js_namespaceObject.decodeSessionId,
     deriveSessionIdFromMCPSession: ()=>session_js_namespaceObject.deriveSessionIdFromMCPSession,
     encodeSessionId: ()=>session_token_js_namespaceObject.encodeSessionId,
@@ -42,6 +43,7 @@ __webpack_require__.d(__webpack_exports__, {
     instrument: ()=>instrument,
     instrumentMutator: ()=>instrumentMutator,
     newSessionId: ()=>session_js_namespaceObject.newSessionId,
+    sendFeedbackResult: ()=>feedback_js_namespaceObject.sendFeedbackResult,
     setLogger: ()=>logger_js_namespaceObject.setLogger
 });
 const compatibility_js_namespaceObject = require("./extensions/compatibility.js");
@@ -54,6 +56,7 @@ const lib_identity_js_namespaceObject = require("./extensions/lib-identity.js");
 const session_js_namespaceObject = require("./extensions/session.js");
 const instrument_lowlevel_js_namespaceObject = require("./extensions/instrument-lowlevel.js");
 const instrument_highlevel_js_namespaceObject = require("./extensions/instrument-highlevel.js");
+const feedback_js_namespaceObject = require("./extensions/feedback.js");
 const session_token_js_namespaceObject = require("./extensions/session-token.js");
 const constants_js_namespaceObject = require("./extensions/constants.js");
 const request_headers_js_namespaceObject = require("./extensions/request-headers.js");
@@ -62,6 +65,8 @@ const tools_js_namespaceObject = require("./extensions/tools.js");
 const external_posthog_node_namespaceObject = require("posthog-node");
 function instrument(server, posthog, options = {}) {
     const logger = (0, logger_js_namespaceObject.createLogger)(options?.logger);
+    const feedbackOptions = (0, feedback_js_namespaceObject.resolveCollectFeedbackOptions)(options?.collectFeedback);
+    if (feedbackOptions) (0, feedback_js_namespaceObject.getFeedbackToolDescriptor)(feedbackOptions);
     try {
         if (!posthog) logger('Warning: No PostHog client passed to instrument(). Events will not be sent anywhere.');
         const validatedServer = (0, compatibility_js_namespaceObject.isCompatibleServerType)(server, logger);
@@ -100,6 +105,7 @@ function getLowLevelServer(server) {
 }
 const DEFAULT_OPTIONS = {
     reportMissing: false,
+    collectFeedback: false,
     enableConversationId: false
 };
 function buildTrackingData(lowLevelServer, options, sink, logger) {
@@ -152,6 +158,7 @@ exports.PostHog = __webpack_exports__.PostHog;
 exports.PostHogMCP = __webpack_exports__.PostHogMCP;
 exports.PostHogMCPAnalyticsEvent = __webpack_exports__.PostHogMCPAnalyticsEvent;
 exports.PostHogMCPAnalyticsProperty = __webpack_exports__.PostHogMCPAnalyticsProperty;
+exports.SEND_FEEDBACK_TOOL_NAME = __webpack_exports__.SEND_FEEDBACK_TOOL_NAME;
 exports.decodeSessionId = __webpack_exports__.decodeSessionId;
 exports.deriveSessionIdFromMCPSession = __webpack_exports__.deriveSessionIdFromMCPSession;
 exports.encodeSessionId = __webpack_exports__.encodeSessionId;
@@ -160,6 +167,7 @@ exports.getRequestHeaders = __webpack_exports__.getRequestHeaders;
 exports.instrument = __webpack_exports__.instrument;
 exports.instrumentMutator = __webpack_exports__.instrumentMutator;
 exports.newSessionId = __webpack_exports__.newSessionId;
+exports.sendFeedbackResult = __webpack_exports__.sendFeedbackResult;
 exports.setLogger = __webpack_exports__.setLogger;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "MCP_SESSION_HEADER",
@@ -168,6 +176,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "PostHogMCP",
     "PostHogMCPAnalyticsEvent",
     "PostHogMCPAnalyticsProperty",
+    "SEND_FEEDBACK_TOOL_NAME",
     "decodeSessionId",
     "deriveSessionIdFromMCPSession",
     "encodeSessionId",
@@ -176,6 +185,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "instrument",
     "instrumentMutator",
     "newSessionId",
+    "sendFeedbackResult",
     "setLogger"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/index.mjs

@@ -8,8 +8,11 @@ import { applyMcpLibIdentity } from "./extensions/lib-identity.mjs";
 import { deriveSessionIdFromMCPSession, getSessionInfo, newSessionId } from "./extensions/session.mjs";
 import { instrumentLowLevelServer } from "./extensions/instrument-lowlevel.mjs";
 import { instrumentHighLevelServer } from "./extensions/instrument-highlevel.mjs";
+import { SEND_FEEDBACK_TOOL_NAME, getFeedbackToolDescriptor, resolveCollectFeedbackOptions, sendFeedbackResult } from "./extensions/feedback.mjs";
 function instrument(server, posthog, options = {}) {
     const logger = createLogger(options?.logger);
+    const feedbackOptions = resolveCollectFeedbackOptions(options?.collectFeedback);
+    if (feedbackOptions) getFeedbackToolDescriptor(feedbackOptions);
     try {
         if (!posthog) logger('Warning: No PostHog client passed to instrument(). Events will not be sent anywhere.');
         const validatedServer = isCompatibleServerType(server, logger);
@@ -48,6 +51,7 @@ function getLowLevelServer(server) {
 }
 const DEFAULT_OPTIONS = {
     reportMissing: false,
+    collectFeedback: false,
     enableConversationId: false
 };
 function buildTrackingData(lowLevelServer, options, sink, logger) {
@@ -100,4 +104,4 @@ export { getRequestHeaders } from "./extensions/request-headers.mjs";
 export { PostHogMCP } from "./extensions/posthog-mcp.mjs";
 export { getMoreToolsResult } from "./extensions/tools.mjs";
 export { PostHog } from "posthog-node";
-export { deriveSessionIdFromMCPSession, instrument, instrumentMutator, newSessionId, setLogger };
+export { SEND_FEEDBACK_TOOL_NAME, deriveSessionIdFromMCPSession, instrument, instrumentMutator, newSessionId, sendFeedbackResult, setLogger };