@posthog/mcp 0.11.2 → 0.11.4

package/README.md

@@ -73,6 +73,27 @@ Details: [docs/ARCHITECTURE.md §4](./docs/ARCHITECTURE.md).
 `@modelcontextprotocol/{core,server,client}` v2 — and on both the high-level `McpServer` and the
 low-level `Server`. Shapes are detected at runtime, so neither major is a dependency here.
 
+### Sessions and client identity on a v2 server
+
+Protocol revision is a property of each **request**, not of the server: a v2 server serves both
+`2025-11-25` and `2026-07-28` traffic, and the SDK is instrumented once for both.
+
+- **On `2026-07-28`** there is no `initialize` and no session header — the revision removed
+  protocol-level sessions, and this SDK will not mint one. Session correlation therefore comes from
+  `enableConversationId`, which is **opt-in**. Without it every request is its own `$session_id`.
+- **On `2025-11-25`**, the session id and the client's name and version are exchanged once at
+  `initialize`. If your server builds a fresh `McpServer` per HTTP request — which
+  `createMcpHandler` does by default — the instance serving a later `tools/call` never saw that
+  handshake. The SDK bridges it by minting the `Mcp-Session-Id` token described above, which the
+  client replays on every request.
+
+  **That token only reaches the client if the transport builds response headers _after_ the handler
+  runs.** `@rekog/mcp-nest` with `enableJsonResponse: true` does; `createMcpHandler`'s legacy leg
+  does not, and there is no setting we can reach from inside the server. On that leg, expect
+  `$mcp_client_name` and `$mcp_client_version` to be absent for `2025-11-25` traffic — the protocol
+  version still arrives, because clients send it on the `MCP-Protocol-Version` header of every
+  request.
+
 ### Reading request headers in a callback
 
 If your `identify`, `intentFallback`, `eventProperties` or `beforeSend` reads HTTP headers, it has

package/dist/extensions/client-identity.d.ts

