mcp-event-intelligence 0.3.1 → 0.5.0

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;
+}

package/scripts/lib/persistent-event-store.mjs

@@ -32,6 +32,22 @@ function scopeIdFromDirectoryName(name) {
   }
 }
 
+function canonicalStateValue(value) {
+  if (Array.isArray(value)) return value.map(canonicalStateValue);
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.keys(value)
+        .sort()
+        .map((key) => [key, canonicalStateValue(value[key])]),
+    );
+  }
+  return value;
+}
+
+function mcpClientStateKey(connectionId, eventName, args = {}) {
+  return `${String(connectionId)}::${String(eventName)}::${JSON.stringify(canonicalStateValue(args ?? {}))}`;
+}
+
 async function readJsonLines(filePath) {
   try {
     const raw = await readFile(filePath, 'utf8');
@@ -263,6 +279,7 @@ export class PersistentEventStore {
       const record = {
         sequence: Number(raw.sequence),
         serverId: String(raw.serverId),
+        subscriptionId: raw.subscriptionId ? String(raw.subscriptionId) : null,
         event: McpEventOccurrenceSchema.parse(raw.event),
       };
       if (!Number.isInteger(record.sequence) || record.sequence < 1) {
@@ -270,7 +287,7 @@ export class PersistentEventStore {
       }
       this.#mcpOccurrences.push(record);
       this.#mcpOccurrenceKeys.add(
-        `${record.serverId}:${record.event.eventId}`,
+        `${record.serverId}:${record.subscriptionId ?? ''}:${record.event.eventId}`,
       );
     }
     this.#mcpOccurrences.sort((a, b) => a.sequence - b.sequence);
@@ -282,15 +299,27 @@ export class PersistentEventStore {
         connectionId: String(raw.connectionId),
         serverId: String(raw.serverId || raw.connectionId),
         eventName: String(raw.eventName),
+        arguments:
+          raw.arguments && !Array.isArray(raw.arguments) && typeof raw.arguments === 'object'
+            ? raw.arguments
+            : {},
+        subscriptionId: raw.subscriptionId ? String(raw.subscriptionId) : null,
+        deliveryMode: raw.deliveryMode ? String(raw.deliveryMode) : 'poll',
         cursor: raw.cursor === null || raw.cursor === undefined
           ? null
           : String(raw.cursor),
         updatedAt: String(raw.updatedAt || new Date(0).toISOString()),
+        ...(raw.nextPollAt ? { nextPollAt: String(raw.nextPollAt) } : {}),
         ...(raw.lastEventAt ? { lastEventAt: String(raw.lastEventAt) } : {}),
         ...(raw.lastError ? { lastError: String(raw.lastError) } : {}),
+        ...(typeof raw.truncated === 'boolean' ? { truncated: raw.truncated } : {}),
       };
       this.#mcpClientStates.set(
-        `${state.connectionId}::${state.eventName}`,
+        mcpClientStateKey(
+          state.connectionId,
+          state.eventName,
+          state.arguments,
+        ),
         state,
       );
     }
@@ -776,13 +805,19 @@ export class PersistentEventStore {
       .filter((record) => !matchId || record.matchId === matchId);
   }
 
