@posthog/mcp 0.17.0 → 0.18.0

package/README.md

@@ -179,7 +179,7 @@ enforces it, so servers keep working; strict-schema clients see the new field. S
 `conversation_id` argument and returns a handle in eligible tool results. Clients must echo that
 handle to group later calls; calls without it mint new handles. Set `enableConversationId: false`
 to retain transport-based session grouping and unchanged response content. Custom `PostHogMCP`
-dispatchers enable model capture by default, but continue to supply their own session IDs.
+dispatchers also enable model capture and conversation correlation by default.
 The reasoning behind these defaults is in [ADR-0013](./docs/adr/0013-analytics-capture-is-on-by-default.md).
 
 ### What `$mcp_llm_model` records, and when it stays empty
@@ -213,29 +213,44 @@ As with `context`, what matters is instance lifetime rather than statelessness:
 server (`sessionIdGenerator: undefined`) that keeps one long-lived server object learns ownership
 from the first `tools/list` and keeps it.
 
-For a custom dispatcher, `PostHogMCP` enables the same option by default. Its `prepareToolList()` helper
-injects the field and records ownership by tool name; `prepareToolCall()` returns `llmModel` and
-`llmModelSource` while removing the SDK-owned argument before dispatch. Pass both fields to
-`captureToolCall()`. Pass the original tool descriptor on each call so this also works when
-`tools/list` and `tools/call` reach different server replicas:
+For a custom dispatcher, `PostHogMCP` enables model capture and conversation correlation by default.
+`prepareToolList()` injects the analytics fields and records ownership by tool name.
+`prepareToolCall()` removes SDK-owned arguments and resolves the conversation and session.
+`prepareToolResult()` returns the result to send and the final values to capture. Pass the original
+tool descriptor on each call so this also works when `tools/list` and `tools/call` reach different
+server replicas:
 
 ```ts
 const posthog = new PostHogMCP(process.env.POSTHOG_PROJECT_TOKEN)
 
 const tools = posthog.prepareToolList(serverTools)
 const originalTool = serverTools.find((tool) => tool.name === toolName)
-const { args, llmModel, llmModelSource } = posthog.prepareToolCall(toolName, rawArgs, {
+const preparedCall = posthog.prepareToolCall(toolName, rawArgs, {
   originalTool,
   requestMeta: request.params?._meta,
+  sessionId: transportSessionId,
+})
+const toolResult = await dispatch(toolName, preparedCall.args)
+const preparedResult = posthog.prepareToolResult(toolResult, preparedCall)
+
+posthog.captureToolCall({
+  toolName,
+  llmModel: preparedCall.llmModel,
+  llmModelSource: preparedCall.llmModelSource,
+  sessionId: preparedResult.sessionId,
+  conversationId: preparedResult.conversationId,
+  isError: false,
 })
-const result = await dispatch(toolName, args)
 
-posthog.captureToolCall({ toolName, llmModel, llmModelSource, isError: false })
+return preparedResult.result
 ```
 
 A persistent single-process dispatcher can omit `originalTool` after it has prepared its tool list.
 Pass `requestMeta` whenever the request supplies `_meta`; this enables recognized client metadata
-without changing the arguments sent to the tool.
+without changing the arguments sent to the tool. Pass an existing transport or request session as
+`sessionId`. A valid echoed conversation handle takes precedence. Otherwise, the existing session
+prevents a new handle from being minted. Set `enableConversationId: false` on `PostHogMCP` to keep
+the previous custom-dispatcher behavior.
 
 ### Collecting agent feedback (`send_feedback`)
 
@@ -288,11 +303,17 @@ return { tools: posthog.prepareToolList(myTools, { collectFeedback: true }) }
 
 // tools/call dispatcher
 const originalTool = myTools.find((tool) => tool.name === name)
