@posthog/mcp 0.11.7 → 0.13.0

package/dist/extensions/model-parameters.d.ts

@@ -0,0 +1,48 @@
+import type { MCPAnalyticsOptions, MCPRequestLike, McpEvent } from '../types';
+import { type AnalyticsInjectableJsonSchema } from './analytics-parameters';
+import { type LoggerFn } from './logger';
+/**
+ * Self-reported model capture (`captureModel`).
+ *
+ * MCP keeps servers deliberately model-ignorant: the wire carries client
+ * name/version and protocol version, never the LLM behind the client, and no
+ * spec revision changes that. The one place the information exists on the
+ * server side of the connection is the agent itself — harnesses inject the
+ * model id into the system prompt, so the agent can state it the same way it
+ * states its intent through the `context` parameter.
+ *
+ * This module injects a required `llm_model` string parameter into every tool
+ * (mirroring `context-parameters.ts`), strips it before the tool runs, and
+ * captures it as `$mcp_llm_model` with `$mcp_llm_model_source = "self_reported"`.
+ * The source property is deliberate: like `clientInfo` in the MCP spec, the
+ * value is self-reported and unverified — right for degradation analytics
+ * ("does our MCP get worse on model X?"), never for billing or security.
+ *
+ * Reasoning effort is deliberately NOT captured: it never crosses the wire,
+ * and models cannot reliably self-report it (harnesses apply it as a sampling
+ * parameter the model never sees), so any captured value would be noise.
+ */
+export interface ModelInjectableTool {
+    inputSchema?: AnalyticsInjectableJsonSchema;
+    name?: string;
+    [key: string]: unknown;
+}
+/** Unlike `context`, model capture is opt-in: off unless explicitly enabled. */
+export declare function isCaptureModelEnabled(captureModel: MCPAnalyticsOptions['captureModel']): boolean;
+export declare function getModelDescription(captureModel: MCPAnalyticsOptions['captureModel']): string | undefined;
+/**
+ * Adds an `llm_model` parameter to a tool's JSON Schema, via the shared
+ * injector so schema handling stays identical to `context`: a tool that already
+ * declares `llm_model` owns it, and complex schemas can't safely gain keys.
+ */
+export declare function addModelParameterToTool<TTool extends ModelInjectableTool>(tool: TTool, modelDescriptionOverride?: string, logger?: LoggerFn): TTool;
+export declare function addModelParameterToTools<TTool extends ModelInjectableTool>(tools: TTool[], modelDescriptionOverride?: string, logger?: LoggerFn): TTool[];
+/**
+ * Reads the self-reported model off a tool-call request. Returns `undefined`
+ * for a missing, blank, or `"unknown"` value — the parameter description asks
+ * agents to pass `unknown` when uncertain, and an honest "I don't know" must
+ * not become a property value queries would group by.
+ */
+export declare function getModelArgument(request: MCPRequestLike): string | undefined;
+export declare function setEventModel(event: McpEvent, model: string | undefined): void;
+//# sourceMappingURL=model-parameters.d.ts.map

package/dist/extensions/model-parameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-parameters.d.ts","sourceRoot":"","sources":["../../src/extensions/model-parameters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAC7E,OAAO,EAA+B,KAAK,6BAA6B,EAAE,MAAM,wBAAwB,CAAA;AAExG,OAAO,EAAO,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAA;AAE7C;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,mBAAmB;IAClC,WAAW,CAAC,EAAE,6BAA6B,CAAA;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAED,gFAAgF;AAChF,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,mBAAmB,CAAC,cAAc,CAAC,GAAG,OAAO,CAEhG;AAED,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,mBAAmB,CAAC,cAAc,CAAC,GAAG,MAAM,GAAG,SAAS,CAEzG;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,SAAS,mBAAmB,EACvE,IAAI,EAAE,KAAK,EACX,wBAAwB,CAAC,EAAE,MAAM,EACjC,MAAM,GAAE,QAAc,GACrB,KAAK,CAQP;AAED,wBAAgB,wBAAwB,CAAC,KAAK,SAAS,mBAAmB,EACxE,KAAK,EAAE,KAAK,EAAE,EACd,wBAAwB,CAAC,EAAE,MAAM,EACjC,MAAM,GAAE,QAAc,GACrB,KAAK,EAAE,CAET;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM,GAAG,SAAS,CAE5E;AAaD,wBAAgB,aAAa,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAO9E"}

