mcp-event-intelligence 0.4.0 → 0.6.0

package/scripts/lib/derived-event-coordinator.mjs

@@ -2,6 +2,9 @@ import {
   parseDerivedEventRecord,
   sha256Hex,
 } from '../../dist/src/intelligenceProtocol/index.js';
+import {
+  evaluatePatternMeasure,
+} from '../../dist/src/patternV2/evaluator.js';
 
 export const DERIVED_EVENT_SERVER_ID = 'event-intelligence:derived';
 export const DERIVED_EVENT_CONNECTION_ID = 'event-intelligence:derived';
@@ -26,6 +29,7 @@ function evidenceRef(source) {
     sourceEventId: source.sourceEventId,
     traceId: source.traceId,
     occurredAt: source.occurredAt,
+    ...(source.receivedAt ? { receivedAt: source.receivedAt } : {}),
     payloadHash: source.payloadHash ?? null,
     contractVersion:
       source.data?._derived?.contractVersion ?? null,
@@ -60,6 +64,43 @@ function latestForClause(match, clauseId) {
     )[0] ?? null;
 }
 
+function patternCandidateForMatch(match) {
+  const bindings = {};
+  for (const event of match.sourceEvents) {
+    bindings[event.clauseId] ??= [];
+    bindings[event.clauseId].push(event);
+  }
+  for (const events of Object.values(bindings)) {
+    events.sort((a, b) =>
+      Date.parse(a.occurredAt) - Date.parse(b.occurredAt) ||
+      a.sourceEventId.localeCompare(b.sourceEventId)
+    );
+  }
+  const events = [...match.sourceEvents].sort((a, b) =>
+    Date.parse(a.occurredAt) - Date.parse(b.occurredAt) ||
+    a.sourceEventId.localeCompare(b.sourceEventId)
+  );
+  return {
+    bindings,
+    events,
+    startIndex: events.length ? 0 : -1,
+    endIndex: events.length ? events.length - 1 : -1,
+    semanticDecisions: [],
+  };
+}
+
+function derivedOccurredAt(match) {
+  if (match.patternState?.completedAt) {
+    return match.patternState.completedAt;
+  }
+
+  const candidates = match.sourceEvents
+    .map((event) => Date.parse(event.occurredAt))
+    .filter(Number.isFinite);
+  if (!candidates.length) return match.updatedAt;
+  return new Date(Math.max(...candidates)).toISOString();
+}
+
 export class DerivedEventCoordinator {
   constructor({
     store,
@@ -89,7 +130,7 @@ export class DerivedEventCoordinator {
       })
     ).slice(0, 24)}`;
 
-    const existing = this.store.getDerivedEvent(
+    const existing = await this.store.getDerivedEvent(
       eventId,
       DERIVED_EVENT_SERVER_ID,
     );
@@ -110,7 +151,7 @@ export class DerivedEventCoordinator {
     const rootEvidence = [];
     for (const source of match.sourceEvents) {
       if (source.serverId === DERIVED_EVENT_SERVER_ID) {
-        const parent = this.store.getDerivedEvent(
+        const parent = await this.store.getDerivedEvent(
           source.sourceEventId,
           DERIVED_EVENT_SERVER_ID,
         );
@@ -147,7 +188,27 @@ export class DerivedEventCoordinator {
       }
     }
 
-    const contract = this.store.getDerivedContract(
+    const measured = {};
+    if (spec.measures?.length) {
+      const candidate = patternCandidateForMatch(match);
+      for (const measure of spec.measures) {
+        const value = evaluatePatternMeasure(candidate, measure);
+        if (
+          value === undefined ||
+          (
+            value !== null &&
+            !['string', 'number', 'boolean'].includes(typeof value)
+          )
+        ) {
+          throw new Error(
+            `Derived event measure must resolve to scalar or null: ${measure.key}`,
+          );
+        }
+        measured[measure.key] = value;
+      }
+    }
+
+    const contract = await this.store.getDerivedContract(
       spec.name,
       spec.contractVersion,
     );
@@ -162,11 +223,12 @@ export class DerivedEventCoordinator {
     const data = {
       ...(spec.constants ?? {}),
       ...projected,
+      ...measured,
       _derived: {
         triggerId: definition.triggerId,
         triggerVersion: definition.version,
         matchId: match.matchId,
-        correlationKey: match.correlationKey,
+        partitionKey: match.partitionKey,
         contractVersion: spec.contractVersion,
         schemaFingerprint: contract.schemaFingerprint,
       },
@@ -176,7 +238,8 @@ export class DerivedEventCoordinator {
       traceId: `derived:${eventId}`,
       sourceEventId: eventId,
       name: spec.name,
-      occurredAt: match.updatedAt,
+      occurredAt: derivedOccurredAt(match),
+      receivedAt: this.now().toISOString(),
       provider: 'event-intelligence',
       serverId: DERIVED_EVENT_SERVER_ID,
       payloadHash,
@@ -222,7 +285,7 @@ export class DerivedEventCoordinator {
         await sha256Hex({
           kind,
           sourceEventId: record.event.sourceEventId,
-          sequence: this.store.auditLength(),
+          sequence: await this.store.auditLength(),
         })
       ).slice(0, 24)}`,
       traceId: record.event.traceId,

