mcp-event-intelligence 0.1.1 → 0.2.1

package/dist/src/composite/runtimeSupport.js

@@ -0,0 +1,176 @@
+import { sha256Hex } from '../intelligenceProtocol/canonical.js';
+export class CompositeTriggerRuntimeSupport {
+    store;
+    now;
+    constructor(store, now = () => new Date()) {
+        this.store = store;
+        this.now = now;
+    }
+    async scheduleDeadlines(definition, record, deadlines) {
+        if (!this.store.putTemporalDeadline)
+            return;
+        for (const deadline of deadlines) {
+            const deadlineId = `td_${(await sha256Hex([
+                definition.triggerId,
+                definition.version,
+                record.matchId,
+                deadline.conditionId,
+                deadline.dueAt,
+            ].join(':'))).slice(0, 24)}`;
+            const existing = this.store.getTemporalDeadline?.(deadlineId);
+            if (existing?.status === 'pending' || existing?.status === 'fired') {
+                continue;
+            }
+            await this.store.putTemporalDeadline({
+                deadlineId,
+                triggerId: definition.triggerId,
+                triggerVersion: definition.version,
+                matchId: record.matchId,
+                conditionId: deadline.conditionId,
+                dueAt: deadline.dueAt,
+                status: 'pending',
+            });
+        }
+    }
+    async cancelDeadlinesForMatch(matchId) {
+        if (!this.store.listTemporalDeadlines ||
+            !this.store.setTemporalDeadlineStatus)
+            return;
+        const pending = this.store.listTemporalDeadlines({
+            matchId,
+            status: 'pending',
+        });
+        for (const deadline of pending) {
+            await this.store.setTemporalDeadlineStatus(deadline.deadlineId, 'cancelled');
+        }
+    }
+    async advanceLifecycleAfterEffect(match, effectKind, effectId) {
+        const definition = this.store.listTriggers().find((candidate) => candidate.triggerId === match.triggerId &&
+            candidate.version === match.triggerVersion);
+        const triggerState = this.store.getTriggerState?.(match.triggerId, match.triggerVersion) ?? null;
+        if (!definition || !this.store.setTriggerState)
+            return;
+        const previousCount = triggerState?.fireCount ?? 0;
+        const fireCount = previousCount + 1;
+        const lifecycle = definition.lifecycle ?? {};
+        const complete = lifecycle.oneShot === true ||
+            lifecycle.completeOnGoal === true ||
+            (lifecycle.maxFirings !== undefined &&
+                fireCount >= lifecycle.maxFirings);
+        const nextStatus = complete ? 'completed' : 'active';
+        const effectAt = this.now().toISOString();
+        await this.store.setTriggerState(match.triggerId, match.triggerVersion, nextStatus, {
+            type: 'system',
+            principal_id: 'event-intelligence:lifecycle',
+        }, {
+            owner: triggerState?.owner ?? null,
+            connectionIds: triggerState?.connectionIds ?? [],
+            fireCount,
+            lastFiredAt: effectAt,
+        });
+        if (complete) {
+            await this.auditTriggerLifecycle(definition, 'trigger.completed', {
+                reason: lifecycle.oneShot
+                    ? 'one_shot'
+                    : lifecycle.completeOnGoal
+                        ? 'complete_on_goal'
+                        : 'max_firings',
+                fireCount,
+                effectKind,
+                effectId,
+            });
+        }
+    }
+    async lifecycleAllows(definition, state, now) {
+        const lifecycle = definition.lifecycle ?? {};
+        const effectiveState = state ?? {
+            status: 'active',
+            fireCount: 0,
+            lastFiredAt: null,
+            connectionIds: [],
+            owner: null,
+        };
+        if (effectiveState.status !== 'active')
+            return false;
+        const expiresAt = lifecycle.expiresAt
+            ? Date.parse(lifecycle.expiresAt)
+            : Number.POSITIVE_INFINITY;
+        const leaseUntil = lifecycle.leaseUntil
+            ? Date.parse(lifecycle.leaseUntil)
+            : Number.POSITIVE_INFINITY;
+        if (now.getTime() > Math.min(expiresAt, leaseUntil)) {
+            if (this.store.setTriggerState) {
+                await this.store.setTriggerState(definition.triggerId, definition.version, 'expired', {
+                    type: 'system',
+                    principal_id: 'event-intelligence:lifecycle',
+                }, {
+                    owner: effectiveState.owner ?? null,
+                    connectionIds: effectiveState.connectionIds ?? [],
+                    fireCount: effectiveState.fireCount ?? 0,
+                    lastFiredAt: effectiveState.lastFiredAt ?? null,
+                });
+            }
+            await this.auditTriggerLifecycle(definition, 'trigger.lifecycle_expired', {
+                expiresAt: lifecycle.expiresAt ?? null,
+                leaseUntil: lifecycle.leaseUntil ?? null,
+            });
+            return false;
+        }
+        const fireCount = effectiveState.fireCount ?? 0;
+        if ((lifecycle.oneShot && fireCount >= 1) ||
+            (lifecycle.maxFirings !== undefined &&
+                fireCount >= lifecycle.maxFirings)) {
+            if (this.store.setTriggerState) {
+                await this.store.setTriggerState(definition.triggerId, definition.version, 'completed', {
+                    type: 'system',
+                    principal_id: 'event-intelligence:lifecycle',
+                }, {
+                    owner: effectiveState.owner ?? null,
+                    connectionIds: effectiveState.connectionIds ?? [],
+                    fireCount,
+                    lastFiredAt: effectiveState.lastFiredAt ?? null,
+                });
+            }
+            return false;
+        }
+        if (lifecycle.cooldownMs > 0 &&
+            effectiveState.lastFiredAt &&
+            now.getTime() - Date.parse(effectiveState.lastFiredAt) <
+                lifecycle.cooldownMs) {
+            return false;
+        }
+        return true;
+    }
+    async auditTriggerLifecycle(definition, kind, details) {
+        const timestamp = this.now().toISOString();
+        await this.store.appendAudit({
+            auditId: `audit_${(await sha256Hex(`${definition.triggerId}:${definition.version}:${kind}:${timestamp}`)).slice(0, 24)}`,
+            traceId: `trigger:${definition.triggerId}`,
+            timestamp,
+            kind,
+            entityType: 'trigger',
+            entityId: definition.triggerId,
+            details: {
+                triggerVersion: definition.version,
+                ...details,
+            },
+        });
+    }
+    async auditMatch(record, kind, details = {}) {
+        await this.store.appendAudit({
+            auditId: `audit_${(await sha256Hex(`${record.matchId}:${kind}:${record.updatedAt}:${this.store.listTriggerMatches().length}`)).slice(0, 24)}`,
+            traceId: record.sourceEvents[0]?.traceId ?? record.matchId,
+            timestamp: this.now().toISOString(),
+            kind,
+            entityType: 'trigger_match',
+            entityId: record.matchId,
+            details: {
+                triggerId: record.triggerId,
+                triggerVersion: record.triggerVersion,
+                status: record.status,
+                correlationKey: record.correlationKey,
+                ...details,
+            },
+        });
+    }
+}