package/dist/extensions/model-parameters.js

@@ -0,0 +1,84 @@
+"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__, {
+    addModelParameterToTool: ()=>addModelParameterToTool,
+    addModelParameterToTools: ()=>addModelParameterToTools,
+    getModelArgument: ()=>getModelArgument,
+    getModelDescription: ()=>getModelDescription,
+    isCaptureModelEnabled: ()=>isCaptureModelEnabled,
+    setEventModel: ()=>setEventModel
+});
+const external_analytics_parameters_js_namespaceObject = require("./analytics-parameters.js");
+const external_constants_js_namespaceObject = require("./constants.js");
+const external_logger_js_namespaceObject = require("./logger.js");
+function isCaptureModelEnabled(captureModel) {
+    return true === captureModel || 'object' == typeof captureModel && null !== captureModel;
+}
+function getModelDescription(captureModel) {
+    return 'object' == typeof captureModel && null !== captureModel ? captureModel.description : void 0;
+}
+function addModelParameterToTool(tool, modelDescriptionOverride, logger = external_logger_js_namespaceObject.log) {
+    return (0, external_analytics_parameters_js_namespaceObject.addAnalyticsParameterToTool)(tool, 'llm_model', modelDescriptionOverride || external_constants_js_namespaceObject.DEFAULT_MODEL_PARAMETER_DESCRIPTION, 'model', logger);
+}
+function addModelParameterToTools(tools, modelDescriptionOverride, logger = external_logger_js_namespaceObject.log) {
+    return tools.map((tool)=>addModelParameterToTool(tool, modelDescriptionOverride, logger));
+}
+function getModelArgument(request) {
+    return normalizeModel(request.params?.arguments?.llm_model);
+}
+function normalizeModel(model) {
+    if ('string' != typeof model) return;
+    const trimmed = model.trim();
+    if (!trimmed || 'unknown' === trimmed.toLowerCase()) return;
+    return trimmed;
+}
+function setEventModel(event, model) {
+    const normalizedModel = normalizeModel(model);
+    if (!normalizedModel) return;
+    event.llmModel = normalizedModel;
+    event.llmModelSource = 'self_reported';
+}
+exports.addModelParameterToTool = __webpack_exports__.addModelParameterToTool;
+exports.addModelParameterToTools = __webpack_exports__.addModelParameterToTools;
+exports.getModelArgument = __webpack_exports__.getModelArgument;
+exports.getModelDescription = __webpack_exports__.getModelDescription;
+exports.isCaptureModelEnabled = __webpack_exports__.isCaptureModelEnabled;
+exports.setEventModel = __webpack_exports__.setEventModel;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "addModelParameterToTool",
+    "addModelParameterToTools",
+    "getModelArgument",
+    "getModelDescription",
+    "isCaptureModelEnabled",
+    "setEventModel"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/model-parameters.mjs

@@ -0,0 +1,31 @@
+import { addAnalyticsParameterToTool } from "./analytics-parameters.mjs";
+import { DEFAULT_MODEL_PARAMETER_DESCRIPTION } from "./constants.mjs";
+import { log } from "./logger.mjs";
+function isCaptureModelEnabled(captureModel) {
+    return true === captureModel || 'object' == typeof captureModel && null !== captureModel;
+}
+function getModelDescription(captureModel) {
+    return 'object' == typeof captureModel && null !== captureModel ? captureModel.description : void 0;
+}
+function addModelParameterToTool(tool, modelDescriptionOverride, logger = log) {
+    return addAnalyticsParameterToTool(tool, 'llm_model', modelDescriptionOverride || DEFAULT_MODEL_PARAMETER_DESCRIPTION, 'model', logger);
+}
+function addModelParameterToTools(tools, modelDescriptionOverride, logger = log) {
+    return tools.map((tool)=>addModelParameterToTool(tool, modelDescriptionOverride, logger));
+}
+function getModelArgument(request) {
+    return normalizeModel(request.params?.arguments?.llm_model);
+}
+function normalizeModel(model) {
+    if ('string' != typeof model) return;
+    const trimmed = model.trim();
+    if (!trimmed || 'unknown' === trimmed.toLowerCase()) return;
+    return trimmed;
+}
+function setEventModel(event, model) {
+    const normalizedModel = normalizeModel(model);
+    if (!normalizedModel) return;
+    event.llmModel = normalizedModel;
+    event.llmModelSource = 'self_reported';
+}
+export { addModelParameterToTool, addModelParameterToTools, getModelArgument, getModelDescription, isCaptureModelEnabled, setEventModel };

