@posthog/mcp 0.10.7 → 0.10.9

package/dist/extensions/instrumentation.mjs

@@ -2,13 +2,14 @@ import { getAnalyticsParameterOwnership, stripOwnedAnalyticsArguments } from "./
 import { addContextParameterToTools, getContextDescription, isContextEnabled } from "./context-parameters.mjs";
 import { addConversationIdToTools, canInjectConversationIdPromptBack, injectConversationIdPromptBack, resolveConversationId } from "./conversation-id.mjs";
 import { stampMetaClientInfo } from "./client-identity.mjs";
+import { addInstructionsToOutputSchemas, mirrorInstructionsIntoStructuredContent } from "./output-instructions.mjs";
 import { captureEvent } from "./capture.mjs";
 import { MCPAnalyticsEventType } from "./event-types.mjs";
 import { captureException } from "./exceptions.mjs";
 import { resolveToolCallIntent, setEventIntent, setExplicitContextIntent } from "./intent.mjs";
 import { getServerTrackingData, handleIdentify, setServerTrackingData, withIdentity } from "./internal.mjs";
 import { buildCapturedMcpParameters } from "./mcp-payloads.mjs";
-import { getLiteralValue, getObjectShape } from "./mcp-sdk-compat.mjs";
+import { readRequestHandlerMethod } from "./mcp-sdk-compat.mjs";
 import { getSessionId, getSessionInfo, newSessionId } from "./session.mjs";
 import { encodeSessionId, readMcpSessionHeader, writeSessionIdToTransport } from "./session-token.mjs";
 import { getReportMissingToolDescriptor, resolveMissingCapabilityToolName } from "./tools.mjs";