-const prepared = posthog.prepareToolCall(name, rawArgs, { originalTool })
-if (prepared.isFeedback) {
-  posthog.captureFeedback({ report: prepared.feedbackReport!, ...identity })
-  await myFeedbackBackend.record(prepared.feedbackReport!)
-  return sendFeedbackResult() // or a custom text reply
+const preparedCall = posthog.prepareToolCall(name, rawArgs, { originalTool })
+if (preparedCall.isFeedback) {
+  await myFeedbackBackend.record(preparedCall.feedbackReport!)
+  const preparedResult = posthog.prepareToolResult(sendFeedbackResult(), preparedCall)
+  posthog.captureFeedback({
+    report: preparedCall.feedbackReport!,
+    sessionId: preparedResult.sessionId,
+    conversationId: preparedResult.conversationId,
+    ...identity,
+  })
+  return preparedResult.result
 }
 ```
 

package/dist/extensions/constants.d.ts

@@ -5,54 +5,54 @@ export declare const DEFAULT_CONVERSATION_ID_DESCRIPTION = "Echo the conversatio
 export declare const POSTHOG_MCP_ANALYTICS_SOURCE = "posthog_mcp_analytics";
 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";
-    readonly PromptGet: "$mcp_prompt_get";
-    readonly PromptsList: "$mcp_prompts_list";
-    readonly ResourceRead: "$mcp_resource_read";
-    readonly ResourcesList: "$mcp_resources_list";
-    readonly ToolCall: "$mcp_tool_call";
-    readonly ToolsList: "$mcp_tools_list";
+    readonly Custom: '$mcp_custom';
+    readonly Exception: '$exception';
+    readonly Feedback: '$mcp_feedback';
+    readonly Identify: '$identify';
+    readonly Initialize: '$mcp_initialize';
+    readonly MissingCapability: '$mcp_missing_capability';
+    readonly PromptGet: '$mcp_prompt_get';
+    readonly PromptsList: '$mcp_prompts_list';
+    readonly ResourceRead: '$mcp_resource_read';
+    readonly ResourcesList: '$mcp_resources_list';
+    readonly ToolCall: '$mcp_tool_call';
+    readonly ToolsList: '$mcp_tools_list';
 };
 export type PostHogMCPAnalyticsEvent = (typeof PostHogMCPAnalyticsEvent)[keyof typeof PostHogMCPAnalyticsEvent];
 export declare const PostHogMCPAnalyticsProperty: {
-    readonly ClientName: "$mcp_client_name";
-    readonly ClientUserAgent: "$mcp_client_user_agent";
-    readonly ClientVersion: "$mcp_client_version";
-    readonly ConversationId: "$mcp_conversation_id";
-    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";
-    readonly ListedToolNames: "$mcp_listed_tool_names";
-    readonly LlmModel: "$mcp_llm_model";
-    readonly LlmModelSource: "$mcp_llm_model_source";
-    readonly Parameters: "$mcp_parameters";
-    readonly ProtocolVersion: "$mcp_protocol_version";
-    readonly ResourceName: "$mcp_resource_name";
-    readonly Response: "$mcp_response";
-    readonly ServerName: "$mcp_server_name";
-    readonly ServerVersion: "$mcp_server_version";
-    readonly SessionId: "$session_id";
-    readonly Source: "$mcp_source";
-    readonly ToolCategory: "$mcp_tool_category";
-    readonly ToolDescription: "$mcp_tool_description";
-    readonly ToolName: "$mcp_tool_name";
-    readonly VendorClient: "$mcp_vendor_client";
+    readonly ClientName: '$mcp_client_name';
+    readonly ClientUserAgent: '$mcp_client_user_agent';
+    readonly ClientVersion: '$mcp_client_version';
+    readonly ConversationId: '$mcp_conversation_id';
+    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';
+    readonly ListedToolNames: '$mcp_listed_tool_names';
+    readonly LlmModel: '$mcp_llm_model';
+    readonly LlmModelSource: '$mcp_llm_model_source';
+    readonly Parameters: '$mcp_parameters';
+    readonly ProtocolVersion: '$mcp_protocol_version';
+    readonly ResourceName: '$mcp_resource_name';
+    readonly Response: '$mcp_response';
+    readonly ServerName: '$mcp_server_name';
+    readonly ServerVersion: '$mcp_server_version';
+    readonly SessionId: '$session_id';
+    readonly Source: '$mcp_source';
+    readonly ToolCategory: '$mcp_tool_category';
+    readonly ToolDescription: '$mcp_tool_description';
+    readonly ToolName: '$mcp_tool_name';
+    readonly VendorClient: '$mcp_vendor_client';
 };
 export type PostHogMCPAnalyticsProperty = (typeof PostHogMCPAnalyticsProperty)[keyof typeof PostHogMCPAnalyticsProperty];
 //# sourceMappingURL=constants.d.ts.map

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;;;;;;;;;;;;;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"}
+{"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;aACnC,MAAM,EAAE,aAAa;aACrB,SAAS,EAAE,YAAY;aACvB,QAAQ,EAAE,eAAe;aACzB,QAAQ,EAAE,WAAW;aACrB,UAAU,EAAE,iBAAiB;aAC7B,iBAAiB,EAAE,yBAAyB;aAC5C,SAAS,EAAE,iBAAiB;aAC5B,WAAW,EAAE,mBAAmB;aAChC,YAAY,EAAE,oBAAoB;aAClC,aAAa,EAAE,qBAAqB;aACpC,QAAQ,EAAE,gBAAgB;aAC1B,SAAS,EAAE,iBAAiB;CACpB,CAAA;AAEV,MAAM,MAAM,wBAAwB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,OAAO,wBAAwB,CAAC,CAAA;AAE/G,eAAO,MAAM,2BAA2B;aACtC,UAAU,EAAE,kBAAkB;aAC9B,eAAe,EAAE,wBAAwB;aACzC,aAAa,EAAE,qBAAqB;aACpC,cAAc,EAAE,sBAAsB;aACtC,UAAU,EAAE,kBAAkB;aAC9B,YAAY,EAAE,oBAAoB;aAClC,SAAS,EAAE,iBAAiB;aAC5B,eAAe,EAAE,uBAAuB;aACxC,sBAAsB,EAAE,+BAA+B;aACvD,iBAAiB,EAAE,yBAAyB;aAC5C,4BAA4B,EAAE,qCAAqC;aACnE,eAAe,EAAE,uBAAuB;aACxC,qBAAqB,EAAE,8BAA8B;aACrD,YAAY,EAAE,oBAAoB;aAClC,YAAY,EAAE,oBAAoB;aAClC,OAAO,EAAE,eAAe;aACxB,MAAM,EAAE,aAAa;aACrB,YAAY,EAAE,oBAAoB;aAClC,eAAe,EAAE,wBAAwB;aACzC,QAAQ,EAAE,gBAAgB;aAC1B,cAAc,EAAE,uBAAuB;aACvC,UAAU,EAAE,iBAAiB;aAC7B,eAAe,EAAE,uBAAuB;aACxC,YAAY,EAAE,oBAAoB;aAClC,QAAQ,EAAE,eAAe;aACzB,UAAU,EAAE,kBAAkB;aAC9B,aAAa,EAAE,qBAAqB;aACpC,SAAS,EAAE,aAAa;aACxB,MAAM,EAAE,aAAa;aACrB,YAAY,EAAE,oBAAoB;aAClC,eAAe,EAAE,uBAAuB;aACxC,QAAQ,EAAE,gBAAgB;aAC1B,YAAY,EAAE,oBAAoB;CAC1B,CAAA;AAEV,MAAM,MAAM,2BAA2B,GAAG,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,OAAO,2BAA2B,CAAC,CAAA"}

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

@@ -6,17 +6,17 @@
  * event names.
  */
 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";
-    readonly mcpPromptsList: "mcp:prompts/list";
-    readonly mcpResourcesList: "mcp:resources/list";
-    readonly mcpResourcesRead: "mcp:resources/read";
-    readonly mcpToolsCall: "mcp:tools/call";
-    readonly mcpToolsList: "mcp:tools/list";
+    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';
+    readonly mcpPromptsList: 'mcp:prompts/list';
+    readonly mcpResourcesList: 'mcp:resources/list';
+    readonly mcpResourcesRead: 'mcp:resources/read';
+    readonly mcpToolsCall: 'mcp:tools/call';
+    readonly mcpToolsList: 'mcp:tools/list';
 };
 export type MCPAnalyticsEventType = (typeof MCPAnalyticsEventType)[keyof typeof MCPAnalyticsEventType];
 //# sourceMappingURL=event-types.d.ts.map

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;;;;;;;;;;;;CAYxB,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;aAChC,QAAQ,EAAE,kBAAkB;aAC5B,MAAM,EAAE,gBAAgB;aACxB,WAAW,EAAE,cAAc;aAC3B,oBAAoB,EAAE,wBAAwB;aAC9C,aAAa,EAAE,gBAAgB;aAC/B,aAAa,EAAE,iBAAiB;aAChC,cAAc,EAAE,kBAAkB;aAClC,gBAAgB,EAAE,oBAAoB;aACtC,gBAAgB,EAAE,oBAAoB;aACtC,YAAY,EAAE,gBAAgB;aAC9B,YAAY,EAAE,gBAAgB;CACtB,CAAA;AAEV,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,OAAO,qBAAqB,CAAC,CAAA"}

package/dist/extensions/feedback.d.ts

@@ -1,6 +1,6 @@
 import type { CollectFeedbackOptions, FeedbackReport, CollectFeedbackConfig, CompatibleTextToolResult, CompatibleToolsListLike, JsonRecord } from '../types';
 import { type LoggerFn } from './logger';
-export declare const SEND_FEEDBACK_TOOL_NAME: "send_feedback";
+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;

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

@@ -1 +1 @@
-{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../src/extensions/internal.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,6BAA6B,EAC7B,gBAAgB,EAChB,cAAc,EACd,aAAa,EAEb,WAAW,EACX,YAAY,EACb,MAAM,UAAU,CAAA;AAMjB;;;;;GAKG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkC;IACzD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;gBAErB,OAAO,SAAO;IAI1B,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAWhD,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,GAAG,IAAI;IAapD,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI/B,IAAI,IAAI,MAAM;CAGf;AAID,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,GAAG,gBAAgB,GAAG,SAAS,CAEzF;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAEzF;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,GAAG,OAAO,CA4B5E;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,YAAY,GAAG,SAAS,EAAE,IAAI,EAAE,YAAY,GAAG,YAAY,CAapG;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,gBAAgB,EACtB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,cAAc,EACvB,kBAAkB,EAAE,WAAW,EAC/B,KAAK,CAAC,EAAE,6BAA6B;AACrC;;;;;GAKG;AACH,uBAAuB,UAAQ,GAC9B,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAuDnC;AAED,wBAAgB,YAAY,CAAC,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,GAAG,SAAS,GAAG,WAAW,CAOtG;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,cAAc,EACvB,KAAK,CAAC,EAAE,6BAA6B,GACpC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,CAUzC"}
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../src/extensions/internal.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,6BAA6B,EAC7B,gBAAgB,EAChB,cAAc,EACd,aAAa,EAEb,WAAW,EACX,YAAY,EACb,MAAM,UAAU,CAAA;AAMjB;;;;;GAKG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkC;IACzD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;IAEjC,YAAY,OAAO,SAAO,EAEzB;IAED,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAS/C;IAED,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,GAAG,IAAI,CAWnD;IAED,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAE9B;IAED,IAAI,IAAI,MAAM,CAEb;CACF;AAID,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,GAAG,gBAAgB,GAAG,SAAS,CAEzF;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAEzF;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,GAAG,OAAO,CA4B5E;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,YAAY,GAAG,SAAS,EAAE,IAAI,EAAE,YAAY,GAAG,YAAY,CAapG;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,gBAAgB,EACtB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,cAAc,EACvB,kBAAkB,EAAE,WAAW,EAC/B,KAAK,CAAC,EAAE,6BAA6B;AACrC;;;;;GAKG;AACH,uBAAuB,UAAQ,GAC9B,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAuDnC;AAED,wBAAgB,YAAY,CAAC,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,GAAG,SAAS,GAAG,WAAW,CAOtG;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,cAAc,EACvB,KAAK,CAAC,EAAE,6BAA6B,GACpC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,CAUzC"}

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
@@ -29,6 +29,12 @@ export interface PostHogMCPOptions extends PostHogOptions {
      * `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;