package/dist/extensions/output-instructions.js

@@ -1,11 +1,15 @@
 "use strict";
 var __webpack_require__ = {};
 (()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
+    __webpack_require__.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");
     };
 })();
 (()=>{
@@ -13,7 +17,7 @@ var __webpack_require__ = {};
 })();
 (()=>{
     __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
             value: 'Module'
         });
         Object.defineProperty(exports1, '__esModule', {
@@ -24,12 +28,12 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    mirrorInstructionsIntoStructuredContent: ()=>mirrorInstructionsIntoStructuredContent,
+    MCP_INSTRUCTIONS_KEY: ()=>MCP_INSTRUCTIONS_KEY,
     addInstructionsToOutputSchema: ()=>addInstructionsToOutputSchema,
     addInstructionsToOutputSchemas: ()=>addInstructionsToOutputSchemas,
-    MCP_INSTRUCTIONS_KEY: ()=>MCP_INSTRUCTIONS_KEY,
     buildConversationInstructions: ()=>buildConversationInstructions,
-    canDeclareOutputInstructions: ()=>canDeclareOutputInstructions
+    canDeclareOutputInstructions: ()=>canDeclareOutputInstructions,
+    mirrorInstructionsIntoStructuredContent: ()=>mirrorInstructionsIntoStructuredContent
 });
 const external_logger_js_namespaceObject = require("./logger.js");
 const MCP_INSTRUCTIONS_KEY = '_mcp_instructions';
@@ -113,14 +117,14 @@ exports.addInstructionsToOutputSchemas = __webpack_exports__.addInstructionsToOu
 exports.buildConversationInstructions = __webpack_exports__.buildConversationInstructions;
 exports.canDeclareOutputInstructions = __webpack_exports__.canDeclareOutputInstructions;
 exports.mirrorInstructionsIntoStructuredContent = __webpack_exports__.mirrorInstructionsIntoStructuredContent;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+for(var __rspack_i in __webpack_exports__)if (-1 === [
     "MCP_INSTRUCTIONS_KEY",
     "addInstructionsToOutputSchema",
     "addInstructionsToOutputSchemas",
     "buildConversationInstructions",
     "canDeclareOutputInstructions",
     "mirrorInstructionsIntoStructuredContent"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true
 });

package/dist/extensions/posthog-events.js

@@ -1,11 +1,15 @@
 "use strict";
 var __webpack_require__ = {};
 (()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
+    __webpack_require__.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");
     };
 })();
 (()=>{
@@ -13,7 +17,7 @@ var __webpack_require__ = {};
 })();
 (()=>{
     __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
             value: 'Module'
         });
         Object.defineProperty(exports1, '__esModule', {
@@ -103,6 +107,8 @@ function addCommonEventProperties(event, properties) {
     if (event.protocolVersion) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.ProtocolVersion] = event.protocolVersion;
     if (event.userIntent) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.Intent] = event.userIntent;
     if (event.userIntentSource) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.IntentSource] = event.userIntentSource;
+    if (event.llmModel) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.LlmModel] = event.llmModel;
+    if (event.llmModelSource) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.LlmModelSource] = event.llmModelSource;
     if (void 0 !== event.isError) properties[external_constants_js_namespaceObject.PostHogMCPAnalyticsProperty.IsError] = event.isError;
     if (event.isError) {
         const firstException = event.error?.$exception_list?.[0];
@@ -151,9 +157,9 @@ function buildExceptionEvent(event) {
     };
 }
 exports.buildPostHogCaptureEvents = __webpack_exports__.buildPostHogCaptureEvents;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+for(var __rspack_i in __webpack_exports__)if (-1 === [
     "buildPostHogCaptureEvents"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true
 });

