mcp-event-intelligence 0.5.0 → 0.6.0

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

@@ -2,9 +2,6 @@ import {
   parseDerivedEventRecord,
   sha256Hex,
 } from '../../dist/src/intelligenceProtocol/index.js';
-import {
-  evaluateTemporalConditions,
-} from '../../dist/src/composite/temporal.js';
 import {
   evaluatePatternMeasure,
 } from '../../dist/src/patternV2/evaluator.js';
@@ -92,22 +89,14 @@ function patternCandidateForMatch(match) {
   };
 }
 
-function derivedOccurredAt(match, definition) {
+function derivedOccurredAt(match) {
+  if (match.patternState?.completedAt) {
+    return match.patternState.completedAt;
+  }
+
   const candidates = match.sourceEvents
     .map((event) => Date.parse(event.occurredAt))
     .filter(Number.isFinite);
-
-  const temporal = evaluateTemporalConditions(
-    definition,
-    match,
-    new Date(match.updatedAt),
-  );
-  for (const state of temporal.conditionStates) {
-    if (state.status !== 'satisfied' || !state.dueAt) continue;
-    const dueAt = Date.parse(state.dueAt);
-    if (Number.isFinite(dueAt)) candidates.push(dueAt);
-  }
-
   if (!candidates.length) return match.updatedAt;
   return new Date(Math.max(...candidates)).toISOString();
 }
@@ -141,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,
     );
@@ -162,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,
         );
@@ -219,7 +208,7 @@ export class DerivedEventCoordinator {
       }
     }
 
-    const contract = this.store.getDerivedContract(
+    const contract = await this.store.getDerivedContract(
       spec.name,
       spec.contractVersion,
     );
@@ -239,7 +228,7 @@ export class DerivedEventCoordinator {
         triggerId: definition.triggerId,
         triggerVersion: definition.version,
         matchId: match.matchId,
-        correlationKey: match.correlationKey,
+        partitionKey: match.partitionKey,
         contractVersion: spec.contractVersion,
         schemaFingerprint: contract.schemaFingerprint,
       },
@@ -249,7 +238,7 @@ export class DerivedEventCoordinator {
       traceId: `derived:${eventId}`,
       sourceEventId: eventId,
       name: spec.name,
-      occurredAt: derivedOccurredAt(match, definition),
+      occurredAt: derivedOccurredAt(match),
       receivedAt: this.now().toISOString(),
       provider: 'event-intelligence',
       serverId: DERIVED_EVENT_SERVER_ID,
@@ -296,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

@@ -394,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) {
@@ -486,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 &&
@@ -571,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;
@@ -664,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,
@@ -687,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,
@@ -810,7 +811,7 @@ export class McpEventsClientManager {
     }
     if (existing) await this.closeSession(subscription.subscriptionId);
 
-    const current = context.store.getMcpClientState(
+    const current = await context.store.getMcpClientState(
       connection.connectionId,
       subscription.eventName,
       subscription.arguments,
@@ -995,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 = [];
 
@@ -1062,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();
@@ -1101,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));
@@ -1136,15 +1140,15 @@ 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
-        ? this.desiredSubscriptions(connection, context)
+        ? await this.desiredSubscriptions(connection, context)
         : new Map();
       return {
         connectionId: connection.connectionId,
@@ -1177,6 +1181,6 @@ export class McpEventsClientManager {
         ),
         error: this.lastErrors.get(connection.connectionId) ?? null,
       };
-    });
+    }));
   }
 }