package/dist/src/composite/store.d.ts

@@ -0,0 +1,59 @@
+import type { CompositeTriggerDefinition, TriggerMatchRecord } from '../intelligenceProtocol/triggerSchemas.js';
+export interface CompositeTriggerStore {
+    putTrigger(definition: CompositeTriggerDefinition): Promise<void>;
+    listTriggers(): CompositeTriggerDefinition[];
+    getTriggerState?(triggerId: string, version: string): {
+        status: 'active' | 'paused' | 'completed' | 'expired' | 'deleted';
+        owner?: unknown;
+        connectionIds?: string[];
+        fireCount?: number;
+        lastFiredAt?: string | null;
+        revision?: number;
+    } | null;
+    setTriggerState?(triggerId: string, version: string, status: 'active' | 'paused' | 'completed' | 'expired' | 'deleted', actor?: unknown, metadata?: Record<string, unknown>): Promise<unknown>;
+    appendTriggerMatch(record: TriggerMatchRecord): Promise<void>;
+    listTriggerMatches(triggerId?: string): TriggerMatchRecord[];
+    getTemporalDeadline?(deadlineId: string): {
+        deadlineId: string;
+        triggerId: string;
+        triggerVersion: string;
+        matchId: string;
+        conditionId: string;
+        dueAt: string;
+        status: 'pending' | 'cancelled' | 'fired';
+    } | null;
+    listTemporalDeadlines?(filter?: {
+        triggerId?: string;
+        matchId?: string;
+        status?: string;
+    }): Array<{
+        deadlineId: string;
+        triggerId: string;
+        triggerVersion: string;
+        matchId: string;
+        conditionId: string;
+        dueAt: string;
+        status: string;
+    }>;
+    putTemporalDeadline?(input: {
+        deadlineId: string;
+        triggerId: string;
+        triggerVersion: string;
+        matchId: string;
+        conditionId: string;
+        dueAt: string;
+        status: 'pending' | 'cancelled' | 'fired';
+    }): Promise<unknown>;
+    setTemporalDeadlineStatus?(deadlineId: string, status: 'pending' | 'cancelled' | 'fired'): Promise<unknown>;
+}
+export interface CompositeTriggerAudit {
+    appendAudit(input: {
+        auditId: string;
+        traceId: string;
+        timestamp: string;
+        kind: string;
+        entityType: 'trigger_match' | 'trigger';
+        entityId: string;
+        details?: Record<string, unknown>;
+    }): Promise<unknown>;
+}

