@posthog/mcp 0.16.4 → 0.18.0

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

@@ -1,5 +1,5 @@
 import { PostHog, type PostHogOptions } from 'posthog-node';
-import type { FeedbackCaptureData, CollectFeedbackConfig, InitializeCaptureData, MCPAnalyticsOptions, MissingCapabilityCaptureData, PreparedToolCall, PrepareToolCallOptions, PrepareToolListOptions, ToolCallCaptureData, ToolsListCaptureData } from '../types';
+import type { FeedbackCaptureData, CollectFeedbackConfig, InitializeCaptureData, MCPAnalyticsOptions, MissingCapabilityCaptureData, PreparedToolCall, PreparedToolResult, PrepareToolCallOptions, PrepareToolListOptions, ToolCallCaptureData, ToolsListCaptureData } from '../types';
 import { type ContextInjectableTool } from './context-parameters';
 /**
  * Options for {@link PostHogMCP}. A superset of `posthog-node`'s options, plus
@@ -26,9 +26,15 @@ export interface PostHogMCPOptions extends PostHogOptions {
     collectFeedback?: CollectFeedbackConfig;
     /**
      * Capture the calling model from recognized client metadata, with an injected
-     * `llm_model` argument as fallback. Off by default.
+     * `llm_model` argument as fallback. On by default; `false` disables it.
      */
     captureModel?: MCPAnalyticsOptions['captureModel'];
+    /**
+     * Correlate calls with an agent-carried `conversation_id` and a derived
+     * PostHog session id. On by default; `false` leaves schemas, arguments, tool
+     * results, and capture data unchanged.
+     */
+    enableConversationId?: boolean;
 }
 /**
  * A `posthog-node` client with first-class MCP analytics. Use this when there is
@@ -84,9 +90,10 @@ 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, appends `get_more_tools` when
-     * `reportMissing` is on, and appends `send_feedback` when `collectFeedback` is
-     * on. Returns a new array; your tools are untouched.
+     * `captureModel` option is enabled, and injects the optional `conversation_id`
+     * handle by default. It appends `get_more_tools` when `reportMissing` is on and
+     * `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
@@ -94,8 +101,9 @@ export declare class PostHogMCP extends PostHog {
      * {@link prepareToolCall}'s `isMissingCapability`, not dispatched through a handler.
      *
      * Call this when there is no `Server` to wrap — it does for a custom dispatcher
-     * what `instrument()` does for a `Server`. Pair it with {@link prepareToolCall}
-     * on the inbound side.
+     * what `instrument()` does for a `Server`. Pair it with
+     * {@link prepareToolCall} on the inbound side and {@link prepareToolResult} on
+     * the outbound side.
      *
      * @example
      * ```ts
@@ -109,8 +117,10 @@ export declare class PostHogMCP extends PostHog {
      * 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 and model fields to {@link captureToolCall}, and
-     * dispatch the returned `args` to your tool.
+     * Dispatch the returned `args` to your tool. Then pass the tool result and
+     * this prepared call to {@link prepareToolResult}. Use its result as the MCP
+     * response and its session and conversation values with
+     * {@link captureToolCall}.
      *
      * On stateless or multi-replica servers, pass the original tool descriptor
      * so ownership does not depend on which process served `tools/list`.
@@ -124,24 +134,49 @@ 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, {
+     * const preparedCall = posthog.prepareToolCall(name, rawArgs, {
      *     originalTool,
      *     requestMeta: request.params?._meta,
      *   })
-     * if (isMissingCapability) {
-     *   posthog.captureMissingCapability({ context: intent, llmModel, llmModelSource, ...identity })
-     *   return getMoreToolsResult()
+     * if (preparedCall.isMissingCapability) {
+     *   const preparedResult = posthog.prepareToolResult(getMoreToolsResult(), preparedCall)
+     *   posthog.captureMissingCapability({
+     *     context: preparedCall.intent,
+     *     sessionId: preparedResult.sessionId,
+     *     conversationId: preparedResult.conversationId,
+     *     ...identity,
+     *   })
+     *   return preparedResult.result
      * }
-     * const result = await runTool(name, args)
-     * posthog.captureToolCall({ toolName: name, intent, intentSource, ...identity })
+     * const toolResult = await runTool(name, preparedCall.args)
+     * const preparedResult = posthog.prepareToolResult(toolResult, preparedCall)
+     * posthog.captureToolCall({
+     *   toolName: name,
+     *   intent: preparedCall.intent,
+     *   sessionId: preparedResult.sessionId,
+     *   conversationId: preparedResult.conversationId,
+     *   ...identity,
+     * })
+     * return preparedResult.result
      * ```
      */
     prepareToolCall(name: string, args?: Record<string, unknown>, options?: PrepareToolCallOptions): PreparedToolCall;