package/dist/extensions/posthog-events.mjs

@@ -75,6 +75,8 @@ function addCommonEventProperties(event, properties) {
     if (event.protocolVersion) properties[PostHogMCPAnalyticsProperty.ProtocolVersion] = event.protocolVersion;
     if (event.userIntent) properties[PostHogMCPAnalyticsProperty.Intent] = event.userIntent;
     if (event.userIntentSource) properties[PostHogMCPAnalyticsProperty.IntentSource] = event.userIntentSource;
+    if (event.llmModel) properties[PostHogMCPAnalyticsProperty.LlmModel] = event.llmModel;
+    if (event.llmModelSource) properties[PostHogMCPAnalyticsProperty.LlmModelSource] = event.llmModelSource;
     if (void 0 !== event.isError) properties[PostHogMCPAnalyticsProperty.IsError] = event.isError;
     if (event.isError) {
         const firstException = event.error?.$exception_list?.[0];

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

@@ -1,5 +1,5 @@
 import { PostHog, type PostHogOptions } from 'posthog-node';
-import type { InitializeCaptureData, MissingCapabilityCaptureData, PreparedToolCall, PrepareToolListOptions, ToolCallCaptureData, ToolsListCaptureData } from '../types';
+import type { 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,11 @@ export interface PostHogMCPOptions extends PostHogOptions {
      * can't drift. Defaults to `get_more_tools`.
      */
     missingCapabilityToolName?: string;
+    /**
+     * Inject a required `llm_model` argument into advertised tools and capture
+     * the agent's self-reported value. Off by default.
+     */
+    captureModel?: MCPAnalyticsOptions['captureModel'];
 }
 /**
  * A `posthog-node` client with first-class MCP analytics. Use this when there is
@@ -32,7 +37,10 @@ export interface PostHogMCPOptions extends PostHogOptions {
  * ```ts
  * import { PostHogMCP } from "@posthog/mcp"
  *
- * const posthog = new PostHogMCP("phc_your_project_token", { host: "https://us.i.posthog.com" })
+ * const posthog = new PostHogMCP("phc_your_project_token", {
+ *   host: "https://us.i.posthog.com",
+ *   captureModel: true,
+ * })
  *
  * posthog.captureToolCall({
  *   toolName: "search_docs",
@@ -64,9 +72,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`) and, when `reportMissing` is on, appends the
-     * `get_more_tools` virtual tool (rename it via the `missingCapabilityToolName`
-     * constructor option). Returns a new array; your tools are untouched.
+     * 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.
      *
      * The appended `get_more_tools` descriptor carries only the base MCP tool fields
      * (name, description, input schema) — not any framework-specific fields your
@@ -85,14 +93,16 @@ export declare class PostHogMCP extends PostHog {
      */
     prepareToolList<TTool extends ContextInjectableTool>(tools: TTool[], options?: PrepareToolListOptions): TTool[];
     /**
-     * Read an incoming `tools/call` before you dispatch it: pulls the agent's
-     * intent off the injected `context` argument, strips `context` from the
-     * arguments (so your handler and its schema validation never see it), and flags
+     * Read an incoming `tools/call` before you dispatch it: pulls analytics values
+     * from SDK-owned arguments, strips those arguments before validation, and flags
      * whether the call targeted the `get_more_tools` virtual tool.
      *
-     * Pass the returned `intent` / `intentSource` to {@link captureToolCall}, and
+     * Pass the returned intent and model fields to {@link captureToolCall}, and
      * dispatch the returned `args` to your tool.
      *
+     * On stateless or multi-replica servers, pass the original tool descriptor
+     * so ownership does not depend on which process served `tools/list`.
+     *
      * This only extracts the explicit `context` argument (`intentSource:
      * 'context_parameter'`); it does not infer intent. If you run your own
      * inference, pass that string with `intentSource: 'inferred'` straight to
@@ -101,16 +111,17 @@ export declare class PostHogMCP extends PostHog {
      *
      * @example
      * ```ts
-     * const { intent, intentSource, args, isMissingCapability } = posthog.prepareToolCall(name, rawArgs)
+     * const { intent, intentSource, llmModel, llmModelSource, args, isMissingCapability } =
+     *   posthog.prepareToolCall(name, rawArgs)
      * if (isMissingCapability) {
-     *   posthog.captureMissingCapability({ context: intent, ...identity })
+     *   posthog.captureMissingCapability({ context: intent, llmModel, llmModelSource, ...identity })
      *   return getMoreToolsResult()
      * }
      * const result = await runTool(name, args)
      * posthog.captureToolCall({ toolName: name, intent, intentSource, ...identity })
      * ```
      */
-    prepareToolCall(name: string, args?: Record<string, unknown>): PreparedToolCall;
+    prepareToolCall(name: string, args?: Record<string, unknown>, options?: PrepareToolCallOptions): PreparedToolCall;
     /**
      * Capture a `get_more_tools` call as a missing-capability report. Emits
      * `$mcp_missing_capability` with the agent's description as `$mcp_intent`. Reply

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,EAIrB,4BAA4B,EAC5B,gBAAgB,EAChB,sBAAsB,EACtB,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,UAAU,CAAA;AACjB,OAAO,EAIL,KAAK,qBAAqB,EAC3B,MAAM,sBAAsB,CAAA;AAS7B;;;GAGG;AACH,MAAM,WAAW,iBAAkB,SAAQ,cAAc;IACvD;;;;;OAKG;IACH,yBAAyB,CAAC,EAAE,MAAM,CAAA;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qBAAa,UAAW,SAAQ,OAAO;;gBAOzB,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB;IAM3D,8FAA8F;IAC9F,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,IAAI;IAiBhD,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;IAYnH;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,gBAAgB;IAW/E;;;;OAIG;IACH,wBAAwB,CAAC,IAAI,EAAE,4BAA4B,GAAG,IAAI;CAkBnE"}
+{"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;IAqBhD,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;IA0BnB;;;;OAIG;IACH,wBAAwB,CAAC,IAAI,EAAE,4BAA4B,GAAG,IAAI;CAsBnE"}

package/dist/extensions/posthog-mcp.js

@@ -1,11 +1,15 @@
 "use strict";
 var __webpack_require__ = {};
 (()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
+    __webpack_require__.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");
     };
 })();
 (()=>{
@@ -13,7 +17,7 @@ var __webpack_require__ = {};
 })();
 (()=>{
     __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
             value: 'Module'
         });
         Object.defineProperty(exports1, '__esModule', {
@@ -27,20 +31,25 @@ __webpack_require__.d(__webpack_exports__, {
     PostHogMCP: ()=>PostHogMCP
 });
 const external_posthog_node_namespaceObject = require("posthog-node");
+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");
 const external_exceptions_js_namespaceObject = require("./exceptions.js");
 const external_headers_js_namespaceObject = require("./headers.js");
 const external_lib_identity_js_namespaceObject = require("./lib-identity.js");
 const external_logger_js_namespaceObject = require("./logger.js");
+const external_model_parameters_js_namespaceObject = require("./model-parameters.js");
 const external_sink_js_namespaceObject = require("./sink.js");
 const external_tools_js_namespaceObject = require("./tools.js");
 class PostHogMCP extends external_posthog_node_namespaceObject.PostHog {
     #sink;
     #missingCapabilityToolName;
+    #captureModel;
+    #modelParameterOwnership;
     constructor(apiKey, options = {}){
-        super(apiKey, options), this.#sink = new external_sink_js_namespaceObject.McpEventSink(this);
+        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.#captureModel = options.captureModel;
         (0, external_lib_identity_js_namespaceObject.applyMcpLibIdentity)(this);
     }
     captureToolCall(data) {
@@ -54,6 +63,8 @@ class PostHogMCP extends external_posthog_node_namespaceObject.PostHog {
         event.isError = data.isError;
         event.errorType = data.errorType;
         applyIntent(event, data.intent, data.intentSource);
+        (0, external_model_parameters_js_namespaceObject.setEventModel)(event, data.llmModel);
+        if (event.llmModel && data.llmModelSource) event.llmModelSource = data.llmModelSource;
         if (data.isError) event.error = (0, external_exceptions_js_namespaceObject.captureException)(data.error ?? `Tool ${data.toolName} returned an error`);
         this.#emit(event);
     }
@@ -86,15 +97,40 @@ class PostHogMCP extends external_posthog_node_namespaceObject.PostHog {
             ...prepared,
             (0, external_tools_js_namespaceObject.getReportMissingToolDescriptor)(this.#missingCapabilityToolName)
         ];
+        if ((0, external_model_parameters_js_namespaceObject.isCaptureModelEnabled)(this.#captureModel)) {
+            this.#modelParameterOwnership.clear();
+            const ownershipByName = new Map();
+            for (const tool of prepared){
+                if ('string' != typeof tool.name) continue;
+                const ownsModel = (0, external_analytics_parameters_js_namespaceObject.analyticsOwnsParameter)(tool.inputSchema, 'llm_model');
+                ownershipByName.set(tool.name, (ownershipByName.get(tool.name) ?? true) && ownsModel);
+            }
+            for (const [toolName, ownsModel] of ownershipByName)this.#modelParameterOwnership.set(toolName, ownsModel);
+            const modelDescription = (0, external_model_parameters_js_namespaceObject.getModelDescription)(this.#captureModel);
+            prepared = prepared.map((tool)=>'string' == typeof tool.name && false === ownershipByName.get(tool.name) ? tool : (0, external_model_parameters_js_namespaceObject.addModelParameterToTool)(tool, modelDescription));
+        }
         return prepared;
     }
-    prepareToolCall(name, args) {
+    prepareToolCall(name, args, options = {}) {
         const rawContext = args?.context;
         const intent = 'string' == typeof rawContext && rawContext.trim() ? rawContext.trim() : void 0;
+        const ownsModel = (0, external_model_parameters_js_namespaceObject.isCaptureModelEnabled)(this.#captureModel) && (options.originalTool ? (0, external_analytics_parameters_js_namespaceObject.analyticsOwnsParameter)(options.originalTool.inputSchema, 'llm_model') : true === this.#modelParameterOwnership.get(name));
+        const llmModel = ownsModel ? (0, external_model_parameters_js_namespaceObject.getModelArgument)({
+            params: {
+                arguments: args
+            }
+        }) : void 0;
+        const strippedArgs = stripContext(args);
         return {
             intent,
             intentSource: intent ? 'context_parameter' : void 0,
-            args: stripContext(args),
+            llmModel,
+            llmModelSource: llmModel ? 'self_reported' : void 0,
+            args: ownsModel ? (0, external_analytics_parameters_js_namespaceObject.stripOwnedAnalyticsArguments)(strippedArgs, {
+                context: false,
+                conversationId: false,
+                llmModel: true
+            }) : strippedArgs,
             isMissingCapability: name === this.#missingCapabilityToolName
         };
     }
@@ -103,6 +139,8 @@ class PostHogMCP extends external_posthog_node_namespaceObject.PostHog {
         event.resourceName = this.#missingCapabilityToolName;
         event.parameters = data.parameters;
         applyIntent(event, data.context, 'context_parameter');
+        (0, external_model_parameters_js_namespaceObject.setEventModel)(event, data.llmModel);
+        if (event.llmModel && data.llmModelSource) event.llmModelSource = data.llmModelSource;
         this.#emit(event);
     }
     #emit(event) {
@@ -138,9 +176,9 @@ function stripContext(args) {
     return rest;
 }
 exports.PostHogMCP = __webpack_exports__.PostHogMCP;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+for(var __rspack_i in __webpack_exports__)if (-1 === [
     "PostHogMCP"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true
 });

package/dist/extensions/posthog-mcp.mjs

@@ -1,18 +1,23 @@
 import { PostHog } from "posthog-node";
+import { analyticsOwnsParameter, stripOwnedAnalyticsArguments } from "./analytics-parameters.mjs";
 import { addContextParameterToTools, getContextDescription, isContextEnabled } from "./context-parameters.mjs";
 import { MCPAnalyticsEventType } from "./event-types.mjs";
 import { captureException } from "./exceptions.mjs";
 import { normalizeHeaderString } from "./headers.mjs";
 import { applyMcpLibIdentity } from "./lib-identity.mjs";
 import { log } from "./logger.mjs";
+import { addModelParameterToTool, getModelArgument, getModelDescription, isCaptureModelEnabled, setEventModel } from "./model-parameters.mjs";
 import { McpEventSink } from "./sink.mjs";
 import { GET_MORE_TOOLS_NAME, getReportMissingToolDescriptor } from "./tools.mjs";
 class PostHogMCP extends PostHog {
     #sink;
     #missingCapabilityToolName;
+    #captureModel;
+    #modelParameterOwnership;
     constructor(apiKey, options = {}){
-        super(apiKey, options), this.#sink = new McpEventSink(this);
+        super(apiKey, options), this.#sink = new McpEventSink(this), this.#modelParameterOwnership = new Map();
         this.#missingCapabilityToolName = options.missingCapabilityToolName ?? GET_MORE_TOOLS_NAME;
+        this.#captureModel = options.captureModel;
         applyMcpLibIdentity(this);
     }
     captureToolCall(data) {
@@ -26,6 +31,8 @@ class PostHogMCP extends PostHog {
         event.isError = data.isError;
         event.errorType = data.errorType;
         applyIntent(event, data.intent, data.intentSource);
+        setEventModel(event, data.llmModel);
+        if (event.llmModel && data.llmModelSource) event.llmModelSource = data.llmModelSource;
         if (data.isError) event.error = captureException(data.error ?? `Tool ${data.toolName} returned an error`);
         this.#emit(event);
     }
@@ -58,15 +65,40 @@ class PostHogMCP extends PostHog {
             ...prepared,
             getReportMissingToolDescriptor(this.#missingCapabilityToolName)
         ];
+        if (isCaptureModelEnabled(this.#captureModel)) {
+            this.#modelParameterOwnership.clear();
+            const ownershipByName = new Map();
+            for (const tool of prepared){
+                if ('string' != typeof tool.name) continue;
+                const ownsModel = analyticsOwnsParameter(tool.inputSchema, 'llm_model');
+                ownershipByName.set(tool.name, (ownershipByName.get(tool.name) ?? true) && ownsModel);
+            }
+            for (const [toolName, ownsModel] of ownershipByName)this.#modelParameterOwnership.set(toolName, ownsModel);
+            const modelDescription = getModelDescription(this.#captureModel);
+            prepared = prepared.map((tool)=>'string' == typeof tool.name && false === ownershipByName.get(tool.name) ? tool : addModelParameterToTool(tool, modelDescription));
+        }
         return prepared;
     }
-    prepareToolCall(name, args) {
+    prepareToolCall(name, args, options = {}) {
         const rawContext = args?.context;
         const intent = 'string' == typeof rawContext && rawContext.trim() ? rawContext.trim() : void 0;
+        const ownsModel = isCaptureModelEnabled(this.#captureModel) && (options.originalTool ? analyticsOwnsParameter(options.originalTool.inputSchema, 'llm_model') : true === this.#modelParameterOwnership.get(name));
+        const llmModel = ownsModel ? getModelArgument({
+            params: {
+                arguments: args
+            }
+        }) : void 0;
+        const strippedArgs = stripContext(args);
         return {
             intent,
             intentSource: intent ? 'context_parameter' : void 0,
-            args: stripContext(args),
+            llmModel,
+            llmModelSource: llmModel ? 'self_reported' : void 0,
+            args: ownsModel ? stripOwnedAnalyticsArguments(strippedArgs, {
+                context: false,
+                conversationId: false,
+                llmModel: true
+            }) : strippedArgs,
             isMissingCapability: name === this.#missingCapabilityToolName
         };
     }
@@ -75,6 +107,8 @@ class PostHogMCP extends PostHog {
         event.resourceName = this.#missingCapabilityToolName;
         event.parameters = data.parameters;
         applyIntent(event, data.context, 'context_parameter');
+        setEventModel(event, data.llmModel);
+        if (event.llmModel && data.llmModelSource) event.llmModelSource = data.llmModelSource;
         this.#emit(event);
     }
     #emit(event) {