package/dist/src/composite/store.js

@@ -0,0 +1 @@
+export {};

package/dist/src/intelligenceProtocol/schemas.d.ts

@@ -68,8 +68,8 @@ export declare const SemanticDecisionRecordSchema: z.ZodObject<{
     createdAt: z.ZodString;
     evaluator: z.ZodString;
     outcome: z.ZodEnum<{
-        reject: "reject";
         match: "match";
+        reject: "reject";
         uncertain: "uncertain";
     }>;
     probability: z.ZodNumber;
@@ -79,9 +79,9 @@ export declare const SemanticDecisionRecordSchema: z.ZodObject<{
         matchThreshold: z.ZodNumber;
         rejectThreshold: z.ZodNumber;
         uncertain: z.ZodEnum<{
-            escalate: "escalate";
-            reject: "reject";
             match: "match";
+            reject: "reject";
+            escalate: "escalate";
         }>;
     }, z.core.$strip>;
     inputFields: z.ZodArray<z.ZodString>;
@@ -136,9 +136,9 @@ export declare const SemanticConditionWireSchema: z.ZodObject<{
     matchThreshold: z.ZodNumber;
     rejectThreshold: z.ZodNumber;
     uncertain: z.ZodEnum<{
-        escalate: "escalate";
-        reject: "reject";
         match: "match";
+        reject: "reject";
+        escalate: "escalate";
     }>;
 }, z.core.$strip>;
 export declare const EventIngestRequestSchema: z.ZodObject<{
@@ -181,9 +181,9 @@ export declare const EventIngestRequestSchema: z.ZodObject<{
         matchThreshold: z.ZodNumber;
         rejectThreshold: z.ZodNumber;
         uncertain: z.ZodEnum<{
-            escalate: "escalate";
-            reject: "reject";
             match: "match";
+            reject: "reject";
+            escalate: "escalate";
         }>;
     }, z.core.$strip>>;
     wakeOnEscalation: z.ZodDefault<z.ZodBoolean>;
@@ -209,6 +209,7 @@ export declare const AuditKindSchema: z.ZodEnum<{
     "lifecycle.transition": "lifecycle.transition";
     "wake.queued": "wake.queued";
     "wake.delivered": "wake.delivered";
+    "wake.retry_scheduled": "wake.retry_scheduled";
     "wake.handled": "wake.handled";
     "wake.dead_letter": "wake.dead_letter";
     "trigger.partial": "trigger.partial";
@@ -244,6 +245,7 @@ export declare const AuditRecordSchema: z.ZodObject<{
         "lifecycle.transition": "lifecycle.transition";
         "wake.queued": "wake.queued";
         "wake.delivered": "wake.delivered";
+        "wake.retry_scheduled": "wake.retry_scheduled";
         "wake.handled": "wake.handled";
         "wake.dead_letter": "wake.dead_letter";
         "trigger.partial": "trigger.partial";

package/dist/src/intelligenceProtocol/schemas.js

@@ -117,6 +117,7 @@ export const AuditKindSchema = z.enum([
     'lifecycle.transition',
     'wake.queued',
     'wake.delivered',
+    'wake.retry_scheduled',
     'wake.handled',
     'wake.dead_letter',
     'trigger.partial',

package/dist/src/intelligenceProtocol/triggerSchemas.d.ts

@@ -182,9 +182,9 @@ export declare const SemanticCorrelationSchema: z.ZodObject<{
     matchThreshold: z.ZodNumber;
     rejectThreshold: z.ZodNumber;
     uncertain: z.ZodDefault<z.ZodEnum<{
-        escalate: "escalate";
-        reject: "reject";
         match: "match";
+        reject: "reject";
+        escalate: "escalate";
     }>>;
 }, z.core.$strip>;
 export declare const CompositeTriggerDefinitionSchema: z.ZodObject<{
@@ -320,9 +320,9 @@ export declare const CompositeTriggerDefinitionSchema: z.ZodObject<{
             matchThreshold: z.ZodNumber;
             rejectThreshold: z.ZodNumber;
             uncertain: z.ZodDefault<z.ZodEnum<{
-                escalate: "escalate";
-                reject: "reject";
                 match: "match";
+                reject: "reject";
+                escalate: "escalate";
             }>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
@@ -408,8 +408,8 @@ export declare const TriggerSourceEventSchema: z.ZodObject<{
 export declare const CompositeCorrelationDecisionSchema: z.ZodObject<{
     evaluator: z.ZodString;
     outcome: z.ZodEnum<{
-        reject: "reject";
         match: "match";
+        reject: "reject";
         uncertain: "uncertain";
     }>;
     probability: z.ZodNumber;
@@ -457,8 +457,8 @@ export declare const TriggerMatchRecordSchema: z.ZodObject<{
     correlationDecision: z.ZodNullable<z.ZodObject<{
         evaluator: z.ZodString;
         outcome: z.ZodEnum<{
-            reject: "reject";
             match: "match";
+            reject: "reject";
             uncertain: "uncertain";
         }>;
         probability: z.ZodNumber;

package/dist/src/mcpEvents/erpnextProvider.d.ts

@@ -0,0 +1,20 @@
+import { type McpEventsProvider, type ProviderPollRequest } from './provider.js';
+export type ErpNextEventName = 'erpnext.sales_invoice.submitted' | 'erpnext.sales_order.created';
+export interface ErpNextProviderPollResult {
+    events: Array<{
+        eventId: string;
+        timestamp: string;
+        data: Record<string, unknown>;
+    }>;
+    cursor: string;
+    hasMore?: boolean;
+    nextPollMs?: number;
+}
+export type ErpNextEventPoller<TContext = unknown> = (request: ProviderPollRequest<TContext>) => ErpNextProviderPollResult | Promise<ErpNextProviderPollResult>;
+export interface CreateErpNextEventsProviderOptions<TContext = unknown> {
+    pollSalesInvoices: ErpNextEventPoller<TContext>;
+    pollSalesOrders: ErpNextEventPoller<TContext>;
+    supportedVersions?: string[];
+    instructions?: string;
+}
+export declare function createErpNextEventsProvider<TContext = unknown>(options: CreateErpNextEventsProviderOptions<TContext>): McpEventsProvider<TContext>;

package/dist/src/mcpEvents/erpnextProvider.js

@@ -0,0 +1,80 @@
+import { createMcpEventsProvider, } from './provider.js';
+function toOccurrences(name, result) {
+    return result.events.map((event) => ({
+        eventId: String(event.eventId),
+        name,
+        timestamp: String(event.timestamp),
+        data: event.data,
+    }));
+}
+export function createErpNextEventsProvider(options) {
+    if (!options || typeof options.pollSalesInvoices !== 'function') {
+        throw new Error('ERPNext Events provider requires pollSalesInvoices()');
+    }
+    if (typeof options.pollSalesOrders !== 'function') {
+        throw new Error('ERPNext Events provider requires pollSalesOrders()');
+    }
+    return createMcpEventsProvider({
+        supportedVersions: options.supportedVersions,
+        instructions: options.instructions ??
+            'ERPNext MCP Events adapter exposing host-owned Sales Invoice and Sales Order changes.',
+        events: [
+            {
+                descriptor: {
+                    name: 'erpnext.sales_invoice.submitted',
+                    description: 'A Sales Invoice reached submitted status in ERPNext.',
+                    delivery: ['poll'],
+                    inputSchema: {},
+                    payloadSchema: {
+                        type: 'object',
+                        required: ['name'],
+                        properties: {
+                            name: { type: 'string', minLength: 1 },
+                            company: { type: 'string' },
+                            customer: { type: 'string' },
+                            grand_total: { type: 'number' },
+                            currency: { type: 'string' },
+                        },
+                    },
+                },
+                poll: async (request) => {
+                    const result = await options.pollSalesInvoices(request);
+                    return {
+                        events: toOccurrences('erpnext.sales_invoice.submitted', result),
+                        cursor: result.cursor,
+                        hasMore: result.hasMore ?? false,
+                        nextPollMs: result.nextPollMs ?? 5000,
+                    };
+                },
+            },
+            {
+                descriptor: {
+                    name: 'erpnext.sales_order.created',
+                    description: 'A Sales Order was created in ERPNext.',
+                    delivery: ['poll'],
+                    inputSchema: {},
+                    payloadSchema: {
+                        type: 'object',
+                        required: ['name'],
+                        properties: {
+                            name: { type: 'string', minLength: 1 },
+                            company: { type: 'string' },
+                            customer: { type: 'string' },
+                            grand_total: { type: 'number' },
+                            currency: { type: 'string' },
+                        },
+                    },
+                },
+                poll: async (request) => {
+                    const result = await options.pollSalesOrders(request);
+                    return {
+                        events: toOccurrences('erpnext.sales_order.created', result),
+                        cursor: result.cursor,
+                        hasMore: result.hasMore ?? false,
+                        nextPollMs: result.nextPollMs ?? 5000,
+                    };
+                },
+            },
+        ],
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-event-intelligence",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Durable temporal event intelligence for agent hosts: host-owned MCP event discovery, composite triggers, derived events, and targeted wakeups.",
   "license": "Apache-2.0",
   "type": "module",
@@ -18,6 +18,10 @@
     "./provider": {
       "types": "./dist/src/mcpEvents/provider.d.ts",
       "import": "./dist/src/mcpEvents/provider.js"
+    },
+    "./provider/erpnext": {
+      "types": "./dist/src/mcpEvents/erpnextProvider.d.ts",
+      "import": "./dist/src/mcpEvents/erpnextProvider.js"
     }
   },
   "bin": {

package/scripts/host-integration.d.mts

@@ -14,8 +14,12 @@ export interface HostMcpConnectionOptions {
   client?: HostMcpClientLike;
   request?: (method: string, params?: unknown) => Promise<unknown>;
   enabled?: boolean;
+  /** Isolation partition used by the shared EI host. Defaults to \"default\". */
+  scopeId?: string;
   pollIntervalMs?: number;
   maxEvents?: number;
+  /** Maximum number of immediately drained pages when the provider reports hasMore. */
+  maxPollBatches?: number;
 }
 
 export interface HostMcpRegistry {
@@ -36,8 +40,18 @@ export type HostWakeHandler = (
   packet: Record<string, unknown>,
 ) => Promise<HostWakeReceipt | string> | HostWakeReceipt | string;
 
+export interface EventIntelligenceStore {
+  init?(): Promise<unknown>;
+  /** Required when non-default scopes are used. Implementations should return an isolated store view. */
+  forScope?(scopeId: string): Promise<EventIntelligenceStore> | EventIntelligenceStore;
+  listScopeIds?(): Promise<string[]> | string[];
+  [key: string]: any;
+}
+
 export interface EventIntelligenceHostOptions {
   dataDir?: string;
+  /** Optional storage backend. PersistentEventStore is used when omitted. */
+  store?: EventIntelligenceStore;
   env?: Record<string, string | undefined>;
   mcpRegistry?: HostMcpRegistry;
   /** Low-level/manual fallback; prefer mcpRegistry for automatic discovery. */
@@ -49,19 +63,25 @@ export interface EventIntelligenceHostOptions {
   semanticEvaluator?: unknown;
 }
 
-export interface EventIntelligenceHost {
+export interface EventIntelligenceScopedHost {
+  readonly scopeId: string;
   readonly runtime: any;
-  readonly store: any;
+  readonly store: EventIntelligenceStore;
   readonly triggerControl: any;
   readonly triggerInspector: any;
   readonly eventSources: any[];
-  refreshMcpRegistry(): Promise<any[]>;
   attachMcpClient(connection: HostMcpConnectionOptions): Promise<{
     connectionId: string;
     events: any[];
   }>;
-  detachMcpClient(connectionId: string): Promise<boolean>;
   mcpStatus(): any[];
+}
+
+export interface EventIntelligenceHost extends EventIntelligenceScopedHost {
+  refreshMcpRegistry(): Promise<any[]>;
+  detachMcpClient(connectionId: string): Promise<boolean>;
+  loadedScopes(): string[];
+  scope(scopeId?: string): Promise<EventIntelligenceScopedHost>;
   close(): Promise<void>;
 }
 
@@ -84,3 +104,13 @@ export function createHostMcpEventsConnection(
 export function createEventIntelligenceHost(
   options?: EventIntelligenceHostOptions,
 ): Promise<EventIntelligenceHost>;
+
+
+export class PersistentEventStore implements EventIntelligenceStore {
+  constructor(dataDir: string);
+  readonly dataDir: string;
+  init(): Promise<unknown>;
+  forScope(scopeId?: string): Promise<PersistentEventStore>;
+  listScopeIds(): Promise<string[]>;
+  [key: string]: any;
+}

package/scripts/host-integration.mjs

@@ -4,6 +4,11 @@ import {
 import {
   createHostMcpEventsConnection,
 } from './lib/mcp-events-client.mjs';
+import {
+  DEFAULT_EVENT_SCOPE_ID,
+  PersistentEventStore,
+  normalizeEventScopeId,
+} from './lib/persistent-event-store.mjs';
 
 function normalizeMcpConnection(input) {
   const connectionId = String(
@@ -61,6 +66,31 @@ export function createMcpRegistryAdapter({
   };
 }
 
+function scopedHostView(runtime, context) {
+  const scopeId = context.scopeId;
+  return {
+    scopeId,
+    runtime: context,
+    store: context.store,
+    triggerControl: context.triggerControl,
+    triggerInspector: context.triggerInspector,
+    get eventSources() {
+      return context.triggerControl.listEventSources();
+    },
+    async attachMcpClient(connection) {
+      const normalized = normalizeMcpConnection({
+        ...connection,
+        scopeId,
+      });
+      return runtime.mcpEventsClient.attachConnection(normalized);
+    },
+    mcpStatus() {
+      return runtime.mcpEventsClient.status()
+        .filter((entry) => entry.scopeId === scopeId);
+    },
+  };
+}
+
 /**
  * Embed Event Intelligence once at the harness/host level.
  *
@@ -70,6 +100,7 @@ export function createMcpRegistryAdapter({
  */
 export async function createEventIntelligenceHost({
   dataDir,
+  store,
   env = {},
   mcpRegistry,
   mcpClients = [],
@@ -88,6 +119,7 @@ export async function createEventIntelligenceHost({
     wake,
     wakeHandlers,
     semanticEvaluator,
+    store,
   });
 
   const registryManaged = new Set();
@@ -117,7 +149,8 @@ export async function createEventIntelligenceHost({
       if (existing) {
         if (
           existing.identity === connection.identity &&
-          existing.serverId === connection.serverId
+          existing.serverId === connection.serverId &&
+          existing.scopeId === connection.scopeId
         ) {
           registryManaged.add(connectionId);
           outcomes.push({ connectionId, status: 'already_attached' });
@@ -179,6 +212,7 @@ export async function createEventIntelligenceHost({
   }
 
   return {
+    scopeId: DEFAULT_EVENT_SCOPE_ID,
     runtime,
     get store() {
       return runtime.store;
@@ -204,6 +238,14 @@ export async function createEventIntelligenceHost({
     mcpStatus() {
       return runtime.mcpEventsClient.status();
     },
+    loadedScopes() {
+      return runtime.loadedScopes();
+    },
+    async scope(scopeIdInput = DEFAULT_EVENT_SCOPE_ID) {
+      const scopeId = normalizeEventScopeId(scopeIdInput);
+      const context = await runtime.scope(scopeId);
+      return scopedHostView(runtime, context);
+    },
     async close() {
       unsubscribe?.();
       await runtime.close();
@@ -213,4 +255,5 @@ export async function createEventIntelligenceHost({
 
 export {
   createHostMcpEventsConnection,
+  PersistentEventStore,
 };