@@ -11,7 +11,11 @@ import type { CompatibleRequestHandlerExtra, McpEvent, MCPRequestLike, MCPServer
  *      the time a handler runs they are here and `params._meta` is empty.
  *   2. `request.params._meta` — where 2026-07-28 puts them on the wire, and
  *      where they still are on any server that does not lift them.
- *   3. the server's own accessors — `getClientVersion()` from a legacy
+ *   3. the `MCP-Protocol-Version` request header, which 2025-11-25 requires a
+ *      client to send on every request after `initialize` — the only per-request
+ *      carrier a legacy-era request has, and therefore the only one that
+ *      survives a per-request server instance.
+ *   4. the server's own accessors — `getClientVersion()` from a legacy
  *      `initialize` handshake, `getNegotiatedProtocolVersion()` on v2.
  *
  * The 2026-07-28 revision removed the `initialize` handshake and the
@@ -22,6 +26,8 @@ import type { CompatibleRequestHandlerExtra, McpEvent, MCPRequestLike, MCPServer
  */
 export declare const META_CLIENT_INFO_KEY = "io.modelcontextprotocol/clientInfo";
 export declare const META_PROTOCOL_VERSION_KEY = "io.modelcontextprotocol/protocolVersion";
+/** Required on every post-`initialize` request by 2025-11-25 (and sent by modern clients too). */
+export declare const PROTOCOL_VERSION_HEADER = "mcp-protocol-version";
 export interface MetaClientInfo {
     clientName?: string;
     clientVersion?: string;
@@ -52,6 +58,16 @@ export declare function readMetaClientInfo(request: MCPRequestLike): MetaClientI
  * everything.
  */
 export declare function readEnvelopeClientInfo(extra: CompatibleRequestHandlerExtra | undefined): MetaClientInfo | undefined;
+/**
+ * Reads the protocol version off the request headers.
+ *
+ * This is what closes the gap on **2025-11-25 traffic served by a per-request
+ * server**: that era carries identity at the handshake, and the instance
+ * handling a later `tools/call` never saw it. The header rides every request, so
+ * it survives where the handshake does not. Carries no client name — that still
+ * depends on the replayed session token.
+ */
+export declare function readHeaderProtocolVersion(extra: CompatibleRequestHandlerExtra | undefined): MetaClientInfo | undefined;
 /**
  * Asks the server itself. `getClientVersion()` answers on any server that
  * handled an `initialize` (and v2 hosts such as `createMcpHandler` backfill it

package/dist/extensions/client-identity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client-identity.d.ts","sourceRoot":"","sources":["../../src/extensions/client-identity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,QAAQ,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAGtG;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,oBAAoB,uCAAuC,CAAA;AACxE,eAAO,MAAM,yBAAyB,4CAA4C,CAAA;AAElF,MAAM,WAAW,cAAc;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAED,8DAA8D;AAC9D,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,cAAc,CAAA;IACvB,KAAK,CAAC,EAAE,6BAA6B,CAAA;IACrC;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;AAuCD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,GAAG,SAAS,CAEtF;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,6BAA6B,GAAG,SAAS,GAAG,cAAc,GAAG,SAAS,CAEnH;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,GAAG,SAAS,CAsBpF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,qBAAqB,GAAG,cAAc,GAAG,SAAS,CAYnH;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,cAAc,EACvB,KAAK,CAAC,EAAE,6BAA6B,EACrC,MAAM,CAAC,EAAE,aAAa,GACrB,IAAI,CAcN"}
+{"version":3,"file":"client-identity.d.ts","sourceRoot":"","sources":["../../src/extensions/client-identity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,QAAQ,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAKtG;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,oBAAoB,uCAAuC,CAAA;AACxE,eAAO,MAAM,yBAAyB,4CAA4C,CAAA;AAClF,kGAAkG;AAClG,eAAO,MAAM,uBAAuB,yBAAyB,CAAA;AAI7D,MAAM,WAAW,cAAc;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAED,8DAA8D;AAC9D,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,cAAc,CAAA;IACvB,KAAK,CAAC,EAAE,6BAA6B,CAAA;IACrC;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;AAuCD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,GAAG,SAAS,CAEtF;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,6BAA6B,GAAG,SAAS,GAAG,cAAc,GAAG,SAAS,CAEnH;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,6BAA6B,GAAG,SAAS,GAC/C,cAAc,GAAG,SAAS,CAS5B;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,GAAG,SAAS,CAsBpF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,qBAAqB,GAAG,cAAc,GAAG,SAAS,CAiBnH;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,cAAc,EACvB,KAAK,CAAC,EAAE,6BAA6B,EACrC,MAAM,CAAC,EAAE,aAAa,GACrB,IAAI,CAcN"}

package/dist/extensions/client-identity.js

@@ -24,17 +24,23 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    resolveClientIdentity: ()=>resolveClientIdentity,
     readMetaClientInfo: ()=>readMetaClientInfo,
-    readServerClientIdentity: ()=>readServerClientIdentity,
-    readEnvelopeClientInfo: ()=>readEnvelopeClientInfo,
+    readHeaderProtocolVersion: ()=>readHeaderProtocolVersion,
     META_PROTOCOL_VERSION_KEY: ()=>META_PROTOCOL_VERSION_KEY,
+    PROTOCOL_VERSION_HEADER: ()=>PROTOCOL_VERSION_HEADER,
     stampClientIdentity: ()=>stampClientIdentity,
+    resolveClientIdentity: ()=>resolveClientIdentity,
+    readServerClientIdentity: ()=>readServerClientIdentity,
+    readEnvelopeClientInfo: ()=>readEnvelopeClientInfo,
     META_CLIENT_INFO_KEY: ()=>META_CLIENT_INFO_KEY
 });
 const external_detect_js_namespaceObject = require("./detect.js");
+const external_headers_js_namespaceObject = require("./headers.js");
+const external_request_headers_js_namespaceObject = require("./request-headers.js");
 const META_CLIENT_INFO_KEY = 'io.modelcontextprotocol/clientInfo';
 const META_PROTOCOL_VERSION_KEY = 'io.modelcontextprotocol/protocolVersion';
+const PROTOCOL_VERSION_HEADER = 'mcp-protocol-version';
+const MAX_PROTOCOL_VERSION_LENGTH = 64;
 function nonEmptyString(value) {
     return 'string' == typeof value && value.length > 0 ? value : void 0;
 }
@@ -64,6 +70,13 @@ function readMetaClientInfo(request) {
 function readEnvelopeClientInfo(extra) {
     return readReservedKeys(extra?.mcpReq?.envelope);
 }
+function readHeaderProtocolVersion(extra) {
+    const protocolVersion = (0, external_headers_js_namespaceObject.readHeaderValue)((0, external_request_headers_js_namespaceObject.getRequestHeaders)(extra), PROTOCOL_VERSION_HEADER);
+    if (!protocolVersion || protocolVersion.length > MAX_PROTOCOL_VERSION_LENGTH) return;
+    return {
+        protocolVersion
+    };
+}
 function readServerClientIdentity(server) {
     if (!server) return;
     const result = {};
@@ -81,6 +94,7 @@ function resolveClientIdentity({ request, extra, server }) {
     const chain = [
         readEnvelopeClientInfo(extra),
         readMetaClientInfo(request),
+        readHeaderProtocolVersion(extra),
         readServerClientIdentity(server)
     ];
     const result = {};
@@ -104,7 +118,9 @@ function stampClientIdentity(event, request, extra, server) {
 }
 exports.META_CLIENT_INFO_KEY = __webpack_exports__.META_CLIENT_INFO_KEY;
 exports.META_PROTOCOL_VERSION_KEY = __webpack_exports__.META_PROTOCOL_VERSION_KEY;
+exports.PROTOCOL_VERSION_HEADER = __webpack_exports__.PROTOCOL_VERSION_HEADER;
 exports.readEnvelopeClientInfo = __webpack_exports__.readEnvelopeClientInfo;
+exports.readHeaderProtocolVersion = __webpack_exports__.readHeaderProtocolVersion;
 exports.readMetaClientInfo = __webpack_exports__.readMetaClientInfo;
 exports.readServerClientIdentity = __webpack_exports__.readServerClientIdentity;
 exports.resolveClientIdentity = __webpack_exports__.resolveClientIdentity;
@@ -112,7 +128,9 @@ exports.stampClientIdentity = __webpack_exports__.stampClientIdentity;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "META_CLIENT_INFO_KEY",
     "META_PROTOCOL_VERSION_KEY",
+    "PROTOCOL_VERSION_HEADER",
     "readEnvelopeClientInfo",
+    "readHeaderProtocolVersion",
     "readMetaClientInfo",
     "readServerClientIdentity",
     "resolveClientIdentity",

package/dist/extensions/client-identity.mjs

@@ -1,6 +1,10 @@
 import { hasClientVersionAccessor, hasNegotiatedProtocolVersionAccessor } from "./detect.mjs";
+import { readHeaderValue } from "./headers.mjs";
+import { getRequestHeaders } from "./request-headers.mjs";
 const META_CLIENT_INFO_KEY = 'io.modelcontextprotocol/clientInfo';
 const META_PROTOCOL_VERSION_KEY = 'io.modelcontextprotocol/protocolVersion';
+const PROTOCOL_VERSION_HEADER = 'mcp-protocol-version';
+const MAX_PROTOCOL_VERSION_LENGTH = 64;
 function nonEmptyString(value) {
     return 'string' == typeof value && value.length > 0 ? value : void 0;
 }
@@ -30,6 +34,13 @@ function readMetaClientInfo(request) {
 function readEnvelopeClientInfo(extra) {
     return readReservedKeys(extra?.mcpReq?.envelope);
 }
+function readHeaderProtocolVersion(extra) {
+    const protocolVersion = readHeaderValue(getRequestHeaders(extra), PROTOCOL_VERSION_HEADER);
+    if (!protocolVersion || protocolVersion.length > MAX_PROTOCOL_VERSION_LENGTH) return;
+    return {
+        protocolVersion
+    };
+}
 function readServerClientIdentity(server) {
     if (!server) return;
     const result = {};
@@ -47,6 +58,7 @@ function resolveClientIdentity({ request, extra, server }) {
     const chain = [
         readEnvelopeClientInfo(extra),
         readMetaClientInfo(request),
+        readHeaderProtocolVersion(extra),
         readServerClientIdentity(server)
     ];
     const result = {};
@@ -68,4 +80,4 @@ function stampClientIdentity(event, request, extra, server) {
     if (info.clientVersion) event.clientVersion = info.clientVersion;
     if (info.protocolVersion) event.protocolVersion = info.protocolVersion;
 }
-export { META_CLIENT_INFO_KEY, META_PROTOCOL_VERSION_KEY, readEnvelopeClientInfo, readMetaClientInfo, readServerClientIdentity, resolveClientIdentity, stampClientIdentity };
+export { META_CLIENT_INFO_KEY, META_PROTOCOL_VERSION_KEY, PROTOCOL_VERSION_HEADER, readEnvelopeClientInfo, readHeaderProtocolVersion, readMetaClientInfo, readServerClientIdentity, resolveClientIdentity, stampClientIdentity };

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

@@ -1 +1 @@
-{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/extensions/instrumentation.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/extensions/instrumentation.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,2BAA2B,EAC3B,6BAA6B,EAC7B,uBAAuB,EACvB,gBAAgB,EAChB,cAAc,EACd,aAAa,EAId,MAAM,UAAU,CAAA;AAcjB,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAIrD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AASxC;;;;;;GAMG;AAEH,KAAK,iBAAiB,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,CAAC,EAAE,6BAA6B,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAE7G,2EAA2E;AAC3E,KAAK,YAAY,GAAG,CAAC,iBAAiB,EAAE,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAE3E,UAAU,mBAAmB;IAC3B,MAAM,EAAE,aAAa,CAAA;IACrB,IAAI,EAAE,gBAAgB,CAAA;IACtB,OAAO,EAAE,cAAc,CAAA;IACvB,KAAK,CAAC,EAAE,6BAA6B,CAAA;IACrC,OAAO,EAAE,YAAY,CAAA;IACrB,2FAA2F;IAC3F,kBAAkB,CAAC,EAAE,2BAA2B,CAAA;IAChD;;;;OAIG;IACH,SAAS,CAAC,EAAE,qBAAqB,CAAA;IACjC;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,OAAO,CAAA;CAClC;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC,CAqDnF;AAuND;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,CACzB,MAAM,EAAE,aAAa,EACrB,eAAe,EAAE,iBAAiB,EAClC,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,6BAA6B,GAAG,SAAS,KAC7C,OAAO,CAAC,OAAO,CAAC,CAAA;AAkBrB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,iBAAiB,EAClC,KAAK,EAAE,YAAY,GAClB,IAAI,CAGN;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,IAAI,CA0CvG;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,6BAA6B,GAAG,SAAS,EAChD,MAAM,EAAE,QAAQ,GACf,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAoB9B;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,aAAa,EACrB,wBAAwB,EAAE,iBAAiB,EAC3C,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,6BAA6B,GAAG,SAAS,EAChD,MAAM,EAAE,QAAQ,GACf,OAAO,CAAC;IAAE,KAAK,EAAE,uBAAuB,CAAC,OAAO,CAAC,CAAA;CAAE,CAAC,CAsDtD;AAqFD,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1B,KAAK,EAAE,uBAAuB,CAAC,OAAO,CAAC,GAAG,SAAS,GAClD,IAAI,CASN;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAGtE;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1B,KAAK,EAAE,uBAAuB,CAAC,OAAO,CAAC,GAAG,SAAS,GAClD,IAAI,CAUN;AAuHD;;;GAGG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,aAAa,EACrB,yBAAyB,EAAE,iBAAiB,EAC5C,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,6BAA6B,GAAG,SAAS,EAChD,MAAM,EAAE,QAAQ,GACf,OAAO,CAAC,OAAO,CAAC,CA4DlB"}

package/dist/extensions/instrumentation.js

@@ -69,7 +69,7 @@ async function captureToolCall(params) {
         throw error;
     }
     const finalResult = applyConversationInstructions(preparedEvent?.event ?? null, result, conversation, ownership);
-    publishSuccessfulToolEvent(server, preparedEvent, finalResult, startTime, data.logger, takeCapturedError);
+    publishSuccessfulToolEvent(server, preparedEvent, finalResult, startTime, data.logger, takeCapturedError, result);
     return finalResult;
 }
 function getActiveAnalyticsParameterOwnership(data, toolName, override, isMissingCapabilityTool) {
@@ -140,14 +140,14 @@ function applyConversationInstructions(event, result, conversation, ownership) {
     if (!delivered && conversation.minted && event) event.conversationId = void 0;
     return updated;
 }
-function publishSuccessfulToolEvent(server, preparedEvent, result, startTime, logger, takeCapturedError) {
+function publishSuccessfulToolEvent(server, preparedEvent, result, startTime, logger, takeCapturedError, resultBeforeInstructions) {
     if (!preparedEvent) return;
     const { event, requestAttribution } = preparedEvent;
     try {
         if ((0, external_tracing_helpers_js_namespaceObject.isToolResultError)(result)) {
             event.isError = true;
             const capturedError = takeCapturedError?.();
-            event.error = (0, external_exceptions_js_namespaceObject.captureException)(capturedError ?? result);
+            event.error = (0, external_exceptions_js_namespaceObject.captureException)(capturedError ?? resultBeforeInstructions ?? result);
         } else event.isError = false;
         event.response = result;
         event.duration = Date.now() - startTime.getTime();
@@ -329,6 +329,7 @@ function mintStatelessSessionOnInitialize(server, data, request, extra) {
     try {
         const headers = (0, external_request_headers_js_namespaceObject.getRequestHeaders)(extra);
         if (!headers) return;
+        if ((0, external_session_js_namespaceObject.isModernEraRequest)(request, extra, server)) return;
         if ((0, external_session_token_js_namespaceObject.readMcpSessionHeader)(headers)) return;
         const transport = server.transport;
         if (!transport || extra?.sessionId || transport.sessionId) return;

package/dist/extensions/instrumentation.mjs

@@ -12,7 +12,7 @@ import { getServerTrackingData, handleIdentify, setServerTrackingData, withIdent
 import { buildCapturedMcpParameters } from "./mcp-payloads.mjs";
 import { readRequestHandlerMethod } from "./mcp-sdk-compat.mjs";
 import { getRequestHeaders } from "./request-headers.mjs";
-import { getSessionId, getSessionInfo, newSessionId } from "./session.mjs";
+import { getSessionId, getSessionInfo, isModernEraRequest, newSessionId } from "./session.mjs";
 import { encodeSessionId, readMcpSessionHeader, writeSessionIdToTransport } from "./session-token.mjs";
 import { getReportMissingToolDescriptor, resolveMissingCapabilityToolName } from "./tools.mjs";
 import { applyResolvedMetadata, isToolResultError } from "./tracing-helpers.mjs";
@@ -33,7 +33,7 @@ async function captureToolCall(params) {
         throw error;
     }
     const finalResult = applyConversationInstructions(preparedEvent?.event ?? null, result, conversation, ownership);
-    publishSuccessfulToolEvent(server, preparedEvent, finalResult, startTime, data.logger, takeCapturedError);
+    publishSuccessfulToolEvent(server, preparedEvent, finalResult, startTime, data.logger, takeCapturedError, result);
     return finalResult;
 }
 function getActiveAnalyticsParameterOwnership(data, toolName, override, isMissingCapabilityTool) {
@@ -104,14 +104,14 @@ function applyConversationInstructions(event, result, conversation, ownership) {
     if (!delivered && conversation.minted && event) event.conversationId = void 0;
     return updated;
 }
-function publishSuccessfulToolEvent(server, preparedEvent, result, startTime, logger, takeCapturedError) {
+function publishSuccessfulToolEvent(server, preparedEvent, result, startTime, logger, takeCapturedError, resultBeforeInstructions) {
     if (!preparedEvent) return;
     const { event, requestAttribution } = preparedEvent;
     try {
         if (isToolResultError(result)) {
             event.isError = true;
             const capturedError = takeCapturedError?.();
-            event.error = captureException(capturedError ?? result);
+            event.error = captureException(capturedError ?? resultBeforeInstructions ?? result);
         } else event.isError = false;
         event.response = result;
         event.duration = Date.now() - startTime.getTime();
@@ -293,6 +293,7 @@ function mintStatelessSessionOnInitialize(server, data, request, extra) {
     try {
         const headers = getRequestHeaders(extra);
         if (!headers) return;
+        if (isModernEraRequest(request, extra, server)) return;
         if (readMcpSessionHeader(headers)) return;
         const transport = server.transport;
         if (!transport || extra?.sessionId || transport.sessionId) return;

package/dist/extensions/session.d.ts

@@ -1,4 +1,28 @@
-import type { CompatibleRequestHandlerExtra, MCPAnalyticsData, MCPServerLike, SessionInfo } from '../types';
+import type { CompatibleRequestHandlerExtra, MCPAnalyticsData, MCPRequestLike, MCPServerLike, SessionInfo } from '../types';
+/**
+ * The revision that removed protocol-level sessions. A request declaring this or
+ * anything later must not be answered with an `Mcp-Session-Id`.
+ *
+ * Compared as a string, which is safe and stable because MCP revisions are
+ * ISO dates: any future revision sorts above this one and is treated as modern,
+ * which is the right default — sessions were removed, not re-added.
+ */
+export declare const MODERN_PROTOCOL_REVISION = "2026-07-28";
+/**
+ * Whether *this request* is governed by 2026-07-28 or later.
+ *
+ * Era is a property of the request, never of the installed SDK: one v2 server
+ * serves both, request by request, and v2's exported `LATEST_PROTOCOL_VERSION`
+ * still reads `2025-11-25`. So the version is resolved from the request itself —
+ * an `initialize` body declares the version it is asking for, and every other
+ * request carries it in the envelope, `_meta`, or the `MCP-Protocol-Version`
+ * header — and only then compared.
+ *
+ * Unknown means legacy. A request that declares nothing is a v1 client on a
+ * transport that has always had a session header, and taking it away from them
+ * would be the regression.
+ */
+export declare function isModernEraRequest(request: MCPRequestLike, extra?: CompatibleRequestHandlerExtra, server?: MCPServerLike): boolean;
 export declare function newSessionId(): string;
 /**
  * Derives the SDK session id deterministically from the MCP sessionId, so the

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

@@ -1 +1 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/extensions/session.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,6BAA6B,EAC7B,gBAAgB,EAChB,aAAa,EAEb,WAAW,EACZ,MAAM,UAAU,CAAA;AAQjB,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAE1E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,+BAA+B,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAE9E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,aAAa,EACrB,KAAK,CAAC,EAAE,6BAA6B,EACrC,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM,CAgCR;AAuED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,gBAAgB,GAAG,SAAS,EAClC,SAAS,CAAC,EAAE,MAAM,GACjB,WAAW,CAmCb"}
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/extensions/session.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,6BAA6B,EAC7B,gBAAgB,EAChB,cAAc,EACd,aAAa,EAEb,WAAW,EACZ,MAAM,UAAU,CAAA;AASjB;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,eAAe,CAAA;AAcpD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,cAAc,EACvB,KAAK,CAAC,EAAE,6BAA6B,EACrC,MAAM,CAAC,EAAE,aAAa,GACrB,OAAO,CAYT;AAED,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAE1E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,+BAA+B,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAE9E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,aAAa,EACrB,KAAK,CAAC,EAAE,6BAA6B,EACrC,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM,CAgCR;AAuED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,gBAAgB,GAAG,SAAS,EAClC,SAAS,CAAC,EAAE,MAAM,GACjB,WAAW,CAmCb"}

package/dist/extensions/session.js

@@ -24,18 +24,35 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    isModernEraRequest: ()=>isModernEraRequest,
     deriveSessionIdFromConversation: ()=>deriveSessionIdFromConversation,
-    getSessionId: ()=>getSessionId,
+    newSessionId: ()=>newSessionId,
+    MODERN_PROTOCOL_REVISION: ()=>MODERN_PROTOCOL_REVISION,
     deriveSessionIdFromMCPSession: ()=>deriveSessionIdFromMCPSession,
-    getSessionInfo: ()=>getSessionInfo,
-    newSessionId: ()=>newSessionId
+    getSessionId: ()=>getSessionId,
+    getSessionInfo: ()=>getSessionInfo
 });
 const external_version_js_namespaceObject = require("../version.js");
 const external_constants_js_namespaceObject = require("./constants.js");
 const external_ids_js_namespaceObject = require("./ids.js");
+const external_client_identity_js_namespaceObject = require("./client-identity.js");
 const external_internal_js_namespaceObject = require("./internal.js");
 const external_request_headers_js_namespaceObject = require("./request-headers.js");
 const external_session_token_js_namespaceObject = require("./session-token.js");
+const MODERN_PROTOCOL_REVISION = '2026-07-28';
+const REVISION_SHAPE = /^\d{4}-\d{2}-\d{2}$/;
+const DRAFT_REVISION = 'draft';
+function isModernEraRequest(request, extra, server) {
+    const requested = request.params?.protocolVersion;
+    const version = ('string' == typeof requested && requested.length > 0 ? requested : void 0) ?? (0, external_client_identity_js_namespaceObject.resolveClientIdentity)({
+        request,
+        extra,
+        server
+    })?.protocolVersion;
+    if (!version) return false;
+    if (version === DRAFT_REVISION) return true;
+    return REVISION_SHAPE.test(version) && version >= MODERN_PROTOCOL_REVISION;
+}
 function newSessionId() {
     return (0, external_ids_js_namespaceObject.newPrefixedId)('ses');
 }
@@ -111,16 +128,20 @@ function getSessionInfo(server, data, sessionId) {
         ...sessionInfo
     };
 }
+exports.MODERN_PROTOCOL_REVISION = __webpack_exports__.MODERN_PROTOCOL_REVISION;
 exports.deriveSessionIdFromConversation = __webpack_exports__.deriveSessionIdFromConversation;
 exports.deriveSessionIdFromMCPSession = __webpack_exports__.deriveSessionIdFromMCPSession;
 exports.getSessionId = __webpack_exports__.getSessionId;
 exports.getSessionInfo = __webpack_exports__.getSessionInfo;
+exports.isModernEraRequest = __webpack_exports__.isModernEraRequest;
 exports.newSessionId = __webpack_exports__.newSessionId;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "MODERN_PROTOCOL_REVISION",
     "deriveSessionIdFromConversation",
     "deriveSessionIdFromMCPSession",
     "getSessionId",
     "getSessionInfo",
+    "isModernEraRequest",
     "newSessionId"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {

package/dist/extensions/session.mjs

@@ -1,9 +1,24 @@
-import { version } from "../version.mjs";
+import { version as external_version_mjs_version } from "../version.mjs";
 import { INACTIVITY_TIMEOUT_IN_MINUTES } from "./constants.mjs";
 import { deterministicPrefixedId, newPrefixedId } from "./ids.mjs";
+import { resolveClientIdentity } from "./client-identity.mjs";
 import { getServerTrackingData, setServerTrackingData } from "./internal.mjs";
 import { getRequestHeaders } from "./request-headers.mjs";
 import { decodeSessionId, readMcpSessionHeader } from "./session-token.mjs";
+const MODERN_PROTOCOL_REVISION = '2026-07-28';
+const REVISION_SHAPE = /^\d{4}-\d{2}-\d{2}$/;
+const DRAFT_REVISION = 'draft';
+function isModernEraRequest(request, extra, server) {
+    const requested = request.params?.protocolVersion;
+    const version = ('string' == typeof requested && requested.length > 0 ? requested : void 0) ?? resolveClientIdentity({
+        request,
+        extra,
+        server
+    })?.protocolVersion;
+    if (!version) return false;
+    if (version === DRAFT_REVISION) return true;
+    return REVISION_SHAPE.test(version) && version >= MODERN_PROTOCOL_REVISION;
+}
 function newSessionId() {
     return newPrefixedId('ses');
 }
@@ -62,7 +77,7 @@ function getSessionInfo(server, data, sessionId) {
     const sessionInfo = {
         ipAddress: void 0,
         sdkLanguage: 'TypeScript',
-        sdkVersion: version,
+        sdkVersion: external_version_mjs_version,
         serverName: server._serverInfo?.name,
         serverVersion: server._serverInfo?.version,
         clientName: clientInfo?.name,
@@ -79,4 +94,4 @@ function getSessionInfo(server, data, sessionId) {
         ...sessionInfo
     };
 }
-export { deriveSessionIdFromConversation, deriveSessionIdFromMCPSession, getSessionId, getSessionInfo, newSessionId };
+export { MODERN_PROTOCOL_REVISION, deriveSessionIdFromConversation, deriveSessionIdFromMCPSession, getSessionId, getSessionInfo, isModernEraRequest, newSessionId };

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "0.11.2";
+export declare const version = "0.11.4";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -26,7 +26,7 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     version: ()=>version
 });
-const version = '0.11.2';
+const version = '0.11.4';
 exports.version = __webpack_exports__.version;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "version"

package/dist/version.mjs

@@ -1,2 +1,2 @@
-const version = '0.11.2';
+const version = '0.11.4';
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/mcp",
-  "version": "0.11.2",
+  "version": "0.11.4",
   "bugs": {
     "url": "https://github.com/PostHog/posthog-js/issues"
   },

package/src/extensions/client-identity.ts

@@ -1,5 +1,7 @@
 import type { CompatibleRequestHandlerExtra, McpEvent, MCPRequestLike, MCPServerLike } from '../types'
 import { hasClientVersionAccessor, hasNegotiatedProtocolVersionAccessor } from './detect'
+import { readHeaderValue } from './headers'
+import { getRequestHeaders } from './request-headers'
 
 /**
  * Client identity — who is calling, and which spec revision they speak.
@@ -13,7 +15,11 @@ import { hasClientVersionAccessor, hasNegotiatedProtocolVersionAccessor } from '
  *      the time a handler runs they are here and `params._meta` is empty.
  *   2. `request.params._meta` — where 2026-07-28 puts them on the wire, and
  *      where they still are on any server that does not lift them.
- *   3. the server's own accessors — `getClientVersion()` from a legacy
+ *   3. the `MCP-Protocol-Version` request header, which 2025-11-25 requires a
+ *      client to send on every request after `initialize` — the only per-request
+ *      carrier a legacy-era request has, and therefore the only one that
+ *      survives a per-request server instance.
+ *   4. the server's own accessors — `getClientVersion()` from a legacy
  *      `initialize` handshake, `getNegotiatedProtocolVersion()` on v2.
  *
  * The 2026-07-28 revision removed the `initialize` handshake and the
@@ -24,6 +30,10 @@ import { hasClientVersionAccessor, hasNegotiatedProtocolVersionAccessor } from '
  */
 export const META_CLIENT_INFO_KEY = 'io.modelcontextprotocol/clientInfo'
 export const META_PROTOCOL_VERSION_KEY = 'io.modelcontextprotocol/protocolVersion'
+/** Required on every post-`initialize` request by 2025-11-25 (and sent by modern clients too). */
+export const PROTOCOL_VERSION_HEADER = 'mcp-protocol-version'
+/** A version string is a date-like token; anything longer is junk we should not record. */
+const MAX_PROTOCOL_VERSION_LENGTH = 64
 
 export interface MetaClientInfo {
   clientName?: string
@@ -100,6 +110,28 @@ export function readEnvelopeClientInfo(extra: CompatibleRequestHandlerExtra | un
   return readReservedKeys((extra as { mcpReq?: { envelope?: unknown } } | undefined)?.mcpReq?.envelope)
 }
 
+/**
+ * Reads the protocol version off the request headers.
+ *
+ * This is what closes the gap on **2025-11-25 traffic served by a per-request
+ * server**: that era carries identity at the handshake, and the instance
+ * handling a later `tools/call` never saw it. The header rides every request, so
+ * it survives where the handshake does not. Carries no client name — that still
+ * depends on the replayed session token.
+ */
+export function readHeaderProtocolVersion(
+  extra: CompatibleRequestHandlerExtra | undefined
+): MetaClientInfo | undefined {
+  // `getRequestHeaders` answers *where* the headers are on either SDK major;
+  // `readHeaderValue` answers how to read one value out of the bag it returns —
+  // repeated values, mixed case, blank strings. Two questions, one place each.
+  const protocolVersion = readHeaderValue(getRequestHeaders(extra), PROTOCOL_VERSION_HEADER)
+  if (!protocolVersion || protocolVersion.length > MAX_PROTOCOL_VERSION_LENGTH) {
+    return undefined
+  }
+  return { protocolVersion }
+}
+
 /**
  * Asks the server itself. `getClientVersion()` answers on any server that
  * handled an `initialize` (and v2 hosts such as `createMcpHandler` backfill it
@@ -148,7 +180,12 @@ export function readServerClientIdentity(server: unknown): MetaClientInfo | unde
  * keeps it a fallback: any request that identifies itself wins outright.
  */
 export function resolveClientIdentity({ request, extra, server }: ClientIdentitySources): MetaClientInfo | undefined {
-  const chain = [readEnvelopeClientInfo(extra), readMetaClientInfo(request), readServerClientIdentity(server)]
+  const chain = [
+    readEnvelopeClientInfo(extra),
+    readMetaClientInfo(request),
+    readHeaderProtocolVersion(extra),
+    readServerClientIdentity(server),
+  ]
   const result: MetaClientInfo = {}
   for (const source of chain) {
     if (!source) {

package/src/extensions/instrumentation.ts

@@ -35,7 +35,7 @@ import type { LoggerFn } from './logger'
 import { buildCapturedMcpParameters } from './mcp-payloads'
 import { readRequestHandlerMethod } from './mcp-sdk-compat'
 import { getRequestHeaders } from './request-headers'
-import { getSessionId, getSessionInfo, newSessionId } from './session'
+import { getSessionId, getSessionInfo, isModernEraRequest, newSessionId } from './session'
 import { encodeSessionId, readMcpSessionHeader, writeSessionIdToTransport } from './session-token'
 import { getReportMissingToolDescriptor, resolveMissingCapabilityToolName } from './tools'
 import { applyResolvedMetadata, isToolResultError } from './tracing-helpers'
@@ -139,7 +139,9 @@ export async function captureToolCall(params: TraceToolCallParams): Promise<unkn
   }
 
   const finalResult = applyConversationInstructions(preparedEvent?.event ?? null, result, conversation, ownership)
-  publishSuccessfulToolEvent(server, preparedEvent, finalResult, startTime, data.logger, takeCapturedError)
+  // `result`, not `finalResult`: the error is read from what the tool produced,
+  // before the conversation handle was written into it. See below.
+  publishSuccessfulToolEvent(server, preparedEvent, finalResult, startTime, data.logger, takeCapturedError, result)
   return finalResult
 }
 
@@ -288,13 +290,26 @@ function applyConversationInstructions(
   return updated
 }
 
+/**
+ * @param result - what the caller receives, conversation handle included.
+ * @param resultBeforeInstructions - the same result as the tool produced it.
+ *
+ * The two differ once `enableConversationId` mints a handle, and the difference
+ * matters for errors. A tool that fails returns its message in `content`, and on
+ * MCP SDK v2 that flattened `isError` result is the only description of the
+ * failure we get — the throw never reaches our callback wrapper. Reading the
+ * error off the *delivered* result would therefore append the prompt-back to it,
+ * putting a fresh uuid inside `$mcp_error_message` on every failed call and
+ * splitting one recurring failure into as many groups as there were calls.
+ */
 function publishSuccessfulToolEvent(
   server: MCPServerLike,
   preparedEvent: PreparedToolEvent | null,
   result: unknown,
   startTime: Date,
   logger: LoggerFn,
-  takeCapturedError?: () => unknown
+  takeCapturedError?: () => unknown,
+  resultBeforeInstructions?: unknown
 ): void {
   if (!preparedEvent) {
     return
@@ -304,7 +319,7 @@ function publishSuccessfulToolEvent(
     if (isToolResultError(result)) {
       event.isError = true
       const capturedError = takeCapturedError?.()
-      event.error = captureException(capturedError ?? result)
+      event.error = captureException(capturedError ?? resultBeforeInstructions ?? result)
     } else {
       event.isError = false
     }
@@ -699,6 +714,14 @@ function mintStatelessSessionOnInitialize(
     if (!headers) {
       return undefined // not an HTTP transport (stdio/in-memory) — nothing to mint into
     }
+    // 2026-07-28 removed sessions from the protocol: a server MUST NOT mint or
+    // echo `Mcp-Session-Id` under it. Today that era never reaches here anyway,
+    // because it has no `initialize` — but relying on that is relying on an SDK
+    // routing detail to keep us spec-compliant, so the era is asked directly.
+    // Per request, never per server: the same v2 server serves both.
+    if (isModernEraRequest(request, extra, server)) {
+      return undefined
+    }
     if (readMcpSessionHeader(headers)) {
       return undefined // client already replays a session id (ours or the transport's)
     }

package/src/extensions/session.ts

@@ -7,17 +7,73 @@ import { version } from '../version'
 import type {
   CompatibleRequestHandlerExtra,
   MCPAnalyticsData,
+  MCPRequestLike,
   MCPServerLike,
   ServerClientInfoLike,
   SessionInfo,
 } from '../types'
 import { INACTIVITY_TIMEOUT_IN_MINUTES } from './constants'
 import { deterministicPrefixedId, newPrefixedId } from './ids'
+import { resolveClientIdentity } from './client-identity'
 import { getServerTrackingData, setServerTrackingData } from './internal'
 import { getRequestHeaders } from './request-headers'
 import { decodeSessionId, readMcpSessionHeader } from './session-token'
 import type { SessionTokenPayload } from './session-token'
 
+/**
+ * The revision that removed protocol-level sessions. A request declaring this or
+ * anything later must not be answered with an `Mcp-Session-Id`.
+ *
+ * Compared as a string, which is safe and stable because MCP revisions are
+ * ISO dates: any future revision sorts above this one and is treated as modern,
+ * which is the right default — sessions were removed, not re-added.
+ */
+export const MODERN_PROTOCOL_REVISION = '2026-07-28'
+
+/**
+ * Revisions are ISO dates, and only a date-shaped token may be compared as one.
+ * Without this the comparison is lexicographic over arbitrary input, so any
+ * string starting above `'2'` — every junk value beginning with a letter —
+ * sorts as modern and silently loses the session header. Unknown must mean
+ * legacy, so anything that is not a date is not compared at all.
+ */
+const REVISION_SHAPE = /^\d{4}-\d{2}-\d{2}$/
+
+/** The spec's rolling draft sits ahead of every dated revision, sessions included. */
+const DRAFT_REVISION = 'draft'
+
+/**
+ * Whether *this request* is governed by 2026-07-28 or later.
+ *
+ * Era is a property of the request, never of the installed SDK: one v2 server
+ * serves both, request by request, and v2's exported `LATEST_PROTOCOL_VERSION`
+ * still reads `2025-11-25`. So the version is resolved from the request itself —
+ * an `initialize` body declares the version it is asking for, and every other
+ * request carries it in the envelope, `_meta`, or the `MCP-Protocol-Version`
+ * header — and only then compared.
+ *
+ * Unknown means legacy. A request that declares nothing is a v1 client on a
+ * transport that has always had a session header, and taking it away from them
+ * would be the regression.
+ */
+export function isModernEraRequest(
+  request: MCPRequestLike,
+  extra?: CompatibleRequestHandlerExtra,
+  server?: MCPServerLike
+): boolean {
+  const requested = request.params?.protocolVersion
+  const version =
+    (typeof requested === 'string' && requested.length > 0 ? requested : undefined) ??
+    resolveClientIdentity({ request, extra, server })?.protocolVersion
+  if (!version) {
+    return false
+  }
+  if (version === DRAFT_REVISION) {
+    return true
+  }
+  return REVISION_SHAPE.test(version) && version >= MODERN_PROTOCOL_REVISION
+}
+
 export function newSessionId(): string {
   return newPrefixedId('ses')
 }

package/src/version.ts

@@ -1 +1 @@
-export const version = '0.11.2'
+export const version = '0.11.4'