package/scripts/lib/local-event-intelligence-runtime.mjs

@@ -26,6 +26,10 @@ import {
   PersistentEventStore,
   normalizeEventScopeId,
 } from './persistent-event-store.mjs';
+import {
+  assertSharedStoreCapabilities,
+  describeStoreCapabilities,
+} from './store-capabilities.mjs';
 import {
   TriggerInspector,
 } from './trigger-inspector.mjs';
@@ -114,6 +118,23 @@ export async function createLocalEventIntelligenceRuntime({
   const dataDir = env.DATA_DIR ?? './data';
   const rootStore = providedStore ?? new PersistentEventStore(dataDir);
   const restored = await initializeStore(rootStore);
+  const storeCapabilities = describeStoreCapabilities(rootStore);
+  const requireSharedStore =
+    env.EVENT_INTELLIGENCE_REQUIRE_SHARED_STORE === 'true';
+  if (requireSharedStore) {
+    assertSharedStoreCapabilities(rootStore);
+    if (!String(env.EVENT_INTELLIGENCE_WORKER_ID || '').trim()) {
+      const error = new Error(
+        'EVENT_INTELLIGENCE_WORKER_ID is required in shared-store mode',
+      );
+      error.code = 'EVENT_INTELLIGENCE_WORKER_ID_REQUIRED';
+      throw error;
+    }
+  }
+  const rootWorkerId = String(
+    env.EVENT_INTELLIGENCE_WORKER_ID ||
+    `ei-${process.pid}`,
+  ).trim();
 
   const evaluator =
     semanticEvaluator !== undefined
@@ -161,7 +182,17 @@ export async function createLocalEventIntelligenceRuntime({
       assertStoreContract(store);
     }
 
-    const triggerEngine = new CompositeTriggerEngine(store, evaluator);
+    const triggerEngine = new CompositeTriggerEngine(
+      store,
+      evaluator,
+      undefined,
+      {
+        workerId: `${rootWorkerId}:${scopeId}`,
+        partitionLeaseMs: Number(
+          env.EVENT_INTELLIGENCE_PARTITION_LEASE_MS ?? 300000,
+        ),
+      },
+    );
     const triggerPlanner = new TriggerPlanner({ store });
     const activationHydrator = new ActivationHydrator({ store });
     const wakeCoordinators = new Map();
@@ -195,7 +226,7 @@ export async function createLocalEventIntelligenceRuntime({
           packetBuilder,
           ...deliveryOptions,
           deliverer: async (packet) => {
-            const activation = activationHydrator.hydrateWake(packet.wake_id);
+            const activation = await activationHydrator.hydrateWake(packet.wake_id);
             const result = await handler(packet, activation);
             if (typeof result === 'string' && result) {
               return { runtimeReceiptId: result };
@@ -224,7 +255,7 @@ export async function createLocalEventIntelligenceRuntime({
         packetBuilder,
         ...deliveryOptions,
         deliverer: async (packet) => {
-          const activation = activationHydrator.hydrateWake(packet.wake_id);
+          const activation = await activationHydrator.hydrateWake(packet.wake_id);
           const result = await wake(packet, activation);
           if (typeof result === 'string' && result) {
             return { runtimeReceiptId: result };
@@ -330,6 +361,7 @@ export async function createLocalEventIntelligenceRuntime({
 
   return {
     restored,
+    storeCapabilities,
     store: defaultContext.store,
     evaluator,
     triggerEngine: defaultContext.triggerEngine,

package/scripts/lib/mcp-events-client.mjs

@@ -8,10 +8,14 @@ import {
   normalizeEventScopeId,
 } from './persistent-event-store.mjs';
 import { assertJsonSchemaValue } from './json-schema.mjs';
+import {
+  MCP_EVENTS_EXTENSION_ID,
+  getMcpEventsCompatibilityProfile,
+  resolveMcpEventsCompatibilityProfile,
+} from './mcp-events-compatibility.mjs';
 
 export { assertJsonSchemaValue } from './json-schema.mjs';
-
-export const MCP_EVENTS_EXTENSION_ID = 'io.modelcontextprotocol/events';
+export { MCP_EVENTS_EXTENSION_ID } from './mcp-events-compatibility.mjs';
 const UnknownResultSchema = z.unknown();
 
 function assertObject(value, message) {
@@ -116,6 +120,10 @@ function normalizeConnection(connection) {
       'maxPollBatches',
     ),
     preferredDelivery,
+    compatibilityProfile:
+      connection.compatibilityProfile === undefined
+        ? 'auto'
+        : String(connection.compatibilityProfile),
     openEventStream:
       typeof connection.openEventStream === 'function'
         ? connection.openEventStream
@@ -148,6 +156,7 @@ export function createHostMcpEventsConnection({
   maxPollBatches = 4,
   scopeId = DEFAULT_EVENT_SCOPE_ID,
   preferredDelivery,
+  compatibilityProfile = 'auto',
   openEventStream,
   createWebhookSubscription,
 } = {}) {
@@ -185,12 +194,13 @@ export function createHostMcpEventsConnection({
     maxPollBatches,
     scopeId,
     preferredDelivery,
+    compatibilityProfile,
     openEventStream,
     createWebhookSubscription,
   });
 }
 
-function sourceDescriptor(raw) {
+function sourceDescriptor(raw, profile) {
   const descriptor = assertObject(raw, 'Invalid MCP event descriptor');
   const name = String(descriptor.name || '').trim();
   if (!name) throw new Error('MCP event descriptor requires name');
@@ -199,7 +209,7 @@ function sourceDescriptor(raw) {
     : [];
   if (
     delivery.length === 0 ||
-    delivery.some((mode) => !['poll', 'push', 'webhook'].includes(mode))
+    delivery.some((mode) => !profile.deliveryModes.includes(mode))
   ) {
     throw new Error(`MCP event descriptor ${name} has invalid delivery modes`);
   }
@@ -284,6 +294,7 @@ export class McpEventsClientManager {
     this.connections = new Map();
     this.now = now;
     this.descriptors = new Map();
+    this.profiles = new Map();
     this.timers = new Map();
     this.lastErrors = new Map();
     this.scopeContexts = new Map();
@@ -364,6 +375,7 @@ export class McpEventsClientManager {
     if (timer) clearTimeout(timer);
     this.timers.delete(connectionId);
     this.descriptors.delete(connectionId);
+    this.profiles.delete(connectionId);
     this.lastErrors.delete(connectionId);
     this.pollInFlight.delete(connectionId);
 
@@ -382,7 +394,7 @@ export class McpEventsClientManager {
     }
     const removed = this.connections.delete(connectionId);
     if (removed && context) {
-      const sources = context.store.listEventSources({
+      const sources = await context.store.listEventSources({
         connectionIds: [connectionId],
       });
       for (const source of sources) {
@@ -426,20 +438,16 @@ export class McpEventsClientManager {
 
     const context = await this.scopeContext(connection);
     const capabilities = (await connection.getCapabilities()) ?? {};
-    const extensions =
-      capabilities.extensions &&
-      !Array.isArray(capabilities.extensions) &&
-      typeof capabilities.extensions === 'object'
-        ? capabilities.extensions
-        : {};
-    if (
-      !Object.prototype.hasOwnProperty.call(
-        extensions,
-        MCP_EVENTS_EXTENSION_ID,
-      )
-    ) {
+    const profile = resolveMcpEventsCompatibilityProfile({
+      capabilities,
+      requested: connection.compatibilityProfile,
+    });
+    if (!profile) {
+      const expected = getMcpEventsCompatibilityProfile(
+        connection.compatibilityProfile,
+      );
       const error = new Error(
-        `MCP server ${connectionId} does not advertise ${MCP_EVENTS_EXTENSION_ID}`,
+        `MCP server ${connectionId} does not advertise the ${expected.id} Events profile`,
       );
       error.code = 'MCP_EVENTS_CAPABILITY_UNAVAILABLE';
       throw error;
@@ -451,7 +459,7 @@ export class McpEventsClientManager {
     do {
       const listed = await this.rpc(
         connection,
-        'events/list',
+        profile.listMethod,
         cursor ? { cursor } : {},
       );
       if (!Array.isArray(listed?.events)) {
@@ -460,7 +468,7 @@ export class McpEventsClientManager {
         );
       }
       for (const raw of listed.events) {
-        const descriptor = sourceDescriptor(raw);
+        const descriptor = sourceDescriptor(raw, profile);
         if (names.has(descriptor.name)) {
           throw new Error(
             `MCP server ${connectionId} returned duplicate event descriptor ${descriptor.name}`,
@@ -478,9 +486,9 @@ export class McpEventsClientManager {
     for (const normalized of descriptors) {
       const sourceId =
         `mcp:${connection.connectionId}:${normalized.name}`;
-      const existing = context.store
-        .listEventSources()
-        .find((source) => source.sourceId === sourceId);
+      const existing = (
+        await context.store.listEventSources()
+      ).find((source) => source.sourceId === sourceId);
       const same =
         existing &&
         existing.enabled !== false &&
@@ -492,7 +500,9 @@ export class McpEventsClientManager {
         JSON.stringify(existing.inputSchema || {}) ===
           JSON.stringify(normalized.inputSchema) &&
         JSON.stringify(existing.payloadSchema || {}) ===
-          JSON.stringify(normalized.payloadSchema);
+          JSON.stringify(normalized.payloadSchema) &&
+        existing.metadata?.compatibilityProfile === profile.id &&
+        existing.metadata?.extensionId === profile.extensionId;
 
       if (!same) {
         const register = context.triggerControl?.registerEventSource
@@ -514,7 +524,8 @@ export class McpEventsClientManager {
             metadata: {
               transport: 'host-managed-mcp',
               hostManaged: true,
-              extensionId: MCP_EVENTS_EXTENSION_ID,
+              extensionId: profile.extensionId,
+              compatibilityProfile: profile.id,
               ...(normalized._meta ? { descriptorMeta: normalized._meta } : {}),
             },
           },
@@ -527,6 +538,7 @@ export class McpEventsClientManager {
     }
 
     this.descriptors.set(connection.connectionId, descriptors);
+    this.profiles.set(connection.connectionId, profile);
     this.lastErrors.delete(connection.connectionId);
     return descriptors;
   }
@@ -559,25 +571,26 @@ export class McpEventsClientManager {
     return results;
   }
 
-  desiredSubscriptions(connection, context) {
+  async desiredSubscriptions(connection, context) {
     const descriptors = this.descriptors.get(connection.connectionId) || [];
     const byName = new Map(descriptors.map((item) => [item.name, item]));
     const desired = new Map();
-    const triggers =
-      typeof context.triggerControl?.listTriggers === 'function'
-        ? context.triggerControl.listTriggers()
-        : typeof context.store?.listTriggers === 'function'
-          ? context.store.listTriggers().map((definition) => ({
-              definition,
-              state:
-                typeof context.store.getTriggerState === 'function'
-                  ? context.store.getTriggerState(
-                      definition.triggerId,
-                      definition.version,
-                    )
-                  : null,
-            }))
-          : [];
+    let triggers = [];
+    if (typeof context.triggerControl?.listTriggers === 'function') {
+      triggers = await context.triggerControl.listTriggers();
+    } else if (typeof context.store?.listTriggers === 'function') {
+      const definitions = await context.store.listTriggers();
+      triggers = await Promise.all(definitions.map(async (definition) => ({
+        definition,
+        state:
+          typeof context.store.getTriggerState === 'function'
+            ? await context.store.getTriggerState(
+              definition.triggerId,
+              definition.version,
+            )
+            : null,
+      })));
+    }
 
     for (const { definition, state } of triggers) {
       if (state?.status !== 'active') continue;
@@ -596,12 +609,18 @@ export class McpEventsClientManager {
           clause.event,
           args,
         );
-        if (!desired.has(subscriptionId)) {
+        const consumerRef =
+          `${definition.triggerId}@${definition.version}:${clause.id}`;
+        const existing = desired.get(subscriptionId);
+        if (existing) {
+          existing.consumerRefs.push(consumerRef);
+        } else {
           desired.set(subscriptionId, {
             subscriptionId,
             eventName: clause.event,
             arguments: args,
             descriptor,
+            consumerRefs: [consumerRef],
           });
         }
       }
@@ -620,6 +639,7 @@ export class McpEventsClientManager {
     }
     assertJsonSchemaValue(descriptor.payloadSchema, occurrence.data);
 
+    const receivedAt = this.now().toISOString();
     const receipt = await context.store.appendMcpOccurrence(
       connection.serverId,
       occurrence,
@@ -634,6 +654,7 @@ export class McpEventsClientManager {
       traceId:
         `mcp:${connection.serverId}:${subscription.subscriptionId}:${occurrence.eventId}`,
       subscriptionArguments: subscription.arguments,
+      receivedAt,
     });
     return { accepted: true, occurrence };
   }
@@ -644,7 +665,7 @@ export class McpEventsClientManager {
     subscription,
     patch = {},
   ) {
-    const previous = context.store.getMcpClientState(
+    const previous = await context.store.getMcpClientState(
       connection.connectionId,
       subscription.eventName,
       subscription.arguments,
@@ -667,7 +688,7 @@ export class McpEventsClientManager {
     { respectSchedule = false } = {},
   ) {
     const store = context.store;
-    const current = store.getMcpClientState(
+    const current = await store.getMcpClientState(
       connection.connectionId,
       subscription.eventName,
       subscription.arguments,
@@ -683,6 +704,7 @@ export class McpEventsClientManager {
         delivery: 'poll',
         status: 'scheduled',
         accepted: 0,
+        consumerCount: subscription.consumerRefs.length,
         cursor: current.cursor,
         nextPollAt: current.nextPollAt,
       };
@@ -697,7 +719,10 @@ export class McpEventsClientManager {
     let nextPollMs = connection.pollIntervalMs;
 
     do {
-      const result = await this.rpc(connection, 'events/poll', {
+      const profile =
+        this.profiles.get(connection.connectionId) ??
+        getMcpEventsCompatibilityProfile(connection.compatibilityProfile);
+      const result = await this.rpc(connection, profile.pollMethod, {
         name: subscription.eventName,
         arguments: subscription.arguments,
         cursor,
@@ -757,6 +782,7 @@ export class McpEventsClientManager {
       delivery: 'poll',
       status: 'ok',
       accepted,
+      consumerCount: subscription.consumerRefs.length,
       cursor,
       truncated,
       hasMore,
@@ -780,11 +806,12 @@ export class McpEventsClientManager {
         delivery,
         status: 'active',
         accepted: existing.accepted,
+        consumerCount: subscription.consumerRefs.length,
       };
     }
     if (existing) await this.closeSession(subscription.subscriptionId);
 
-    const current = context.store.getMcpClientState(
+    const current = await context.store.getMcpClientState(
       connection.connectionId,
       subscription.eventName,
       subscription.arguments,
@@ -922,6 +949,7 @@ export class McpEventsClientManager {
       delivery,
       status: 'active',
       accepted,
+      consumerCount: subscription.consumerRefs.length,
     };
   }
 
@@ -968,7 +996,7 @@ export class McpEventsClientManager {
       descriptors = await this.discoverConnection(connectionId);
     }
 
-    const desired = this.desiredSubscriptions(connection, context);
+    const desired = await this.desiredSubscriptions(connection, context);
     const desiredIds = new Set(desired.keys());
     const results = [];
 
@@ -981,6 +1009,7 @@ export class McpEventsClientManager {
           status: 'delivery_not_supported',
           delivery: null,
           accepted: 0,
+          consumerCount: subscription.consumerRefs.length,
         });
         continue;
       }
@@ -1034,12 +1063,12 @@ export class McpEventsClientManager {
     return results;
   }
 
-  nextDelay(connection) {
+  async nextDelay(connection) {
     const context = this.scopeContexts.get(
       `${connection.connectionId}::${connection.scopeId}`,
     );
     if (!context) return connection.pollIntervalMs;
-    const states = context.store.listMcpClientStates(
+    const states = await context.store.listMcpClientStates(
       connection.connectionId,
     );
     const now = this.now().getTime();
@@ -1073,7 +1102,10 @@ export class McpEventsClientManager {
           this.started &&
           this.connections.get(connection.connectionId) === connection
         ) {
-          this.scheduleConnection(connection, this.nextDelay(connection));
+          this.scheduleConnection(
+            connection,
+            await this.nextDelay(connection),
+          );
         }
       }
     }, Math.max(0, delay));
@@ -1108,19 +1140,27 @@ export class McpEventsClientManager {
     await this.drain();
   }
 
-  status() {
-    return [...this.connections.values()].map((connection) => {
+  async status() {
+    return Promise.all([...this.connections.values()].map(async (connection) => {
       const context = this.scopeContexts.get(
         `${connection.connectionId}::${connection.scopeId}`,
       );
       const store = context?.store ?? this.store;
-      const states = store.listMcpClientStates(connection.connectionId);
+      const states = await store.listMcpClientStates(connection.connectionId);
+      const desired = context
+        ? await this.desiredSubscriptions(connection, context)
+        : new Map();
       return {
         connectionId: connection.connectionId,
         scopeId: connection.scopeId,
         serverId: connection.serverId,
         hostManaged: true,
-        extensionId: MCP_EVENTS_EXTENSION_ID,
+        extensionId:
+          this.profiles.get(connection.connectionId)?.extensionId ??
+          MCP_EVENTS_EXTENSION_ID,
+        compatibilityProfile:
+          this.profiles.get(connection.connectionId)?.id ??
+          connection.compatibilityProfile,
         events: (this.descriptors.get(connection.connectionId) || []).map(
           (event) => ({
             name: event.name,
@@ -1130,6 +1170,8 @@ export class McpEventsClientManager {
               .map((state) => ({
                 subscriptionId: state.subscriptionId,
                 arguments: state.arguments ?? {},
+                consumerCount:
+                  desired.get(state.subscriptionId)?.consumerRefs.length ?? 0,
                 delivery: state.deliveryMode,
                 cursor: state.cursor,
                 nextPollAt: state.nextPollAt ?? null,
@@ -1139,6 +1181,6 @@ export class McpEventsClientManager {
         ),
         error: this.lastErrors.get(connection.connectionId) ?? null,
       };
-    });
+    }));
   }
 }

package/scripts/lib/mcp-events-compatibility.mjs

@@ -0,0 +1,54 @@
+export const MCP_EVENTS_EXTENSION_ID = 'io.modelcontextprotocol/events';
+
+export const MCP_EVENTS_COMPATIBILITY_PROFILES = Object.freeze({
+  'experimental-extension-2026-09-25': Object.freeze({
+    id: 'experimental-extension-2026-09-25',
+    capabilityStyle: 'extension',
+    extensionId: MCP_EVENTS_EXTENSION_ID,
+    listMethod: 'events/list',
+    pollMethod: 'events/poll',
+    deliveryModes: Object.freeze(['poll', 'push', 'webhook']),
+    experimental: true,
+  }),
+});
+
+export const DEFAULT_MCP_EVENTS_COMPATIBILITY_PROFILE =
+  'experimental-extension-2026-09-25';
+
+export function getMcpEventsCompatibilityProfile(profileId) {
+  const id =
+    !profileId || profileId === 'auto'
+      ? DEFAULT_MCP_EVENTS_COMPATIBILITY_PROFILE
+      : String(profileId);
+  const profile = MCP_EVENTS_COMPATIBILITY_PROFILES[id];
+  if (!profile) {
+    const error = new Error(`Unknown MCP Events compatibility profile: ${id}`);
+    error.code = 'MCP_EVENTS_PROFILE_UNKNOWN';
+    throw error;
+  }
+  return profile;
+}
+
+export function profileAdvertisedByCapabilities(profile, capabilities = {}) {
+  if (profile.capabilityStyle !== 'extension') return false;
+  const extensions =
+    capabilities?.extensions &&
+    !Array.isArray(capabilities.extensions) &&
+    typeof capabilities.extensions === 'object'
+      ? capabilities.extensions
+      : {};
+  return Object.prototype.hasOwnProperty.call(
+    extensions,
+    profile.extensionId,
+  );
+}
+
+export function resolveMcpEventsCompatibilityProfile({
+  capabilities,
+  requested = 'auto',
+} = {}) {
+  const profile = getMcpEventsCompatibilityProfile(requested);
+  return profileAdvertisedByCapabilities(profile, capabilities)
+    ? profile
+    : null;
+}