+    /**
+     * Add the conversation handle to a tool result without changing the original
+     * value. A new handle is appended to text content once. When the advertised
+     * output schema supports it, the handle is also mirrored into
+     * `structuredContent`.
+     *
+     * Use the returned session and conversation values for capture. If a new
+     * handle could not reach the client, the conversation value is omitted while
+     * the derived session value is kept.
+     */
+    prepareToolResult<TResult>(result: TResult, preparedCall: PreparedToolCall): PreparedToolResult<TResult>;
     /**
      * Capture a `get_more_tools` call as a missing-capability report. Emits
      * `$mcp_missing_capability` with the agent's description as `$mcp_intent`. Reply
-     * to the agent with `getMoreToolsResult()`.
+     * to the agent with `getMoreToolsResult()` after passing it through
+     * {@link prepareToolResult}.
      */
     captureMissingCapability(data: MissingCapabilityCaptureData): void;
     /**
@@ -149,7 +184,7 @@ export declare class PostHogMCP extends PostHog {
      * `$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.
+     * own feedback backend and passing the reply through {@link prepareToolResult}.
      */
     captureFeedback(data: FeedbackCaptureData): void;
 }

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,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"}
+{"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,EAGnB,qBAAqB,EACrB,qBAAqB,EAErB,mBAAmB,EAGnB,4BAA4B,EAC5B,gBAAgB,EAChB,kBAAkB,EAClB,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,UAAU,CAAA;AAgBjB,OAAO,EAIL,KAAK,qBAAqB,EAC3B,MAAM,sBAAsB,CAAA;AAkB7B;;;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;IAClD;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B;AAaD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,qBAAa,UAAW,SAAQ,OAAO;;IAcrC,YAAY,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB,EAe1D;IAMD,8FAA8F;IAC9F,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,IAAI,CAgB/C;IAED,iEAAiE;IACjE,iBAAiB,CAAC,IAAI,EAAE,qBAAqB,GAAG,IAAI,CAQnD;IAED;;;;;OAKG;IACH,gBAAgB,CAAC,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAYjD;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,eAAe,CAAC,KAAK,SAAS,qBAAqB,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,OAAO,GAAE,sBAA2B,GAAG,KAAK,EAAE,CAmDlH;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+CG;IACH,eAAe,CACb,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,GAAE,sBAA2B,GACnC,gBAAgB,CAiDlB;IAED;;;;;;;;;OASG;IACH,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,gBAAgB,GAAG,kBAAkB,CAAC,OAAO,CAAC,CA2BvG;IAED;;;;;OAKG;IACH,wBAAwB,CAAC,IAAI,EAAE,4BAA4B,GAAG,IAAI,CAOjE;IAED;;;;;;OAMG;IACH,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,IAAI,CAW/C;CAYF"}

package/dist/extensions/posthog-mcp.js

