@posthog/mcp 0.14.1 → 0.16.0

package/LICENSE

@@ -217,6 +217,70 @@ limitations under the License.
    limitations under the License.
 
 
+---
+
+The @posthog/core package in packages/core is licensed under the MIT License below.
+Third-party code remains subject to its respective notices in this file.
+This owning notice is preserved from posthog-js-lite, from which @posthog/core was migrated:
+https://github.com/PostHog/posthog-js-lite/blob/5fb7bee96f739b243dfea5589e2027f16629e8cd/LICENSE
+
+MIT License
+
+Copyright (c) 2022 PostHog (part of Hiberly Inc)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+packages/core/src/error-tracking/parsers/index.ts and its compiled distributions contain code
+derived from TraceKit. This license only applies to the relevant code.
+
+MIT License
+
+Copyright (c) 2013 Onur Can Cakmak onur.cakmak@gmail.com and all TraceKit contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files(the 'Software'), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify,
+merge, publish, distribute, sublicense, and / or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be included in all copies
+or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---
+
+packages/core/src/vendor/uuidv7.ts and its compiled distributions contain code from uuidv7:
+https://github.com/LiosK/uuidv7/blob/f30b7a7faff73afbce0b27a46c638310f96912ba/src/index.ts
+
+Copyright 2021-2023 LiosK
+
+This code is licensed under the Apache License, Version 2.0, reproduced above.
+
 ---
 
 Some files in this codebase contain code from getsentry/sentry-javascript.

package/README.md

@@ -213,6 +213,70 @@ A persistent single-process dispatcher can omit `originalTool` after it has prep
 Pass `requestMeta` whenever the request supplies `_meta`; this enables recognized client metadata
 without changing the arguments sent to the tool.
 
