mcp-event-intelligence 0.1.0 → 0.2.0

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/dist/src/mcpEvents/provider.d.ts

@@ -0,0 +1,48 @@
+import type { EventDescriptor, EventOccurrence, JsonRpcRequest, JsonRpcResponse } from '../protocol/types.js';
+export declare const MCP_EVENTS_CAPABILITY_KEY: "io.modelcontextprotocol.experimental/events";
+export declare const MCP_EVENTS_CAPABILITY: Readonly<{
+    status: "draft";
+    designDate: "2026-02-19";
+    methods: readonly ["events/list", "events/poll"];
+    listChanged: false;
+}>;
+export interface ProviderPollRequest<TContext = unknown> {
+    name: string;
+    arguments: Record<string, unknown>;
+    cursor: string | null;
+    maxAgeMs?: number;
+    maxEvents: number;
+    context?: TContext;
+}
+export interface ProviderPollResult {
+    events: EventOccurrence[];
+    cursor: string;
+    truncated?: boolean;
+    hasMore?: boolean;
+    nextPollMs?: number;
+}
+export interface McpProviderEvent<TContext = unknown> {
+    descriptor: EventDescriptor;
+    poll: (request: ProviderPollRequest<TContext>) => ProviderPollResult | Promise<ProviderPollResult>;
+}
+export interface CreateMcpEventsProviderOptions<TContext = unknown> {
+    events: McpProviderEvent<TContext>[];
+    supportedVersions?: string[];
+    instructions?: string;
+}
+export declare function assertJsonSchemaValue(schemaInput: Record<string, unknown>, value: unknown, path?: string): void;
+export declare class McpEventsProvider<TContext = unknown> {
+    private readonly events;
+    readonly supportedVersions: string[];
+    readonly instructions: string;
+    constructor(options: CreateMcpEventsProviderOptions<TContext>);
+    canHandle(method: string): boolean;
+    listEvents(): EventDescriptor[];
+    handleRequest(request: JsonRpcRequest, context?: TContext): Promise<JsonRpcResponse>;
+    private poll;
+    private ok;
+    private error;
+}
+export declare function createMcpEventsProvider<TContext = unknown>(options: CreateMcpEventsProviderOptions<TContext>): McpEventsProvider<TContext>;
+export { ExperimentalMcpEventsServer, decodeMcpEventCursor, encodeMcpEventCursor, } from './server.js';
+export type { McpEventOccurrenceStore, PersistedMcpOccurrence, PollEventsParams, PollEventsResult, RegisteredMcpEvent, } from './server.js';