@@ -33,6 +33,7 @@ __webpack_require__.d(__webpack_exports__, {
 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_conversation_id_js_namespaceObject = require("./conversation-id.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");
@@ -41,20 +42,25 @@ 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_output_instructions_js_namespaceObject = require("./output-instructions.js");
+const external_session_js_namespaceObject = require("./session.js");
 const external_tools_js_namespaceObject = require("./tools.js");
+const PREPARED_CONVERSATION_STATE_KEY = '__posthogMcpConversationState';
 class PostHogMCP extends external_posthog_node_namespaceObject.PostHog {
     #sink;
     #missingCapabilityToolName;
     #feedbackOptions;
     #captureModel;
-    #modelParameterOwnership;
+    #enableConversationId;
+    #analyticsParameterOwnership;
     constructor(apiKey, options = {}){
-        super(apiKey, options), this.#sink = new external_sink_js_namespaceObject.McpEventSink(this), this.#modelParameterOwnership = new Map();
+        super(apiKey, options), this.#sink = new external_sink_js_namespaceObject.McpEventSink(this), this.#analyticsParameterOwnership = 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;
+        this.#enableConversationId = options.enableConversationId ?? true;
         (0, external_lib_identity_js_namespaceObject.applyMcpLibIdentity)(this);
     }
     get #feedbackToolName() {
@@ -100,32 +106,47 @@ class PostHogMCP extends external_posthog_node_namespaceObject.PostHog {
         let prepared = (0, external_context_parameters_js_namespaceObject.isContextEnabled)(contextOption) ? (0, external_context_parameters_js_namespaceObject.addContextParameterToTools)(tools, (0, external_context_parameters_js_namespaceObject.getContextDescription)(contextOption)) : [
             ...tools
         ];
-        if (options.reportMissing && !prepared.some((tool)=>tool?.name === this.#missingCapabilityToolName)) prepared = [
-            ...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)
+        const ownershipSources = [
+            ...tools
         ];
+        if (options.reportMissing && !prepared.some((tool)=>tool?.name === this.#missingCapabilityToolName)) {
+            const virtualTool = (0, external_tools_js_namespaceObject.getReportMissingToolDescriptor)(this.#missingCapabilityToolName);
+            prepared = [
+                ...prepared,
+                virtualTool
+            ];
+            ownershipSources.push(virtualTool);
+        }
+        if (options.collectFeedback && void 0 !== this.#feedbackOptions && !prepared.some((tool)=>tool?.name === this.#feedbackToolName)) {
+            const virtualTool = (0, external_feedback_js_namespaceObject.getFeedbackToolDescriptor)(this.#feedbackOptions);
+            prepared = [
+                ...prepared,
+                virtualTool
+            ];
+            ownershipSources.push(virtualTool);
+        }
+        this.#analyticsParameterOwnership.clear();
+        const ownershipByName = collectAnalyticsParameterOwnership(ownershipSources);
+        for (const [toolName, ownership] of ownershipByName)this.#analyticsParameterOwnership.set(toolName, ownership);
         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));
+            prepared = prepared.map((tool)=>'string' == typeof tool.name && ownershipByName.get(tool.name)?.llmModel === false ? tool : (0, external_model_parameters_js_namespaceObject.addModelParameterToTool)(tool, modelDescription));
+        }
+        if (this.#enableConversationId) {
+            prepared = prepared.map((tool)=>'string' == typeof tool.name && ownershipByName.get(tool.name)?.conversationId === false ? tool : (0, external_conversation_id_js_namespaceObject.addConversationIdToTools)([
+                    tool
+                ])[0]);
+            prepared = prepared.map((tool)=>'string' == typeof tool.name && ownershipByName.get(tool.name)?.outputInstructions === false ? tool : (0, external_output_instructions_js_namespaceObject.addInstructionsToOutputSchemas)([
+                    tool
+                ])[0]);
         }
         return prepared;
     }
     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 ownership = options.originalTool ? (0, external_analytics_parameters_js_namespaceObject.getAnalyticsParameterOwnership)(options.originalTool.inputSchema, options.originalTool.outputSchema) : this.#analyticsParameterOwnership.get(name);
+        const ownsModel = (0, external_model_parameters_js_namespaceObject.isCaptureModelEnabled)(this.#captureModel) && ownership?.llmModel === true;
         const resolvedModel = (0, external_model_parameters_js_namespaceObject.isCaptureModelEnabled)(this.#captureModel) ? (0, external_model_parameters_js_namespaceObject.resolveModel)({
             params: {
                 arguments: args,
@@ -133,20 +154,65 @@ class PostHogMCP extends external_posthog_node_namespaceObject.PostHog {
             }
         }, ownsModel) : void 0;
         const strippedArgs = stripContext(args);
+        const canReadConversationId = this.#enableConversationId && (ownership?.conversationId ?? true);
+        const resolvedConversation = (0, external_conversation_id_js_namespaceObject.resolveConversationId)(canReadConversationId, args);
+        const conversation = resolvedConversation.minted && options.sessionId ? {
+            minted: false,
+            conversationId: void 0
+        } : resolvedConversation;
+        const conversationId = conversation.conversationId;
+        const sessionId = conversationId ? (0, external_session_js_namespaceObject.deriveSessionIdFromConversation)(conversationId) : options.sessionId;
         const isFeedback = void 0 !== this.#feedbackOptions && name === this.#feedbackToolName && null == options.originalTool;
-        return {
+        const preparedCall = {
             intent,
             intentSource: intent ? 'context_parameter' : void 0,
             llmModel: resolvedModel?.model,
             llmModelSource: resolvedModel?.source,
-            args: ownsModel ? (0, external_analytics_parameters_js_namespaceObject.stripOwnedAnalyticsArguments)(strippedArgs, {
+            args: (0, external_analytics_parameters_js_namespaceObject.stripOwnedAnalyticsArguments)(strippedArgs, {
                 context: false,
-                conversationId: false,
-                llmModel: true
-            }) : strippedArgs,
+                conversationId: this.#enableConversationId && ownership?.conversationId === true,
+                llmModel: ownsModel
+            }),
+            sessionId,
+            conversationId,
             isMissingCapability: name === this.#missingCapabilityToolName,
             isFeedback,
-            feedbackReport: isFeedback ? (0, external_feedback_js_namespaceObject.parseFeedbackReport)(args, this.#feedbackOptions) : void 0
+            feedbackReport: isFeedback ? (0, external_feedback_js_namespaceObject.parseFeedbackReport)(args, this.#feedbackOptions) : void 0,
+            [PREPARED_CONVERSATION_STATE_KEY]: {
+                minted: conversation.minted,
+                outputInstructions: this.#enableConversationId && ownership?.outputInstructions === true
+            }
+        };
+        return preparedCall;
+    }
+    prepareToolResult(result, preparedCall) {
+        const state = preparedCall[PREPARED_CONVERSATION_STATE_KEY];
+        const conversationId = preparedCall.conversationId;
+        if (!conversationId) return {
+            result,
+            sessionId: preparedCall.sessionId,
+            conversationId
+        };
+        if (!state) return {
+            result,
+            sessionId: preparedCall.sessionId,
+            conversationId: void 0
+        };
+        let preparedResult = result;
+        let delivered = false;
+        if (state.outputInstructions) {
+            const mirrored = (0, external_output_instructions_js_namespaceObject.mirrorInstructionsIntoStructuredContent)(preparedResult, conversationId);
+            delivered = mirrored !== preparedResult;
+            preparedResult = mirrored;
+        }
+        if (state.minted && (0, external_conversation_id_js_namespaceObject.canInjectConversationIdPromptBack)(preparedResult)) {
+            preparedResult = (0, external_conversation_id_js_namespaceObject.injectConversationIdPromptBack)(preparedResult, conversationId);
+            delivered = true;
+        }
+        return {
+            result: preparedResult,
+            sessionId: preparedCall.sessionId,
+            conversationId: state.minted && !delivered ? void 0 : conversationId
         };
     }
     captureMissingCapability(data) {
@@ -178,6 +244,7 @@ function baseEvent(eventType, common) {
     const event = {
         eventType,
         sessionId: common.sessionId,
+        conversationId: common.conversationId,
         protocolVersion: common.protocolVersion,
         clientUserAgent: (0, external_headers_js_namespaceObject.normalizeHeaderString)(common.clientUserAgent),
         vendorClient: (0, external_headers_js_namespaceObject.normalizeHeaderString)(common.vendorClient),
@@ -189,6 +256,21 @@ function baseEvent(eventType, common) {
     if (common.setProperties && Object.keys(common.setProperties).length > 0) event.identifyActorData = common.setProperties;
     return event;
 }
+function collectAnalyticsParameterOwnership(tools) {
+    const ownershipByName = new Map();
+    for (const tool of tools){
+        if ('string' != typeof tool.name) continue;
+        const next = (0, external_analytics_parameters_js_namespaceObject.getAnalyticsParameterOwnership)(tool.inputSchema, tool.outputSchema);
+        const current = ownershipByName.get(tool.name);
+        ownershipByName.set(tool.name, current ? {
+            context: current.context && next.context,
+            conversationId: current.conversationId && next.conversationId,
+            llmModel: current.llmModel && next.llmModel,
+            outputInstructions: current.outputInstructions && next.outputInstructions
+        } : next);
+    }
+    return ownershipByName;
+}
 function applyIntent(event, intent, source) {
     const trimmed = 'string' == typeof intent ? intent.trim() : '';
     if (!trimmed) return;

package/dist/extensions/posthog-mcp.mjs

@@ -1,6 +1,7 @@
 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 { getAnalyticsParameterOwnership, stripOwnedAnalyticsArguments } from "./analytics-parameters.mjs";
+import { addConversationIdToTools, canInjectConversationIdPromptBack, injectConversationIdPromptBack, resolveConversationId } from "./conversation-id.mjs";
 import { addContextParameterToTools, getContextDescription, isContextEnabled } from "./context-parameters.mjs";
 import { MCPAnalyticsEventType } from "./event-types.mjs";
 import { captureException } from "./exceptions.mjs";
@@ -9,20 +10,25 @@ import { applyMcpLibIdentity } from "./lib-identity.mjs";
 import { log } from "./logger.mjs";
 import { addModelParameterToTool, getModelDescription, isCaptureModelEnabled, resolveModel, setEventModel } from "./model-parameters.mjs";
 import { McpEventSink } from "./sink.mjs";
+import { addInstructionsToOutputSchemas, mirrorInstructionsIntoStructuredContent } from "./output-instructions.mjs";
+import { deriveSessionIdFromConversation } from "./session.mjs";
 import { GET_MORE_TOOLS_NAME, getReportMissingToolDescriptor } from "./tools.mjs";
+const PREPARED_CONVERSATION_STATE_KEY = '__posthogMcpConversationState';
 class PostHogMCP extends PostHog {
     #sink;
     #missingCapabilityToolName;
     #feedbackOptions;
     #captureModel;
-    #modelParameterOwnership;
+    #enableConversationId;
+    #analyticsParameterOwnership;
     constructor(apiKey, options = {}){
-        super(apiKey, options), this.#sink = new McpEventSink(this), this.#modelParameterOwnership = new Map();
+        super(apiKey, options), this.#sink = new McpEventSink(this), this.#analyticsParameterOwnership = 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;
+        this.#enableConversationId = options.enableConversationId ?? true;
         applyMcpLibIdentity(this);
     }
     get #feedbackToolName() {
@@ -68,32 +74,47 @@ class PostHogMCP extends PostHog {
         let prepared = isContextEnabled(contextOption) ? addContextParameterToTools(tools, getContextDescription(contextOption)) : [
             ...tools
         ];
-        if (options.reportMissing && !prepared.some((tool)=>tool?.name === this.#missingCapabilityToolName)) prepared = [
-            ...prepared,
-            getReportMissingToolDescriptor(this.#missingCapabilityToolName)
-        ];
-        if (options.collectFeedback && void 0 !== this.#feedbackOptions && !prepared.some((tool)=>tool?.name === this.#feedbackToolName)) prepared = [
-            ...prepared,
-            getFeedbackToolDescriptor(this.#feedbackOptions)
+        const ownershipSources = [
+            ...tools
         ];
+        if (options.reportMissing && !prepared.some((tool)=>tool?.name === this.#missingCapabilityToolName)) {
+            const virtualTool = getReportMissingToolDescriptor(this.#missingCapabilityToolName);
+            prepared = [
+                ...prepared,
+                virtualTool
+            ];
+            ownershipSources.push(virtualTool);
+        }
+        if (options.collectFeedback && void 0 !== this.#feedbackOptions && !prepared.some((tool)=>tool?.name === this.#feedbackToolName)) {
+            const virtualTool = getFeedbackToolDescriptor(this.#feedbackOptions);
+            prepared = [
+                ...prepared,
+                virtualTool
+            ];
+            ownershipSources.push(virtualTool);
+        }
+        this.#analyticsParameterOwnership.clear();
+        const ownershipByName = collectAnalyticsParameterOwnership(ownershipSources);
+        for (const [toolName, ownership] of ownershipByName)this.#analyticsParameterOwnership.set(toolName, ownership);
         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));
+            prepared = prepared.map((tool)=>'string' == typeof tool.name && ownershipByName.get(tool.name)?.llmModel === false ? tool : addModelParameterToTool(tool, modelDescription));
+        }
+        if (this.#enableConversationId) {
+            prepared = prepared.map((tool)=>'string' == typeof tool.name && ownershipByName.get(tool.name)?.conversationId === false ? tool : addConversationIdToTools([
+                    tool
+                ])[0]);
+            prepared = prepared.map((tool)=>'string' == typeof tool.name && ownershipByName.get(tool.name)?.outputInstructions === false ? tool : addInstructionsToOutputSchemas([
+                    tool
+                ])[0]);
         }
         return prepared;
     }
     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 ownership = options.originalTool ? getAnalyticsParameterOwnership(options.originalTool.inputSchema, options.originalTool.outputSchema) : this.#analyticsParameterOwnership.get(name);
+        const ownsModel = isCaptureModelEnabled(this.#captureModel) && ownership?.llmModel === true;
         const resolvedModel = isCaptureModelEnabled(this.#captureModel) ? resolveModel({
             params: {
                 arguments: args,
@@ -101,20 +122,65 @@ class PostHogMCP extends PostHog {
             }
         }, ownsModel) : void 0;
         const strippedArgs = stripContext(args);
+        const canReadConversationId = this.#enableConversationId && (ownership?.conversationId ?? true);
+        const resolvedConversation = resolveConversationId(canReadConversationId, args);
+        const conversation = resolvedConversation.minted && options.sessionId ? {
+            minted: false,
+            conversationId: void 0
+        } : resolvedConversation;
+        const conversationId = conversation.conversationId;
+        const sessionId = conversationId ? deriveSessionIdFromConversation(conversationId) : options.sessionId;
         const isFeedback = void 0 !== this.#feedbackOptions && name === this.#feedbackToolName && null == options.originalTool;
-        return {
+        const preparedCall = {
             intent,
             intentSource: intent ? 'context_parameter' : void 0,
             llmModel: resolvedModel?.model,
             llmModelSource: resolvedModel?.source,
-            args: ownsModel ? stripOwnedAnalyticsArguments(strippedArgs, {
+            args: stripOwnedAnalyticsArguments(strippedArgs, {
                 context: false,
-                conversationId: false,
-                llmModel: true
-            }) : strippedArgs,
+                conversationId: this.#enableConversationId && ownership?.conversationId === true,
+                llmModel: ownsModel
+            }),
+            sessionId,
+            conversationId,
             isMissingCapability: name === this.#missingCapabilityToolName,
             isFeedback,
-            feedbackReport: isFeedback ? parseFeedbackReport(args, this.#feedbackOptions) : void 0
+            feedbackReport: isFeedback ? parseFeedbackReport(args, this.#feedbackOptions) : void 0,
+            [PREPARED_CONVERSATION_STATE_KEY]: {
+                minted: conversation.minted,
+                outputInstructions: this.#enableConversationId && ownership?.outputInstructions === true
+            }
+        };
+        return preparedCall;
+    }
+    prepareToolResult(result, preparedCall) {
+        const state = preparedCall[PREPARED_CONVERSATION_STATE_KEY];
+        const conversationId = preparedCall.conversationId;
+        if (!conversationId) return {
+            result,
+            sessionId: preparedCall.sessionId,
+            conversationId
+        };
+        if (!state) return {
+            result,
+            sessionId: preparedCall.sessionId,
+            conversationId: void 0
+        };
+        let preparedResult = result;
+        let delivered = false;
+        if (state.outputInstructions) {
+            const mirrored = mirrorInstructionsIntoStructuredContent(preparedResult, conversationId);
+            delivered = mirrored !== preparedResult;
+            preparedResult = mirrored;
+        }
+        if (state.minted && canInjectConversationIdPromptBack(preparedResult)) {
+            preparedResult = injectConversationIdPromptBack(preparedResult, conversationId);
+            delivered = true;
+        }
+        return {
+            result: preparedResult,
+            sessionId: preparedCall.sessionId,
+            conversationId: state.minted && !delivered ? void 0 : conversationId
         };
     }
     captureMissingCapability(data) {
@@ -146,6 +212,7 @@ function baseEvent(eventType, common) {
     const event = {
         eventType,
         sessionId: common.sessionId,
+        conversationId: common.conversationId,
         protocolVersion: common.protocolVersion,
         clientUserAgent: normalizeHeaderString(common.clientUserAgent),
         vendorClient: normalizeHeaderString(common.vendorClient),
@@ -157,6 +224,21 @@ function baseEvent(eventType, common) {
     if (common.setProperties && Object.keys(common.setProperties).length > 0) event.identifyActorData = common.setProperties;
     return event;
 }
+function collectAnalyticsParameterOwnership(tools) {
+    const ownershipByName = new Map();
+    for (const tool of tools){
+        if ('string' != typeof tool.name) continue;
+        const next = getAnalyticsParameterOwnership(tool.inputSchema, tool.outputSchema);
+        const current = ownershipByName.get(tool.name);
+        ownershipByName.set(tool.name, current ? {
+            context: current.context && next.context,
+            conversationId: current.conversationId && next.conversationId,
+            llmModel: current.llmModel && next.llmModel,
+            outputInstructions: current.outputInstructions && next.outputInstructions
+        } : next);
+    }
+    return ownershipByName;
+}
 function applyIntent(event, intent, source) {
     const trimmed = 'string' == typeof intent ? intent.trim() : '';
     if (!trimmed) return;

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

@@ -1 +1 @@
-{"version":3,"file":"sink.d.ts","sourceRoot":"","sources":["../../src/extensions/sink.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAG3C,OAAO,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAC7D,OAAO,EAAO,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAA;AAC7C,OAAO,EAAE,KAAK,mBAAmB,EAA6B,MAAM,kBAAkB,CAAA;AAKtF,yEAAyE;AACzE,MAAM,WAAW,iBAAiB;IAChC,0BAA0B,EAAE,OAAO,CAAA;IACnC,kFAAkF;IAClF,UAAU,CAAC,EAAE,YAAY,CAAA;CAC1B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,iBAAiB,EAC1B,MAAM,GAAE,QAAc,GACrB,OAAO,CAAC;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,mBAAmB,EAAE,CAAA;CAAE,GAAG,IAAI,CAAC,CA2BnE;AA6BD;;;;;;;GAOG;AACH,qBAAa,YAAY;IAErB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,OAAO,EAAE,OAAO,EAChB,MAAM,GAAE,QAAc;IAGzC;;;OAGG;IACG,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;CAmC1E"}
+{"version":3,"file":"sink.d.ts","sourceRoot":"","sources":["../../src/extensions/sink.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAG3C,OAAO,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAC7D,OAAO,EAAO,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAA;AAC7C,OAAO,EAAE,KAAK,mBAAmB,EAA6B,MAAM,kBAAkB,CAAA;AAKtF,yEAAyE;AACzE,MAAM,WAAW,iBAAiB;IAChC,0BAA0B,EAAE,OAAO,CAAA;IACnC,kFAAkF;IAClF,UAAU,CAAC,EAAE,YAAY,CAAA;CAC1B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,iBAAiB,EAC1B,MAAM,GAAE,QAAc,GACrB,OAAO,CAAC;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,mBAAmB,EAAE,CAAA;CAAE,GAAG,IAAI,CAAC,CA2BnE;AA6BD;;;;;;;GAOG;AACH,qBAAa,YAAY;IAErB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAFzB,YACmB,OAAO,EAAE,OAAO,EAChB,MAAM,GAAE,QAAc,EACrC;IAEJ;;;OAGG;IACG,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkCxE;CACF"}

package/dist/extensions/tools.d.ts

@@ -1,6 +1,6 @@
 import type { CompatibleTextToolResult, CompatibleToolsListLike } from '../types';
 import { type LoggerFn } from './logger';
-export declare const GET_MORE_TOOLS_NAME: "get_more_tools";
+export declare const GET_MORE_TOOLS_NAME: 'get_more_tools';
 /**
  * The configured name of the `get_more_tools` virtual tool, falling back to the
  * default. Resolve through here everywhere (inject + detect) so a custom name

package/dist/index.d.ts

@@ -56,7 +56,7 @@ 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 { 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 { FeedbackCaptureData, FeedbackExtraPropertySchema, CollectFeedbackOptions, FeedbackReport, FeedbackSentiment, FeedbackType, BeforeSendFn, CaptureEventData, CollectFeedbackConfig, InitializeCaptureData, McpAnalytics, McpCaptureCommon, MCPAnalyticsContextOptions, MCPAnalyticsIntentSource, MCPAnalyticsModelOptions, MCPAnalyticsModelSource, MCPAnalyticsOptions, MissingCapabilityCaptureData, PreparedToolCall, PreparedToolResult, 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;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"}
+{"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;AA4FD,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,kBAAkB,EAClB,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

@@ -106,7 +106,8 @@ function getLowLevelServer(server) {
 const DEFAULT_OPTIONS = {
     reportMissing: false,
     collectFeedback: false,
-    enableConversationId: false
+    enableConversationId: true,
+    captureModel: true
 };
 function buildTrackingData(lowLevelServer, options, sink, logger) {
     return {
@@ -121,7 +122,7 @@ function buildTrackingData(lowLevelServer, options, sink, logger) {
         sessionInfo: (0, session_js_namespaceObject.getSessionInfo)(lowLevelServer, void 0),
         options: {
             ...DEFAULT_OPTIONS,
-            ...options
+            ...Object.fromEntries(Object.entries(options).filter(([, value])=>void 0 !== value))
         },
         sessionSource: 'generated'
     };

package/dist/index.mjs

@@ -52,7 +52,8 @@ function getLowLevelServer(server) {
 const DEFAULT_OPTIONS = {
     reportMissing: false,
     collectFeedback: false,
-    enableConversationId: false
+    enableConversationId: true,
+    captureModel: true
 };
 function buildTrackingData(lowLevelServer, options, sink, logger) {
     return {
@@ -67,7 +68,7 @@ function buildTrackingData(lowLevelServer, options, sink, logger) {
         sessionInfo: getSessionInfo(lowLevelServer, void 0),
         options: {
             ...DEFAULT_OPTIONS,
-            ...options
+            ...Object.fromEntries(Object.entries(options).filter(([, value])=>void 0 !== value))
         },
         sessionSource: 'generated'
     };