+### Collecting agent feedback (`send_feedback`)
+
+`collectFeedback` is **off** by default. Turn it on and the SDK advertises a `send_feedback` virtual
+tool: an honest, general feedback channel from the agent to your team. The tool description makes
+missing capabilities the priority category ("report a missing capability whenever no available tool
+fits your task, even if you can work around it") and also invites reports about a tool that failed
+or confused the agent, and praise. Every call emits one `$mcp_feedback` event — never a
+`$mcp_tool_call` — with `$mcp_feedback_type`, `$mcp_feedback_summary`, and the other
+`$mcp_feedback_*` properties; the summary and details double as `$mcp_intent`. The agent receives an
+acknowledgement that says exactly what happened: the report was recorded, no tools were added.
+
+```ts
+instrument(server, posthog, {
+  collectFeedback: {
+    // All fields optional; `collectFeedback: true` uses the defaults.
+    toolName: 'send_feedback',
+    extraProperties: {
+      product_area: { type: 'string', description: 'The product or feature the feedback is about.' },
+    },
+    extraRequired: ['product_area'],
+    onFeedback: async (report) => {
+      await myFeedbackBackend.record(report) // report.extras.product_area, report.raw, ...
+      return 'Thanks - your feedback reached the team.' // replaces the default acknowledgement
+    },
+  },
+})
+```
+
+Host-declared `extraProperties` are merged into the advertised schema and captured as
+`$mcp_feedback_<key>` (sanitized and bounded like every captured value). Arguments the agent invents
+beyond the schema are never captured — they reach `onFeedback` via `report.raw` only. A key that
+collides with a core field fails at configuration time. Free-text fields go through the same PII
+redaction as `$mcp_intent`.
+
+`onFeedback`'s returned string replaces the acknowledgement and is captured as `$mcp_response`
+through the generic sanitize pipeline only — it does not get the structured-PII redaction applied to
+`$mcp_feedback_summary`/`details`, so don't echo the agent's raw report text back in it.
+
+On the custom-dispatcher path, configure the tool on the `PostHogMCP` constructor and route reports
+yourself (`onFeedback` does not apply there):
+
+```ts
+const posthog = new PostHogMCP(process.env.POSTHOG_PROJECT_TOKEN, {
+  collectFeedback: { toolName: 'send_feedback' },
+})
+
+// tools/list handler
+return { tools: posthog.prepareToolList(myTools, { collectFeedback: true }) }
+
+// tools/call dispatcher
+const prepared = posthog.prepareToolCall(name, rawArgs)
+if (prepared.isFeedback) {
+  posthog.captureFeedback({ report: prepared.feedbackReport!, ...identity })
+  await myFeedbackBackend.record(prepared.feedbackReport!)
+  return sendFeedbackResult() // or a custom text reply
+}
+```
+
+`send_feedback` covers what `reportMissing` covers — a capability gap is
+`feedback_type: "missing_capability"` — so new integrations should enable only `collectFeedback`.
+`reportMissing` and its `$mcp_missing_capability` event stay unchanged for existing users; enabling
+both advertises both tools. Like `get_more_tools`, a real tool that already uses the configured name
+wins: the SDK warns, skips injection, and delegates calls to the real handler.
+
 ### If you switched to `instrument(server.server)`
 
 Before v2 support landed, the compatibility gate rejected high-level v2 servers, and the usual

package/dist/extensions/constants.d.ts

@@ -7,6 +7,7 @@ export declare const POSTHOG_MCP_LIB_NAME = "posthog-node-mcp";
 export declare const PostHogMCPAnalyticsEvent: {
     readonly Custom: "$mcp_custom";
     readonly Exception: "$exception";
+    readonly Feedback: "$mcp_feedback";
     readonly Identify: "$identify";
     readonly Initialize: "$mcp_initialize";
     readonly MissingCapability: "$mcp_missing_capability";
@@ -26,6 +27,14 @@ export declare const PostHogMCPAnalyticsProperty: {
     readonly DurationMs: "$mcp_duration_ms";
     readonly ErrorMessage: "$mcp_error_message";
     readonly ErrorType: "$mcp_error_type";
+    readonly FeedbackDetails: "$mcp_feedback_details";
+    readonly FeedbackFrictionPoints: "$mcp_feedback_friction_points";
+    readonly FeedbackSentiment: "$mcp_feedback_sentiment";
+    readonly FeedbackSuggestedImprovement: "$mcp_feedback_suggested_improvement";
+    readonly FeedbackSummary: "$mcp_feedback_summary";
+    readonly FeedbackTaskCompleted: "$mcp_feedback_task_completed";
+    readonly FeedbackTool: "$mcp_feedback_tool";
+    readonly FeedbackType: "$mcp_feedback_type";
     readonly IsError: "$mcp_is_error";
     readonly Intent: "$mcp_intent";
     readonly IntentSource: "$mcp_intent_source";

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

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/extensions/constants.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,6BAA6B,KAAK,CAAA;AAE/C,eAAO,MAAM,qCAAqC,onBAA4mB,CAAA;AAE9pB,eAAO,MAAM,mCAAmC,gRAAqQ,CAAA;AAErT,eAAO,MAAM,mCAAmC,4LACsI,CAAA;AAEtL,eAAO,MAAM,4BAA4B,0BAA0B,CAAA;AAMnE,eAAO,MAAM,oBAAoB,qBAAqB,CAAA;AAItD,eAAO,MAAM,wBAAwB;;;;;;;;;;;;CAY3B,CAAA;AAEV,MAAM,MAAM,wBAAwB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,OAAO,wBAAwB,CAAC,CAAA;AAE/G,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;CA0B9B,CAAA;AAEV,MAAM,MAAM,2BAA2B,GAAG,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,OAAO,2BAA2B,CAAC,CAAA"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/extensions/constants.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,6BAA6B,KAAK,CAAA;AAE/C,eAAO,MAAM,qCAAqC,onBAA4mB,CAAA;AAE9pB,eAAO,MAAM,mCAAmC,gRAAqQ,CAAA;AAErT,eAAO,MAAM,mCAAmC,4LACsI,CAAA;AAEtL,eAAO,MAAM,4BAA4B,0BAA0B,CAAA;AAMnE,eAAO,MAAM,oBAAoB,qBAAqB,CAAA;AAItD,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;CAa3B,CAAA;AAEV,MAAM,MAAM,wBAAwB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,OAAO,wBAAwB,CAAC,CAAA;AAE/G,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkC9B,CAAA;AAEV,MAAM,MAAM,2BAA2B,GAAG,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,OAAO,2BAA2B,CAAC,CAAA"}

package/dist/extensions/constants.js

@@ -36,6 +36,7 @@ const POSTHOG_MCP_LIB_NAME = 'posthog-node-mcp';
 const PostHogMCPAnalyticsEvent = {
     Custom: '$mcp_custom',
     Exception: '$exception',
+    Feedback: '$mcp_feedback',
     Identify: '$identify',
     Initialize: '$mcp_initialize',
     MissingCapability: '$mcp_missing_capability',
@@ -54,6 +55,14 @@ const PostHogMCPAnalyticsProperty = {
     DurationMs: '$mcp_duration_ms',
     ErrorMessage: '$mcp_error_message',
     ErrorType: '$mcp_error_type',
+    FeedbackDetails: '$mcp_feedback_details',
+    FeedbackFrictionPoints: '$mcp_feedback_friction_points',
+    FeedbackSentiment: '$mcp_feedback_sentiment',
+    FeedbackSuggestedImprovement: '$mcp_feedback_suggested_improvement',
+    FeedbackSummary: '$mcp_feedback_summary',
+    FeedbackTaskCompleted: '$mcp_feedback_task_completed',
+    FeedbackTool: '$mcp_feedback_tool',
+    FeedbackType: '$mcp_feedback_type',
     IsError: '$mcp_is_error',
     Intent: '$mcp_intent',
     IntentSource: '$mcp_intent_source',

package/dist/extensions/constants.mjs

@@ -7,6 +7,7 @@ const POSTHOG_MCP_LIB_NAME = 'posthog-node-mcp';
 const PostHogMCPAnalyticsEvent = {
     Custom: '$mcp_custom',
     Exception: '$exception',
+    Feedback: '$mcp_feedback',
     Identify: '$identify',
     Initialize: '$mcp_initialize',
     MissingCapability: '$mcp_missing_capability',
@@ -25,6 +26,14 @@ const PostHogMCPAnalyticsProperty = {
     DurationMs: '$mcp_duration_ms',
     ErrorMessage: '$mcp_error_message',
     ErrorType: '$mcp_error_type',
+    FeedbackDetails: '$mcp_feedback_details',
+    FeedbackFrictionPoints: '$mcp_feedback_friction_points',
+    FeedbackSentiment: '$mcp_feedback_sentiment',
+    FeedbackSuggestedImprovement: '$mcp_feedback_suggested_improvement',
+    FeedbackSummary: '$mcp_feedback_summary',
+    FeedbackTaskCompleted: '$mcp_feedback_task_completed',
+    FeedbackTool: '$mcp_feedback_tool',
+    FeedbackType: '$mcp_feedback_type',
     IsError: '$mcp_is_error',
     Intent: '$mcp_intent',
     IntentSource: '$mcp_intent_source',

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

@@ -8,6 +8,7 @@
 export declare const MCPAnalyticsEventType: {
     readonly identify: "posthog:identify";
     readonly custom: "posthog:custom";
+    readonly mcpFeedback: "mcp:feedback";
     readonly mcpMissingCapability: "mcp:missing_capability";
     readonly mcpInitialize: "mcp:initialize";
     readonly mcpPromptsGet: "mcp:prompts/get";

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

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

package/dist/extensions/event-types.js

@@ -30,6 +30,7 @@ __webpack_require__.r(__webpack_exports__);
 const MCPAnalyticsEventType = {
     identify: 'posthog:identify',
     custom: 'posthog:custom',
+    mcpFeedback: 'mcp:feedback',
     mcpMissingCapability: 'mcp:missing_capability',
     mcpInitialize: 'mcp:initialize',
     mcpPromptsGet: 'mcp:prompts/get',

package/dist/extensions/event-types.mjs

@@ -1,6 +1,7 @@
 const MCPAnalyticsEventType = {
     identify: 'posthog:identify',
     custom: 'posthog:custom',
+    mcpFeedback: 'mcp:feedback',
     mcpMissingCapability: 'mcp:missing_capability',
     mcpInitialize: 'mcp:initialize',
     mcpPromptsGet: 'mcp:prompts/get',

package/dist/extensions/feedback.d.ts

@@ -0,0 +1,41 @@
+import type { CollectFeedbackOptions, FeedbackReport, CollectFeedbackConfig, CompatibleTextToolResult, CompatibleToolsListLike, JsonRecord } from '../types';
+import { type LoggerFn } from './logger';
+export declare const SEND_FEEDBACK_TOOL_NAME: "send_feedback";
+type FeedbackToolDescriptor = CompatibleToolsListLike['tools'][number];
+/** `collectFeedback` normalized to its object form; `undefined` when the feature is off. */
+export declare function resolveCollectFeedbackOptions(config: CollectFeedbackConfig | undefined): CollectFeedbackOptions | undefined;
+/**
+ * The advertised descriptor: the core feedback schema plus the host's declared
+ * `extraProperties`. Throws on a config error (a reserved extra key, or an
+ * `extraRequired` entry that was never declared) so a bad setup fails at
+ * configuration time instead of silently corrupting the advertised schema.
+ */
+export declare function getFeedbackToolDescriptor(options?: CollectFeedbackOptions): FeedbackToolDescriptor;
+/**
+ * Parses the raw `send_feedback` arguments into a typed report. Never throws:
+ * an invalid `feedback_type` falls back to `other`, missing fields stay
+ * undefined, and only **declared** extras whose values match their declared
+ * `type`/`enum` are lifted into `extras` — mismatches and anything the agent
+ * invented reach the handler via `raw` only and are never captured.
+ */
+export declare function parseFeedbackReport(args: Record<string, unknown> | undefined, options?: CollectFeedbackOptions): FeedbackReport;
+/** The report's free text, used as the event's `$mcp_intent`. */
+export declare function buildFeedbackIntent(report: FeedbackReport): string;
+/** The `$mcp_feedback_*` event properties for one report, declared extras included. */
+export declare function buildFeedbackEventProperties(report: FeedbackReport): JsonRecord;
+/**
+ * The default acknowledgement returned to the agent after it calls
+ * `send_feedback`. Reply with this from your dispatcher (custom dispatcher
+ * path); the `instrument()` path returns it automatically, or the string your
+ * `onFeedback` handler returned instead.
+ */
+export declare function sendFeedbackResult(): CompatibleTextToolResult;
+/**
+ * Runs the host's `onFeedback` handler (when configured) and builds the reply.
+ * A returned non-blank string replaces the default acknowledgement; a thrown
+ * handler is logged and falls back to it — feedback capture must never break
+ * the agent's turn.
+ */
+export declare function handleFeedback(report: FeedbackReport, options?: CollectFeedbackOptions, logger?: LoggerFn): Promise<CompatibleTextToolResult>;
+export {};
+//# sourceMappingURL=feedback.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feedback.d.ts","sourceRoot":"","sources":["../../src/extensions/feedback.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EAEtB,cAAc,EAGd,qBAAqB,EACrB,wBAAwB,EACxB,uBAAuB,EACvB,UAAU,EACX,MAAM,UAAU,CAAA;AAEjB,OAAO,EAAO,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAA;AAG7C,eAAO,MAAM,uBAAuB,EAAG,eAAwB,CAAA;AAsF/D,KAAK,sBAAsB,GAAG,uBAAuB,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAA;AAEtE,4FAA4F;AAC5F,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,qBAAqB,GAAG,SAAS,GACxC,sBAAsB,GAAG,SAAS,CAKpC;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,GAAE,sBAA2B,GAAG,sBAAsB,CA6CtG;AA4BD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EACzC,OAAO,GAAE,sBAA2B,GACnC,cAAc,CAoBhB;AAED,iEAAiE;AACjE,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CAElE;AAuCD,uFAAuF;AACvF,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,cAAc,GAAG,UAAU,CAqC/E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,IAAI,wBAAwB,CAS7D;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,cAAc,EACtB,OAAO,GAAE,sBAA2B,EACpC,MAAM,GAAE,QAAc,GACrB,OAAO,CAAC,wBAAwB,CAAC,CAenC"}

package/dist/extensions/feedback.js

@@ -0,0 +1,259 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    SEND_FEEDBACK_TOOL_NAME: ()=>SEND_FEEDBACK_TOOL_NAME,
+    buildFeedbackEventProperties: ()=>buildFeedbackEventProperties,
+    buildFeedbackIntent: ()=>buildFeedbackIntent,
+    getFeedbackToolDescriptor: ()=>getFeedbackToolDescriptor,
+    handleFeedback: ()=>handleFeedback,
+    parseFeedbackReport: ()=>parseFeedbackReport,
+    resolveCollectFeedbackOptions: ()=>resolveCollectFeedbackOptions,
+    sendFeedbackResult: ()=>sendFeedbackResult
+});
+const external_constants_js_namespaceObject = require("./constants.js");
+const external_logger_js_namespaceObject = require("./logger.js");
+const external_mcp_payloads_js_namespaceObject = require("./mcp-payloads.js");
+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((0, external_mcp_payloads_js_namespaceObject.sanitizeFreeText)(value), MAX_FEEDBACK_TEXT_LENGTH);
+}
+function captureExtraValue(value) {
+    const sanitized = (0, external_mcp_payloads_js_namespaceObject.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 = {
+        [external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.FeedbackType]: report.feedbackType
+    };
+    if (report.summary) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.FeedbackSummary] = captureFreeText(report.summary);
+    if (report.sentiment) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.FeedbackSentiment] = report.sentiment;
+    if (report.frictionPoints) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.FeedbackFrictionPoints] = captureFreeText(report.frictionPoints);
+    if (report.suggestedImprovement) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.FeedbackSuggestedImprovement] = captureFreeText(report.suggestedImprovement);
+    if (report.details) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.FeedbackDetails] = captureFreeText(report.details);
+    if (report.toolName) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.FeedbackTool] = truncateFeedbackText((0, external_mcp_payloads_js_namespaceObject.sanitizeFreeText)(report.toolName), MAX_FEEDBACK_TOOL_NAME_LENGTH);
+    if (void 0 !== report.taskCompleted) properties[external_constants_js_namespaceObject.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 = external_logger_js_namespaceObject.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();
+}
+exports.SEND_FEEDBACK_TOOL_NAME = __webpack_exports__.SEND_FEEDBACK_TOOL_NAME;
+exports.buildFeedbackEventProperties = __webpack_exports__.buildFeedbackEventProperties;
+exports.buildFeedbackIntent = __webpack_exports__.buildFeedbackIntent;
+exports.getFeedbackToolDescriptor = __webpack_exports__.getFeedbackToolDescriptor;
+exports.handleFeedback = __webpack_exports__.handleFeedback;
+exports.parseFeedbackReport = __webpack_exports__.parseFeedbackReport;
+exports.resolveCollectFeedbackOptions = __webpack_exports__.resolveCollectFeedbackOptions;
+exports.sendFeedbackResult = __webpack_exports__.sendFeedbackResult;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "SEND_FEEDBACK_TOOL_NAME",
+    "buildFeedbackEventProperties",
+    "buildFeedbackIntent",
+    "getFeedbackToolDescriptor",
+    "handleFeedback",
+    "parseFeedbackReport",
+    "resolveCollectFeedbackOptions",
+    "sendFeedbackResult"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});