@@ -17,7 +18,7 @@ async function captureToolCall(params) {
     const { server, data, request, extra, execute, parameterOwnership, eventType, explicitContextIntent, takeCapturedError } = params;
     const resolvedEventType = eventType ?? MCPAnalyticsEventType.mcpToolsCall;
     const ownership = getActiveAnalyticsParameterOwnership(data, request.params?.name, parameterOwnership, resolvedEventType === MCPAnalyticsEventType.mcpMissingCapability);
-    const conversation = resolveConversationId(ownership.conversationId, request.params?.arguments, request.params?.name, resolvedEventType === MCPAnalyticsEventType.mcpMissingCapability ? resolveMissingCapabilityToolName(data.options) : '');
+    const conversation = resolveConversationId(ownership.conversationId, request.params?.arguments);
     const downstreamRequest = cloneRequestWithoutOwnedAnalyticsArguments(request, ownership);
     const startTime = new Date();
     const preparedEvent = await prepareToolCallEvent(server, data, request, downstreamRequest, extra, startTime, conversation, ownership, resolvedEventType);
@@ -29,15 +30,17 @@ async function captureToolCall(params) {
         publishFailedToolEvent(server, preparedEvent, error, startTime, conversation, data.logger);
         throw error;
     }
-    const finalResult = applyConversationPromptBack(preparedEvent?.event ?? null, result, conversation);
+    const finalResult = applyConversationInstructions(preparedEvent?.event ?? null, result, conversation, ownership);
     publishSuccessfulToolEvent(server, preparedEvent, finalResult, startTime, data.logger, takeCapturedError);
     return finalResult;
 }
 function getActiveAnalyticsParameterOwnership(data, toolName, override, isMissingCapabilityTool) {
-    const ownership = override ?? (toolName ? data.toolAnalyticsParameterOwnership.get(toolName) : void 0);
+    const listed = toolName ? data.toolAnalyticsParameterOwnership.get(toolName) : void 0;
+    const ownership = override ?? listed;
     return {
         context: !isMissingCapabilityTool && isContextEnabled(data.options.context) && ownership?.context === true,
-        conversationId: !isMissingCapabilityTool && true === data.options.enableConversationId && ownership?.conversationId === true
+        conversationId: true === data.options.enableConversationId && ownership?.conversationId === true,
+        outputInstructions: true === data.options.enableConversationId && listed?.outputInstructions === true
     };
 }
 function cloneRequestWithoutOwnedAnalyticsArguments(request, ownership) {
@@ -54,9 +57,9 @@ function cloneRequestWithoutOwnedAnalyticsArguments(request, ownership) {
 }
 async function prepareToolCallEvent(server, data, request, downstreamRequest, extra, startTime, conversation, ownership, eventType) {
     try {
-        const sessionId = getSessionId(server, extra);
+        const sessionId = getSessionId(server, extra, conversation.conversationId);
         const sessionInfo = getSessionInfo(server, data, sessionId);
-        const identity = await handleIdentify(server, data, sessionId, request, sessionInfo, extra);
+        const identity = await handleIdentify(server, data, sessionId, request, sessionInfo, extra, !!conversation.conversationId);
         const requestAttribution = withIdentity(sessionInfo, identity);
         const toolName = request.params?.name;
         const event = {
@@ -81,11 +84,22 @@ async function prepareToolCallEvent(server, data, request, downstreamRequest, ex
         return null;
     }
 }
-function applyConversationPromptBack(event, result, conversation) {
-    if (!conversation.minted) return result;
-    if (canInjectConversationIdPromptBack(result)) return injectConversationIdPromptBack(result, conversation.conversationId);
-    if (event) event.conversationId = void 0;
-    return result;
+function applyConversationInstructions(event, result, conversation, ownership) {
+    const conversationId = conversation.conversationId;
+    if (!conversationId) return result;
+    let updated = result;
+    let delivered = false;
+    if (ownership.outputInstructions) {
+        const mirrored = mirrorInstructionsIntoStructuredContent(updated, conversationId);
+        delivered = mirrored !== updated;
+        updated = mirrored;
+    }
+    if (conversation.minted && canInjectConversationIdPromptBack(updated)) {
+        updated = injectConversationIdPromptBack(updated, conversationId);
+        delivered = true;
+    }
+    if (!delivered && conversation.minted && event) event.conversationId = void 0;
+    return updated;
 }
 function publishSuccessfulToolEvent(server, preparedEvent, result, startTime, logger, takeCapturedError) {
     if (!preparedEvent) return;
@@ -125,6 +139,10 @@ function rememberOriginalRequestHandler(server, handlerName, originalHandler) {
     }
     handlers.set(handlerName, originalHandler);
 }
+function registerFallbackRequestHandler(server, handlerName, fallbackHandler, patch) {
+    rememberOriginalRequestHandler(server, handlerName, fallbackHandler);
+    server._requestHandlers.set(handlerName, (request, extra)=>patch(server, fallbackHandler, request, extra));
+}
 function patchRequestHandlers(server, patches) {
     for (const [handlerName, patch] of Object.entries(patches)){
         const originalHandler = server._requestHandlers.get(handlerName);
@@ -134,12 +152,11 @@ function patchRequestHandlers(server, patches) {
         }
     }
     const originalSetRequestHandler = server.setRequestHandler.bind(server);
-    server.setRequestHandler = (requestSchema, originalHandler)=>{
-        const shape = getObjectShape(requestSchema);
-        const handlerName = shape?.method ? getLiteralValue(shape.method) : void 0;
-        const patch = 'string' == typeof handlerName ? patches[handlerName] : void 0;
-        if (!patch || 'string' != typeof handlerName) return originalSetRequestHandler(requestSchema, originalHandler);
-        const result = originalSetRequestHandler(requestSchema, originalHandler);
+    server.setRequestHandler = (...args)=>{
+        const handlerName = readRequestHandlerMethod(args[0]);
+        const patch = void 0 !== handlerName && Object.prototype.hasOwnProperty.call(patches, handlerName) ? patches[handlerName] : void 0;
+        if (void 0 === handlerName || !patch) return originalSetRequestHandler(...args);
+        const result = originalSetRequestHandler(...args);
         const registeredHandler = server._requestHandlers.get(handlerName);
         if (registeredHandler) {
             rememberOriginalRequestHandler(server, handlerName, registeredHandler);
@@ -205,7 +222,7 @@ async function handleListToolsRequest(server, originalListToolsHandler, request,
     };
 }
 function cacheToolAnalyticsParameterOwnership(cache, tools) {
-    for (const tool of tools)if (tool?.name) cache.set(tool.name, getAnalyticsParameterOwnership(tool.inputSchema));
+    for (const tool of tools)if (tool?.name) cache.set(tool.name, getAnalyticsParameterOwnership(tool.inputSchema, tool.outputSchema));
 }
 function collectListedToolNames(tools) {
     if (!tools || 0 === tools.length) return;
@@ -223,16 +240,21 @@ async function getTracedToolsList(server, originalListToolsHandler, request, ext
         if (data && isContextEnabled(data.options.context)) tools = addContextParameterToTools(tools, getContextDescription(data.options.context), data.logger);
         if (data) {
             const missingToolName = resolveMissingCapabilityToolName(data.options);
-            let injectedMissingCapabilityTool = false;
             if (data.options.reportMissing) {
                 const alreadyPresent = tools.some((tool)=>tool?.name === missingToolName);
                 if (alreadyPresent) data.logger(`Warning: Cannot inject missing-capability tool "${missingToolName}" because a real tool already uses that name. The real tool will not be intercepted.`);
                 else {
-                    tools.push(getReportMissingToolDescriptor(missingToolName));
-                    injectedMissingCapabilityTool = true;
+                    const virtualTool = getReportMissingToolDescriptor(missingToolName);
+                    tools.push(virtualTool);
+                    cacheToolAnalyticsParameterOwnership(data.toolAnalyticsParameterOwnership, [
+                        virtualTool
+                    ]);
                 }
             }
-            if (data.options.enableConversationId) tools = addConversationIdToTools(tools, missingToolName, injectedMissingCapabilityTool, data.logger);
+            if (data.options.enableConversationId) {
+                tools = addConversationIdToTools(tools, data.logger);
+                tools = addInstructionsToOutputSchemas(tools, data.logger);
+            }
         }
         if (data) {
             cacheToolDescriptions(data.toolDescriptions, tools);
@@ -367,4 +389,4 @@ function readProtocolVersion(result, request) {
     const requested = request.params?.protocolVersion;
     return 'string' == typeof requested && requested.length > 0 ? requested : void 0;
 }
-export { cacheToolCategories, cacheToolDescriptions, captureToolCall, handleInitializeRequest, handleListToolsRequest, isToolAdvertised, patchRequestHandlers, readToolMetaCategory };
+export { cacheToolCategories, cacheToolDescriptions, captureToolCall, handleInitializeRequest, handleListToolsRequest, isToolAdvertised, patchRequestHandlers, readToolMetaCategory, registerFallbackRequestHandler };

package/dist/extensions/internal.d.ts

@@ -24,7 +24,14 @@ export declare function mergeIdentities(previous: UserIdentity | undefined, next
  * `$identify` event at most once per session: at `initialize`, when a
  * long-lived server first sees the identity, or when it materially changes.
  */
-export declare function handleIdentify(server: MCPServerLike, data: MCPAnalyticsData, sessionId: string, request: MCPRequestLike, requestAttribution: SessionInfo, extra?: CompatibleRequestHandlerExtra): Promise<UserIdentity | undefined>;
+export declare function handleIdentify(server: MCPServerLike, data: MCPAnalyticsData, sessionId: string, request: MCPRequestLike, requestAttribution: SessionInfo, extra?: CompatibleRequestHandlerExtra, 
+/**
+ * True when this session id came from an agent-carried `conversation_id`
+ * rather than the transport. Such a session is brand new and was never
+ * announced at `initialize`, whatever `data.sessionSource` still says about
+ * the connection.
+ */
+sessionFromConversation?: boolean): Promise<UserIdentity | undefined>;
 export declare function withIdentity(sessionInfo: SessionInfo, identity: UserIdentity | undefined): SessionInfo;
 /**
  * Resolves the `eventProperties` callback. Returns null when no callback is

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;AAKjB;;;;;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,GACpC,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAsDnC;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;AAKjB;;;;;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"}

package/dist/extensions/internal.js

@@ -95,7 +95,7 @@ function mergeIdentities(previous, next) {
         groups: next.groups ?? previous.groups
     };
 }
-async function handleIdentify(server, data, sessionId, request, requestAttribution, extra) {
+async function handleIdentify(server, data, sessionId, request, requestAttribution, extra, sessionFromConversation = false) {
     const identityBeforeRequest = data.identifiedSessions.get(sessionId);
     const sessionSourceBeforeIdentify = data.sessionSource;
     if (!data.options.identify) return identityBeforeRequest;
@@ -117,7 +117,7 @@ async function handleIdentify(server, data, sessionId, request, requestAttributi
             const mergedIdentity = mergeIdentities(previousIdentity, identityResult);
             const changed = void 0 !== previousIdentity && !areIdentitiesEqual(previousIdentity, mergedIdentity);
             const firstSeen = void 0 === previousIdentity;
-            const announcedAtInitialize = 'token' === sessionSourceBeforeIdentify && 'initialize' !== request.method;
+            const announcedAtInitialize = !sessionFromConversation && 'token' === sessionSourceBeforeIdentify && 'initialize' !== request.method;
             const shouldPublish = changed || firstSeen && !announcedAtInitialize;
             data.identifiedSessions.set(sessionId, mergedIdentity);
             if (shouldPublish) {

package/dist/extensions/internal.mjs

@@ -60,7 +60,7 @@ function mergeIdentities(previous, next) {
         groups: next.groups ?? previous.groups
     };
 }
-async function handleIdentify(server, data, sessionId, request, requestAttribution, extra) {
+async function handleIdentify(server, data, sessionId, request, requestAttribution, extra, sessionFromConversation = false) {
     const identityBeforeRequest = data.identifiedSessions.get(sessionId);
     const sessionSourceBeforeIdentify = data.sessionSource;
     if (!data.options.identify) return identityBeforeRequest;
@@ -82,7 +82,7 @@ async function handleIdentify(server, data, sessionId, request, requestAttributi
             const mergedIdentity = mergeIdentities(previousIdentity, identityResult);
             const changed = void 0 !== previousIdentity && !areIdentitiesEqual(previousIdentity, mergedIdentity);
             const firstSeen = void 0 === previousIdentity;
-            const announcedAtInitialize = 'token' === sessionSourceBeforeIdentify && 'initialize' !== request.method;
+            const announcedAtInitialize = !sessionFromConversation && 'token' === sessionSourceBeforeIdentify && 'initialize' !== request.method;
             const shouldPublish = changed || firstSeen && !announcedAtInitialize;
             data.identifiedSessions.set(sessionId, mergedIdentity);
             if (shouldPublish) {

package/dist/extensions/mcp-sdk-compat.d.ts

@@ -30,5 +30,15 @@ export declare function createWrappedTool(originalTool: RegisteredTool, wrappedF
 export declare function isZ4Schema(schema: unknown): boolean;
 export declare function isZodRawShapeCompat(schema: unknown): schema is Record<string, unknown>;
 export declare function getObjectShape(schema: unknown): Record<string, unknown> | undefined;
+/**
+ * Reads the method name a `setRequestHandler` registration is for.
+ *
+ * The two SDK majors disagree on what the first argument is: v1 passes the Zod
+ * schema for the request and carries the method as a literal on its shape, v2
+ * passes the method string itself. A registration we cannot name is one we
+ * cannot match against a patch — which is how a handler registered after
+ * `instrument()` on v2 ends up replacing our wrapper instead of being wrapped.
+ */
+export declare function readRequestHandlerMethod(requestSchema: unknown): string | undefined;
 export declare function getLiteralValue(schema: unknown): unknown;
 //# sourceMappingURL=mcp-sdk-compat.d.ts.map

package/dist/extensions/mcp-sdk-compat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-sdk-compat.d.ts","sourceRoot":"","sources":["../../src/extensions/mcp-sdk-compat.ts"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAK5D,MAAM,MAAM,eAAe,GAAG,UAAU,GAAG,SAAS,CAAA;AAEpD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,cAAc,GAAG,YAAY,CAQlE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,eAAe,CAKxE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,cAAc,CAMrE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,YAAY,GAAG,cAAc,CAM7G;AAyBD,wBAAgB,UAAU,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAKnD;AAaD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEtF;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CA6BnF;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAkCxD"}
+{"version":3,"file":"mcp-sdk-compat.d.ts","sourceRoot":"","sources":["../../src/extensions/mcp-sdk-compat.ts"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAK5D,MAAM,MAAM,eAAe,GAAG,UAAU,GAAG,SAAS,CAAA;AAEpD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,cAAc,GAAG,YAAY,CAQlE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,eAAe,CAKxE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,cAAc,CAMrE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,YAAY,GAAG,cAAc,CAM7G;AAyBD,wBAAgB,UAAU,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAKnD;AAaD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEtF;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CA6BnF;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CAAC,aAAa,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAOnF;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAkCxD"}

package/dist/extensions/mcp-sdk-compat.js

@@ -31,7 +31,8 @@ __webpack_require__.d(__webpack_exports__, {
     getToolFunctionKey: ()=>getToolFunctionKey,
     hasToolFunction: ()=>hasToolFunction,
     isZ4Schema: ()=>isZ4Schema,
-    isZodRawShapeCompat: ()=>isZodRawShapeCompat
+    isZodRawShapeCompat: ()=>isZodRawShapeCompat,
+    readRequestHandlerMethod: ()=>readRequestHandlerMethod
 });
 function getToolFunction(tool) {
     if ('handler' in tool && 'function' == typeof tool.handler) return tool.handler;
@@ -82,6 +83,12 @@ function getObjectShape(schema) {
     }
     return rawShape;
 }
+function readRequestHandlerMethod(requestSchema) {
+    if ('string' == typeof requestSchema) return requestSchema;
+    const shape = getObjectShape(requestSchema);
+    const method = shape?.method ? getLiteralValue(shape.method) : void 0;
+    return 'string' == typeof method ? method : void 0;
+}
 function getLiteralValue(schema) {
     if (!schema || 'object' != typeof schema) return;
     if (isZ4Schema(schema)) {
@@ -106,6 +113,7 @@ exports.getToolFunctionKey = __webpack_exports__.getToolFunctionKey;
 exports.hasToolFunction = __webpack_exports__.hasToolFunction;
 exports.isZ4Schema = __webpack_exports__.isZ4Schema;
 exports.isZodRawShapeCompat = __webpack_exports__.isZodRawShapeCompat;
+exports.readRequestHandlerMethod = __webpack_exports__.readRequestHandlerMethod;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "createWrappedTool",
     "getLiteralValue",
@@ -114,7 +122,8 @@ for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "getToolFunctionKey",
     "hasToolFunction",
     "isZ4Schema",
-    "isZodRawShapeCompat"
+    "isZodRawShapeCompat",
+    "readRequestHandlerMethod"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/extensions/mcp-sdk-compat.mjs

@@ -47,6 +47,12 @@ function getObjectShape(schema) {
     }
     return rawShape;
 }
+function readRequestHandlerMethod(requestSchema) {
+    if ('string' == typeof requestSchema) return requestSchema;
+    const shape = getObjectShape(requestSchema);
+    const method = shape?.method ? getLiteralValue(shape.method) : void 0;
+    return 'string' == typeof method ? method : void 0;
+}
 function getLiteralValue(schema) {
     if (!schema || 'object' != typeof schema) return;
     if (isZ4Schema(schema)) {
@@ -63,4 +69,4 @@ function getLiteralValue(schema) {
     const directValue = schema.value;
     if (void 0 !== directValue) return directValue;
 }
-export { createWrappedTool, getLiteralValue, getObjectShape, getToolFunction, getToolFunctionKey, hasToolFunction, isZ4Schema, isZodRawShapeCompat };
+export { createWrappedTool, getLiteralValue, getObjectShape, getToolFunction, getToolFunctionKey, hasToolFunction, isZ4Schema, isZodRawShapeCompat, readRequestHandlerMethod };

package/dist/extensions/output-instructions.d.ts

@@ -0,0 +1,70 @@
+import type { LoggerFn } from './logger';
+/**
+ * The `conversation_id` session handle reaches the agent as a text block appended to the
+ * tool result. That block is invisible to any client that reads
+ * `structuredContent` instead of `content` — which is what clients do whenever a
+ * tool declares an `outputSchema`. Measured against Claude Code, correlation for
+ * such tools drops to zero.
+ *
+ * The fix is to mirror the session handle into `structuredContent` as well, which this
+ * module does in two halves that must stay in that order:
+ *
+ *   1. declare `_mcp_instructions` on the tool's advertised `outputSchema`
+ *   2. write it into the result's `structuredContent`
+ *
+ * The declaration is what makes the write safe. The MCP client ajv-validates
+ * `structuredContent` against the schema from `tools/list`, and
+ * `zod-to-json-schema` emits `additionalProperties: false` for a plain
+ * `z.object`, so an undeclared key is not ignored — it fails the entire tool
+ * result. Only tools that got the declaration are ever written to.
+ */
+export declare const MCP_INSTRUCTIONS_KEY = "_mcp_instructions";
+export interface OutputInstructionsInjectableTool {
+    name?: string;
+    outputSchema?: unknown;
+    [key: string]: unknown;
+}
+/**
+ * True when we can safely declare {@link MCP_INSTRUCTIONS_KEY} on this tool's
+ * advertised output schema.
+ *
+ * Requires a plain-object schema we can extend. A tool with no `outputSchema`
+ * has nothing to mirror into and keeps working through `content`; a composed
+ * schema (`oneOf`/`allOf`/`anyOf`/`$ref`) has no single `properties` bag to add
+ * to. Both stay content-only, matching the policy on the input side.
+ */
+export declare function canDeclareOutputInstructions(outputSchema: unknown): boolean;
+/**
+ * Returns a copy of the tool with an optional {@link MCP_INSTRUCTIONS_KEY}
+ * property added to its output schema, or the tool untouched when it has no
+ * output schema to extend.
+ *
+ * The property is never added to `required` — a result without it must stay
+ * valid, since every tool result predating this change lacks it.
+ */
+export declare function addInstructionsToOutputSchema<TTool extends OutputInstructionsInjectableTool>(tool: TTool, logger?: LoggerFn): TTool;
+/**
+ * Declares {@link MCP_INSTRUCTIONS_KEY} across a tool listing. Tools without an
+ * output schema, and tools whose schema we cannot extend, pass through unchanged.
+ */
+export declare function addInstructionsToOutputSchemas<TTool extends OutputInstructionsInjectableTool>(tools: TTool[], logger?: LoggerFn): TTool[];
+export interface ConversationInstructions {
+    conversation_id: string;
+    instructions: string;
+}
+/** The payload mirrored into `structuredContent` for a tool we declared the key on. */
+export declare function buildConversationInstructions(conversationId: string): ConversationInstructions;
+/**
+ * Adds {@link MCP_INSTRUCTIONS_KEY} to a result's `structuredContent`, which is
+ * where clients look once a tool declares an `outputSchema` — the `content` text
+ * block carrying the session handle is invisible to them.
+ *
+ * Unlike the text block, this rides *every* response rather than only the one
+ * that minted the session handle, so an agent that drops it can read it back.
+ *
+ * Returns the result untouched when there is no plain-object `structuredContent`
+ * to extend, or when the tool already produced its own key — customer data wins.
+ * Never mutates the input.
+ */
+export declare function mirrorInstructionsIntoStructuredContent(result: unknown, conversationId: string): unknown;
+//# sourceMappingURL=output-instructions.d.ts.map

package/dist/extensions/output-instructions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-instructions.d.ts","sourceRoot":"","sources":["../../src/extensions/output-instructions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAIxC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,oBAAoB,sBAAsB,CAAA;AAQvD,MAAM,WAAW,gCAAgC;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAAC,YAAY,EAAE,OAAO,GAAG,OAAO,CAgC3E;AAwCD;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,SAAS,gCAAgC,EAC1F,IAAI,EAAE,KAAK,EACX,MAAM,GAAE,QAAc,GACrB,KAAK,CA8CP;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,KAAK,SAAS,gCAAgC,EAC3F,KAAK,EAAE,KAAK,EAAE,EACd,MAAM,GAAE,QAAc,GACrB,KAAK,EAAE,CAET;AAED,MAAM,WAAW,wBAAwB;IACvC,eAAe,EAAE,MAAM,CAAA;IACvB,YAAY,EAAE,MAAM,CAAA;CACrB;AAID,uFAAuF;AACvF,wBAAgB,6BAA6B,CAAC,cAAc,EAAE,MAAM,GAAG,wBAAwB,CAE9F;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uCAAuC,CAAC,MAAM,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAkBxG"}

package/dist/extensions/output-instructions.js

@@ -0,0 +1,131 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    mirrorInstructionsIntoStructuredContent: ()=>mirrorInstructionsIntoStructuredContent,
+    addInstructionsToOutputSchema: ()=>addInstructionsToOutputSchema,
+    addInstructionsToOutputSchemas: ()=>addInstructionsToOutputSchemas,
+    MCP_INSTRUCTIONS_KEY: ()=>MCP_INSTRUCTIONS_KEY,
+    buildConversationInstructions: ()=>buildConversationInstructions,
+    canDeclareOutputInstructions: ()=>canDeclareOutputInstructions
+});
+const external_logger_js_namespaceObject = require("./logger.js");
+const MCP_INSTRUCTIONS_KEY = '_mcp_instructions';
+const INSTRUCTIONS_FIELD_DESCRIPTION = 'Server-issued handles for this conversation, and what to do with them. Read and follow.';
+const CONVERSATION_ID_FIELD_DESCRIPTION = 'Echo this exact value as the conversation_id argument on every subsequent tool call.';
+function canDeclareOutputInstructions(outputSchema) {
+    if (!outputSchema || 'object' != typeof outputSchema) return false;
+    if (isSchemaObjectLike(outputSchema)) return false;
+    const schema = outputSchema;
+    if (schema.$ref || schema.oneOf || schema.allOf || schema.anyOf) return false;
+    const { properties } = schema;
+    if (void 0 !== properties && ('object' != typeof properties || null === properties || Array.isArray(properties))) return false;
+    return !properties || !Object.prototype.hasOwnProperty.call(properties, MCP_INSTRUCTIONS_KEY);
+}
+function isZodLike(entry) {
+    return !!entry && 'object' == typeof entry && ('_def' in entry || '_zod' in entry || '~standard' in entry);
+}
+function looksLikeJsonSchema(candidate) {
+    if ('string' == typeof candidate.type || 'string' == typeof candidate.$ref) return true;
+    if (Array.isArray(candidate.oneOf) || Array.isArray(candidate.allOf) || Array.isArray(candidate.anyOf)) return true;
+    const { properties } = candidate;
+    return !!properties && 'object' == typeof properties && !isZodLike(properties);
+}
+function isSchemaObjectLike(value) {
+    const candidate = value;
+    if (isZodLike(candidate)) return true;
+    if (looksLikeJsonSchema(candidate)) return false;
+    return Object.values(candidate).some(isZodLike);
+}
+function addInstructionsToOutputSchema(tool, logger = external_logger_js_namespaceObject.log) {
+    const toolName = tool.name || 'unknown';
+    const original = tool.outputSchema;
+    if (!original || 'object' != typeof original) return tool;
+    if (!canDeclareOutputInstructions(original)) {
+        const schema = original;
+        logger(schema.properties && Object.prototype.hasOwnProperty.call(schema.properties, MCP_INSTRUCTIONS_KEY) ? `WARN: Tool "${toolName}" already declares '${MCP_INSTRUCTIONS_KEY}' in its output schema. Leaving it alone.` : `WARN: Tool "${toolName}" has a complex output schema (oneOf/allOf/anyOf/$ref). Skipping '${MCP_INSTRUCTIONS_KEY}' declaration; its session handle stays content-only.`);
+        return tool;
+    }
+    const modifiedTool = {
+        ...tool
+    };
+    const outputSchema = JSON.parse(JSON.stringify(original));
+    if (!outputSchema.properties) outputSchema.properties = {};
+    outputSchema.properties[MCP_INSTRUCTIONS_KEY] = {
+        type: 'object',
+        description: INSTRUCTIONS_FIELD_DESCRIPTION,
+        properties: {
+            conversation_id: {
+                type: 'string',
+                description: CONVERSATION_ID_FIELD_DESCRIPTION
+            },
+            instructions: {
+                type: 'string'
+            }
+        }
+    };
+    modifiedTool.outputSchema = outputSchema;
+    return modifiedTool;
+}
+function addInstructionsToOutputSchemas(tools, logger = external_logger_js_namespaceObject.log) {
+    return tools.map((tool)=>addInstructionsToOutputSchema(tool, logger));
+}
+const ECHO_INSTRUCTION = 'Send this conversation_id as an argument on every subsequent tool call in this conversation.';
+function buildConversationInstructions(conversationId) {
+    return {
+        conversation_id: conversationId,
+        instructions: ECHO_INSTRUCTION
+    };
+}
+function mirrorInstructionsIntoStructuredContent(result, conversationId) {
+    if (!result || 'object' != typeof result) return result;
+    const structuredContent = result.structuredContent;
+    if (!structuredContent || 'object' != typeof structuredContent || Array.isArray(structuredContent)) return result;
+    if (Object.prototype.hasOwnProperty.call(structuredContent, MCP_INSTRUCTIONS_KEY)) return result;
+    return {
+        ...result,
+        structuredContent: {
+            ...structuredContent,
+            [MCP_INSTRUCTIONS_KEY]: buildConversationInstructions(conversationId)
+        }
+    };
+}
+exports.MCP_INSTRUCTIONS_KEY = __webpack_exports__.MCP_INSTRUCTIONS_KEY;
+exports.addInstructionsToOutputSchema = __webpack_exports__.addInstructionsToOutputSchema;
+exports.addInstructionsToOutputSchemas = __webpack_exports__.addInstructionsToOutputSchemas;
+exports.buildConversationInstructions = __webpack_exports__.buildConversationInstructions;
+exports.canDeclareOutputInstructions = __webpack_exports__.canDeclareOutputInstructions;
+exports.mirrorInstructionsIntoStructuredContent = __webpack_exports__.mirrorInstructionsIntoStructuredContent;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "MCP_INSTRUCTIONS_KEY",
+    "addInstructionsToOutputSchema",
+    "addInstructionsToOutputSchemas",
+    "buildConversationInstructions",
+    "canDeclareOutputInstructions",
+    "mirrorInstructionsIntoStructuredContent"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/output-instructions.mjs

@@ -0,0 +1,82 @@
+import { log } from "./logger.mjs";
+const MCP_INSTRUCTIONS_KEY = '_mcp_instructions';
+const INSTRUCTIONS_FIELD_DESCRIPTION = 'Server-issued handles for this conversation, and what to do with them. Read and follow.';
+const CONVERSATION_ID_FIELD_DESCRIPTION = 'Echo this exact value as the conversation_id argument on every subsequent tool call.';
+function canDeclareOutputInstructions(outputSchema) {
+    if (!outputSchema || 'object' != typeof outputSchema) return false;
+    if (isSchemaObjectLike(outputSchema)) return false;
+    const schema = outputSchema;
+    if (schema.$ref || schema.oneOf || schema.allOf || schema.anyOf) return false;
+    const { properties } = schema;
+    if (void 0 !== properties && ('object' != typeof properties || null === properties || Array.isArray(properties))) return false;
+    return !properties || !Object.prototype.hasOwnProperty.call(properties, MCP_INSTRUCTIONS_KEY);
+}
+function isZodLike(entry) {
+    return !!entry && 'object' == typeof entry && ('_def' in entry || '_zod' in entry || '~standard' in entry);
+}
+function looksLikeJsonSchema(candidate) {
+    if ('string' == typeof candidate.type || 'string' == typeof candidate.$ref) return true;
+    if (Array.isArray(candidate.oneOf) || Array.isArray(candidate.allOf) || Array.isArray(candidate.anyOf)) return true;
+    const { properties } = candidate;
+    return !!properties && 'object' == typeof properties && !isZodLike(properties);
+}
+function isSchemaObjectLike(value) {
+    const candidate = value;
+    if (isZodLike(candidate)) return true;
+    if (looksLikeJsonSchema(candidate)) return false;
+    return Object.values(candidate).some(isZodLike);
+}
+function addInstructionsToOutputSchema(tool, logger = log) {
+    const toolName = tool.name || 'unknown';
+    const original = tool.outputSchema;
+    if (!original || 'object' != typeof original) return tool;
+    if (!canDeclareOutputInstructions(original)) {
+        const schema = original;
+        logger(schema.properties && Object.prototype.hasOwnProperty.call(schema.properties, MCP_INSTRUCTIONS_KEY) ? `WARN: Tool "${toolName}" already declares '${MCP_INSTRUCTIONS_KEY}' in its output schema. Leaving it alone.` : `WARN: Tool "${toolName}" has a complex output schema (oneOf/allOf/anyOf/$ref). Skipping '${MCP_INSTRUCTIONS_KEY}' declaration; its session handle stays content-only.`);
+        return tool;
+    }
+    const modifiedTool = {
+        ...tool
+    };
+    const outputSchema = JSON.parse(JSON.stringify(original));
+    if (!outputSchema.properties) outputSchema.properties = {};
+    outputSchema.properties[MCP_INSTRUCTIONS_KEY] = {
+        type: 'object',
+        description: INSTRUCTIONS_FIELD_DESCRIPTION,
+        properties: {
+            conversation_id: {
+                type: 'string',
+                description: CONVERSATION_ID_FIELD_DESCRIPTION
+            },
+            instructions: {
+                type: 'string'
+            }
+        }
+    };
+    modifiedTool.outputSchema = outputSchema;
+    return modifiedTool;
+}
+function addInstructionsToOutputSchemas(tools, logger = log) {
+    return tools.map((tool)=>addInstructionsToOutputSchema(tool, logger));
+}
+const ECHO_INSTRUCTION = 'Send this conversation_id as an argument on every subsequent tool call in this conversation.';
+function buildConversationInstructions(conversationId) {
+    return {
+        conversation_id: conversationId,
+        instructions: ECHO_INSTRUCTION
+    };
+}
+function mirrorInstructionsIntoStructuredContent(result, conversationId) {
+    if (!result || 'object' != typeof result) return result;
+    const structuredContent = result.structuredContent;
+    if (!structuredContent || 'object' != typeof structuredContent || Array.isArray(structuredContent)) return result;
+    if (Object.prototype.hasOwnProperty.call(structuredContent, MCP_INSTRUCTIONS_KEY)) return result;
+    return {
+        ...result,
+        structuredContent: {
+            ...structuredContent,
+            [MCP_INSTRUCTIONS_KEY]: buildConversationInstructions(conversationId)
+        }
+    };
+}
+export { MCP_INSTRUCTIONS_KEY, addInstructionsToOutputSchema, addInstructionsToOutputSchemas, buildConversationInstructions, canDeclareOutputInstructions, mirrorInstructionsIntoStructuredContent };

package/dist/extensions/session.d.ts

@@ -6,12 +6,33 @@ export declare function newSessionId(): string;
  */
 export declare function deriveSessionIdFromMCPSession(mcpSessionId: string): string;
 /**
- * Resolves the session id for a request: from the replayed session token, from
- * the transport's MCP session id, or — when the request carries nothing — from
- * this instance's memory. Also saves the token's client name/version so events
- * built later in the request can use them (see getSessionInfo).
+ * Derives the SDK session id from the agent's conversation handle. Deterministic
+ * and unsalted on purpose: two pods that never met must agree on the session, and
+ * the 2026-07-28 revision leaves them no shared state to agree through.
+ *
+ * Hashed rather than used verbatim so an MCP session can never collide with a
+ * Session Replay id — a bare uuidv7 would render a "View recording" button that
+ * resolves to nothing.
+ *
+ * Exported because this *is* the cross-SDK contract: posthog-python has to
+ * reproduce it byte for byte or the same conversation splits into two sessions
+ * depending on which SDK served the call.
  */
-export declare function getSessionId(server: MCPServerLike, extra?: CompatibleRequestHandlerExtra): string;
+export declare function deriveSessionIdFromConversation(conversationId: string): string;
+/**
+ * Resolves the session id for a request. Three steps, first match wins:
+ *
+ *   1. the agent carried a `conversation_id` tool argument   — 2026-07-28
+ *   2. the request carried a session id                      — 2025-11-25
+ *   3. nothing was carried, so reuse this instance's own id  — stdio
+ *
+ * The split mirrors the two protocol revisions. 2026-07-28 removed protocol-level
+ * sessions, so the only thing that can carry a session across calls is the agent
+ * itself (1). 2025-11-25 kept the session on the connection, so the request
+ * carries it (2). 3 is for stdio, where neither applies — there is no
+ * HTTP request to carry anything, and no agent handle unless the host opted in.
+ */
+export declare function getSessionId(server: MCPServerLike, extra?: CompatibleRequestHandlerExtra, conversationId?: string): string;
 /**
  * Builds the session metadata stamped onto an event. The caller passes the
  * session id resolved for *this* request so identity attribution can't be

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;AAMjB,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAE1E;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,CAAC,EAAE,6BAA6B,GAAG,MAAM,CAgCjG;AAgBD;;;;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,aAAa,EAEb,WAAW,EACZ,MAAM,UAAU,CAAA;AAOjB,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAE1E;AAED;;;;;;;;;;;;GAYG;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,CA0CR;AA4ED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,gBAAgB,GAAG,SAAS,EAClC,SAAS,CAAC,EAAE,MAAM,GACjB,WAAW,CAmCb"}