-  async appendMcpOccurrence(serverId, eventInput) {
+  async appendMcpOccurrence(serverId, eventInput, subscriptionIdInput = null) {
     return this.#serialized(async () => {
       const event = McpEventOccurrenceSchema.parse(eventInput);
-      const key = `${serverId}:${event.eventId}`;
+      const subscriptionId =
+        subscriptionIdInput === null || subscriptionIdInput === undefined
+          ? null
+          : String(subscriptionIdInput);
+      const key =
+        `${serverId}:${subscriptionId ?? ''}:${event.eventId}`;
       const existing = this.#mcpOccurrences.find(
         (record) =>
           record.serverId === serverId &&
+          (record.subscriptionId ?? null) === subscriptionId &&
           record.event.eventId === event.eventId,
       );
       if (this.#mcpOccurrenceKeys.has(key)) {
@@ -794,7 +829,12 @@ export class PersistentEventStore {
       }
 
       const sequence = this.latestMcpEventSequence() + 1;
-      const record = { sequence, serverId, event };
+      const record = {
+        sequence,
+        serverId,
+        subscriptionId,
+        event,
+      };
       this.#mcpOccurrenceKeys.add(key);
       this.#mcpOccurrences.push(record);
       await appendFile(
@@ -816,6 +856,7 @@ export class PersistentEventStore {
       .map((record) => ({
         sequence: record.sequence,
         serverId: record.serverId,
+        subscriptionId: record.subscriptionId ?? null,
         event: {
           ...record.event,
           data: { ...record.event.data },
@@ -823,9 +864,9 @@ export class PersistentEventStore {
       }));
   }
 
-  getMcpClientState(connectionId, eventName) {
+  getMcpClientState(connectionId, eventName, args = {}) {
     return this.#mcpClientStates.get(
-      `${String(connectionId)}::${String(eventName)}`,
+      mcpClientStateKey(connectionId, eventName, args),
     ) ?? null;
   }
 
@@ -843,24 +884,42 @@ export class PersistentEventStore {
       if (!connectionId || !eventName) {
         throw new Error('MCP client state requires connectionId and eventName');
       }
-      const previous = this.getMcpClientState(connectionId, eventName);
+      const args =
+        input.arguments && !Array.isArray(input.arguments) && typeof input.arguments === 'object'
+          ? input.arguments
+          : {};
+      const previous = this.getMcpClientState(connectionId, eventName, args);
       const state = {
         connectionId,
         serverId: String(input.serverId || previous?.serverId || connectionId),
         eventName,
+        arguments: args,
+        subscriptionId:
+          input.subscriptionId
+            ? String(input.subscriptionId)
+            : previous?.subscriptionId ?? null,
+        deliveryMode: String(input.deliveryMode || previous?.deliveryMode || 'poll'),
         cursor: input.cursor === null || input.cursor === undefined
           ? null
           : String(input.cursor),
         updatedAt: new Date().toISOString(),
+        ...(input.nextPollAt || previous?.nextPollAt
+          ? { nextPollAt: String(input.nextPollAt || previous.nextPollAt) }
+          : {}),
         ...(input.lastEventAt || previous?.lastEventAt
           ? { lastEventAt: String(input.lastEventAt || previous.lastEventAt) }
           : {}),
         ...(input.lastError
           ? { lastError: String(input.lastError) }
           : {}),
+        ...(typeof input.truncated === 'boolean'
+          ? { truncated: input.truncated }
+          : typeof previous?.truncated === 'boolean'
+            ? { truncated: previous.truncated }
+            : {}),
       };
       this.#mcpClientStates.set(
-        `${connectionId}::${eventName}`,
+        mcpClientStateKey(connectionId, eventName, args),
         state,
       );
       await appendFile(

package/scripts/lib/trigger-control-plane.mjs

@@ -5,6 +5,7 @@ import {
 import {
   DerivedContractRegistry,
 } from './derived-contract-registry.mjs';
+import { assertJsonSchemaValue } from './json-schema.mjs';
 
 function actorIdentity(actor) {
   if (!actor || typeof actor !== 'object') {
@@ -66,6 +67,67 @@ function scalarSchemaForConstant(value) {
   return {};
 }
 
+function walkPatternValue(value, visitor) {
+  if (!value || typeof value !== 'object') return;
+  if (value.kind === 'field') {
+    visitor(value.ref, value.path, 'pattern value');
+    return;
+  }
+  if (value.kind === 'arithmetic') {
+    for (const arg of value.args ?? []) walkPatternValue(arg, visitor);
+  }
+}
+
+function walkPatternNode(node, visitor) {
+  if (!node || typeof node !== 'object') return;
+
+  if (node.kind === 'compare') {
+    walkPatternValue(node.left, visitor);
+    if (node.right) walkPatternValue(node.right, visitor);
+  }
+  if (
+    node.kind === 'aggregate' ||
+    node.kind === 'state' ||
+    node.kind === 'distinct'
+  ) {
+    if (node.path) visitor(node.ref, node.path, `pattern ${node.kind}`);
+  }
+  if (node.kind === 'semantic') {
+    for (const input of node.input ?? []) {
+      const [ref, ...parts] = String(input).split('.');
+      if (ref && parts.length) {
+        visitor(ref, parts.join('.'), 'pattern semantic input');
+      }
+    }
+  }
+
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) walkPatternNode(child, visitor);
+  }
+  if (node.child) walkPatternNode(node.child, visitor);
+  if (node.forbidden) walkPatternNode(node.forbidden, visitor);
+}
+
+function assertSubscriptionArguments(source, args, purpose) {
+  const inputSchema = source?.inputSchema;
+  if (
+    !inputSchema ||
+    typeof inputSchema !== 'object' ||
+    Object.keys(inputSchema).length === 0
+  ) {
+    return;
+  }
+  try {
+    assertJsonSchemaValue(inputSchema, args ?? {});
+  } catch (error) {
+    const wrapped = new Error(
+      `${purpose} arguments are invalid for ${source.serverId}/${source.eventName}: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    wrapped.code = 'TRIGGER_SOURCE_ARGUMENTS_INVALID';
+    throw wrapped;
+  }
+}
+
 function assertAdvertisedPath(source, path, purpose) {
   const payloadSchema = source?.payloadSchema;
   if (
@@ -695,6 +757,11 @@ export class TriggerControlPlane {
 
     for (const clause of definition.clauses) {
       const source = resolveSource(clause);
+      assertSubscriptionArguments(
+        source,
+        clause.arguments ?? {},
+        `Trigger clause ${clause.id}`,
+      );
       for (const predicate of clause.where ?? []) {
         assertAdvertisedPath(
           source,
@@ -716,6 +783,59 @@ export class TriggerControlPlane {
       );
     }
 
+    if (definition.patternV2) {
+      const clauseForRef = (ref) =>
+        definition.clauses.find((candidate) => candidate.id === ref);
+      const sourceForRef = (ref) => {
+        const clause = clauseForRef(ref);
+        return clause ? resolveSource(clause) : null;
+      };
+
+      for (const dimension of definition.patternV2.partitionBy ?? []) {
+        for (const field of dimension.fields ?? []) {
+          assertAdvertisedPath(
+            sourceForRef(field.ref),
+            field.path,
+            `Pattern partition ${dimension.key}`,
+          );
+        }
+      }
+
+      walkPatternNode(definition.patternV2.root, (ref, fieldPath, purpose) => {
+        assertAdvertisedPath(
+          sourceForRef(ref),
+          fieldPath,
+          purpose,
+        );
+      });
+    }
+
+    for (const measure of definition.derivedEvent?.measures ?? []) {
+      const expression = measure.expression;
+      const clauseForRef = (ref) =>
+        definition.clauses.find((candidate) => candidate.id === ref);
+      const sourceForRef = (ref) => {
+        const clause = clauseForRef(ref);
+        return clause ? resolveSource(clause) : null;
+      };
+
+      if (expression.kind === 'aggregate' && expression.path) {
+        assertAdvertisedPath(
+          sourceForRef(expression.ref),
+          expression.path,
+          `Derived measure ${measure.key}`,
+        );
+      } else {
+        walkPatternValue(expression, (ref, fieldPath) => {
+          assertAdvertisedPath(
+            sourceForRef(ref),
+            fieldPath,
+            `Derived measure ${measure.key}`,
+          );
+        });
+      }
+    }
+
     for (const projection of definition.derivedEvent?.projections ?? []) {
       const clause = definition.clauses.find(
         (candidate) => candidate.id === projection.ref,
@@ -780,6 +900,65 @@ export class TriggerControlPlane {
     }
 
     const allSources = this.store.listEventSources();
+    const sourceSchemaForRefPath = (ref, fieldPath) => {
+      const clause = definition.clauses.find(
+        (candidate) => candidate.id === ref,
+      );
+      const source = clause
+        ? allSources.find(
+            (candidate) =>
+              candidate.eventName === clause.event &&
+              candidate.serverId === clause.serverId &&
+              (
+                !clause.contractVersion ||
+                String(candidate.metadata?.contractVersion || '') ===
+                  String(clause.contractVersion)
+              ),
+          )
+        : null;
+      return getSchemaNode(source?.payloadSchema, fieldPath) ?? {};
+    };
+
+    const schemaForMeasureExpression = (expression) => {
+      if (!expression || typeof expression !== 'object') return {};
+      if (expression.kind === 'literal') {
+        if (expression.value === null) return { type: 'null' };
+        return scalarSchemaForConstant(expression.value);
+      }
+      if (expression.kind === 'field') {
+        return sourceSchemaForRefPath(expression.ref, expression.path);
+      }
+      if (
+        expression.kind === 'occurredAt' ||
+        expression.kind === 'arithmetic'
+      ) {
+        return { type: 'number' };
+      }
+      if (expression.kind === 'aggregate') {
+        if (
+          ['count', 'countDistinct'].includes(expression.function)
+        ) {
+          return { type: 'integer' };
+        }
+        if (
+          ['sum', 'avg', 'min', 'max', 'stddev', 'percentile']
+            .includes(expression.function)
+        ) {
+          return { type: 'number' };
+        }
+        return sourceSchemaForRefPath(
+          expression.ref,
+          expression.path,
+        );
+      }
+      return {};
+    };
+
+    for (const measure of definition.derivedEvent.measures ?? []) {
+      properties[measure.key] =
+        schemaForMeasureExpression(measure.expression);
+    }
+
     for (const projection of definition.derivedEvent.projections ?? []) {
       const clause = definition.clauses.find(
         (candidate) => candidate.id === projection.ref,
@@ -806,6 +985,7 @@ export class TriggerControlPlane {
       required: [
         '_derived',
         ...Object.keys(definition.derivedEvent.constants ?? {}),
+        ...(definition.derivedEvent.measures ?? []).map((measure) => measure.key),
       ],
     };
   }

package/scripts/lib/trigger-inspector.mjs

@@ -166,6 +166,18 @@ function explain({
     };
   }
 
+  if (definition.patternV2) {
+    return {
+      code: 'pattern_v2_waiting',
+      summary:
+        'Pattern AST v2 has buffered evidence but no new complete match is currently eligible.',
+      patternVersion: '2',
+      bufferRole: match.patternState?.role ?? null,
+      semanticDecisions:
+        match.patternState?.semanticDecisions ?? [],
+    };
+  }
+
   const missing = clauses
     .filter((clause) => clause.status !== 'satisfied')
     .map((clause) => clause.clauseId);
@@ -312,6 +324,7 @@ export class TriggerInspector {
         derivedEvent: definition.derivedEvent ?? null,
         expression: definition.expression,
         temporal: definition.temporal ?? [],
+        patternV2: definition.patternV2 ?? null,
         lifecycle: definition.lifecycle ?? {},
       },
       lifecycle: state,
@@ -323,6 +336,7 @@ export class TriggerInspector {
             openedAt: match.openedAt,
             expiresAt: match.expiresAt,
             updatedAt: match.updatedAt,
+            patternState: match.patternState ?? null,
           }
         : null,
       clauses,
@@ -360,6 +374,7 @@ export class TriggerInspector {
           rootEvidence: record.rootEvidence,
         })),
         matchHistory,
+        patternState: match?.patternState ?? null,
       },
       why: explain({
         definition,