mcp-event-intelligence 0.3.1 → 0.5.0

package/dist/src/intelligenceProtocol/triggerSchemas.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { RuntimeTargetSchema } from './schemas.js';
+import { PatternAstV2DefinitionSchema, PatternMeasureSchema, collectPatternDurationsMs, collectGuaranteedPatternBindings, collectPatternMeasureRefs, collectPatternRefs, } from './patternV2Schemas.js';
 export const COMPOSITE_TRIGGER_PROTOCOL_VERSION = '0.1.0';
 export const COMPOSITE_TRIGGER_SCHEMA_VERSION = 'trigger.v0.1';
 const Id = z.string().min(1).max(200);
@@ -11,8 +12,28 @@ export const StructuredPredicateSchema = z.discriminatedUnion('op', [
     z.object({ path: z.string().min(1), op: z.literal('eq'), value: Scalar }),
     z.object({ path: z.string().min(1), op: z.literal('neq'), value: Scalar }),
     z.object({ path: z.string().min(1), op: z.literal('contains'), value: Scalar }),
+    z.object({ path: z.string().min(1), op: z.literal('startsWith'), value: z.string() }),
+    z.object({ path: z.string().min(1), op: z.literal('endsWith'), value: z.string() }),
+    z.object({
+        path: z.string().min(1),
+        op: z.literal('regex'),
+        value: z.string(),
+        flags: z.string().max(10).optional(),
+    }),
     z.object({ path: z.string().min(1), op: z.literal('in'), value: z.array(Scalar).min(1) }),
+    z.object({ path: z.string().min(1), op: z.literal('notIn'), value: z.array(Scalar).min(1) }),
+    z.object({
+        path: z.string().min(1),
+        op: z.literal('between'),
+        value: z.tuple([Scalar, Scalar]),
+    }),
     z.object({ path: z.string().min(1), op: z.literal('exists'), value: z.boolean().default(true) }),
+    z.object({ path: z.string().min(1), op: z.literal('isNull'), value: z.boolean().default(true) }),
+    z.object({
+        path: z.string().min(1),
+        op: z.literal('type'),
+        value: z.enum(['string', 'number', 'boolean', 'null', 'object', 'array']),
+    }),
     z.object({ path: z.string().min(1), op: z.literal('gt'), value: z.number() }),
     z.object({ path: z.string().min(1), op: z.literal('gte'), value: z.number() }),
     z.object({ path: z.string().min(1), op: z.literal('lt'), value: z.number() }),
@@ -23,6 +44,7 @@ export const TriggerClauseSchema = z.object({
     event: z.string().min(1),
     serverId: Id.optional(),
     contractVersion: z.string().min(1).max(50).optional(),
+    arguments: z.record(z.string(), z.unknown()).default({}),
     where: z.array(StructuredPredicateSchema).default([]),
 });
 const TriggerExpressionSchema = z.discriminatedUnion('kind', [
@@ -112,6 +134,7 @@ export const DerivedEventDefinitionSchema = z.object({
     contractVersion: z.string().min(1).max(50),
     projections: z.array(DerivedEventProjectionSchema).max(32).default([]),
     constants: z.record(z.string(), Scalar).default({}),
+    measures: z.array(PatternMeasureSchema).max(32).default([]),
 }).strict();
 export const DerivedEventEvidenceRefSchema = z.object({
     serverId: Id.nullable(),
@@ -119,10 +142,15 @@ export const DerivedEventEvidenceRefSchema = z.object({
     sourceEventId: Id,
     traceId: Id,
     occurredAt: Timestamp,
+    receivedAt: Timestamp.optional(),
     payloadHash: z.string().regex(/^[a-f0-9]{64}$/).nullable(),
     contractVersion: z.string().min(1).nullable().optional(),
     schemaFingerprint: z.string().regex(/^[a-f0-9]{64}$/).nullable().optional(),
 }).strict();
+export const EventTimePolicySchema = z.object({
+    allowedLatenessMs: z.number().int().nonnegative()
+        .max(1000 * 60 * 60 * 24 * 30),
+}).strict();
 export const TriggerLifecyclePolicySchema = z.object({
     oneShot: z.boolean().default(false),
     maxFirings: z.number().int().min(1).optional(),
@@ -181,10 +209,13 @@ export const CompositeTriggerDefinitionSchema = z.object({
     triggerId: Id,
     version: z.string().min(1),
     description: z.string().max(500).optional(),
+    conditionOnly: z.boolean().default(false),
     continuation: ContinuationContractSchema.optional(),
     clauses: z.array(TriggerClauseSchema).min(1),
     expression: TriggerExpressionSchema,
     temporal: z.array(TemporalConditionSchema).default([]),
+    patternV2: PatternAstV2DefinitionSchema.optional(),
+    eventTime: EventTimePolicySchema.optional(),
     lifecycle: TriggerLifecyclePolicySchema.default({
         oneShot: false,
         cooldownMs: 0,
@@ -198,10 +229,27 @@ export const CompositeTriggerDefinitionSchema = z.object({
     target: RuntimeTargetSchema.optional(),
     derivedEvent: DerivedEventDefinitionSchema.optional(),
 }).superRefine((value, ctx) => {
-    if (!value.target && !value.derivedEvent) {
+    if (!value.target && !value.derivedEvent && !value.conditionOnly) {
         ctx.addIssue({
             code: 'custom',
-            message: 'Trigger requires target, derivedEvent, or both',
+            message: 'Trigger requires target, derivedEvent, or conditionOnly=true',
+        });
+    }
+    if (value.conditionOnly &&
+        (value.target || value.derivedEvent || value.continuation)) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'conditionOnly triggers cannot declare target, derivedEvent, or continuation',
+        });
+    }
+    if (value.conditionOnly &&
+        (value.lifecycle.oneShot ||
+            value.lifecycle.maxFirings !== undefined ||
+            value.lifecycle.cooldownMs > 0 ||
+            value.lifecycle.completeOnGoal)) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'conditionOnly triggers cannot use effect-based lifecycle fields',
         });
     }
     if (value.continuation && !value.target) {
@@ -235,6 +283,36 @@ export const CompositeTriggerDefinitionSchema = z.object({
     }
     if (value.derivedEvent) {
         const projectionKeys = new Set();
+        const measureKeys = new Set();
+        for (const measure of value.derivedEvent.measures ?? []) {
+            if (measure.key === '_derived') {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: 'Derived event measure key _derived is reserved',
+                });
+            }
+            if (measureKeys.has(measure.key)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: `Derived event measure key must be unique: ${measure.key}`,
+                });
+            }
+            if (Object.prototype.hasOwnProperty.call(value.derivedEvent.constants, measure.key)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: `Derived event key cannot be both constant and measure: ${measure.key}`,
+                });
+            }
+            for (const ref of collectPatternMeasureRefs(measure)) {
+                if (!ids.has(ref)) {
+                    ctx.addIssue({
+                        code: 'custom',
+                        message: `Derived event measure ${measure.key} references unknown clause: ${ref}`,
+                    });
+                }
+            }
+            measureKeys.add(measure.key);
+        }
         for (const projection of value.derivedEvent.projections) {
             if (!ids.has(projection.ref)) {
                 ctx.addIssue({
@@ -242,6 +320,12 @@ export const CompositeTriggerDefinitionSchema = z.object({
                     message: `Derived event projection references unknown clause: ${projection.ref}`,
                 });
             }
+            if (measureKeys.has(projection.key)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: `Derived event key cannot be both measure and projection: ${projection.key}`,
+                });
+            }
             if (projectionKeys.has(projection.key)) {
                 ctx.addIssue({
                     code: 'custom',
@@ -269,6 +353,69 @@ export const CompositeTriggerDefinitionSchema = z.object({
             });
         }
     }
+    if (value.patternV2) {
+        const patternRefs = collectPatternRefs(value.patternV2.root);
+        for (const ref of patternRefs) {
+            if (!ids.has(ref)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: `Pattern AST v2 references unknown clause: ${ref}`,
+                });
+            }
+        }
+        for (const dimension of value.patternV2.partitionBy) {
+            const dimensionRefs = new Set();
+            for (const field of dimension.fields) {
+                if (!ids.has(field.ref)) {
+                    ctx.addIssue({
+                        code: 'custom',
+                        message: `Pattern partition ${dimension.key} references unknown clause: ${field.ref}`,
+                    });
+                }
+                if (dimensionRefs.has(field.ref)) {
+                    ctx.addIssue({
+                        code: 'custom',
+                        message: `Pattern partition ${dimension.key} has duplicate field mapping for ${field.ref}`,
+                    });
+                }
+                dimensionRefs.add(field.ref);
+            }
+            for (const ref of patternRefs) {
+                if (!dimensionRefs.has(ref)) {
+                    ctx.addIssue({
+                        code: 'custom',
+                        message: `Pattern partition ${dimension.key} does not map pattern ref: ${ref}`,
+                    });
+                }
+            }
+        }
+        const guaranteedPatternRefs = collectGuaranteedPatternBindings(value.patternV2.root);
+        if (typeof value.patternV2.selection.afterMatch === 'object' &&
+            !guaranteedPatternRefs.includes(value.patternV2.selection.afterMatch.ref)) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `Pattern afterMatch ref is not guaranteed by every match: ${value.patternV2.selection.afterMatch.ref}`,
+            });
+        }
+        for (const measure of value.derivedEvent?.measures ?? []) {
+            for (const ref of collectPatternMeasureRefs(measure)) {
+                if (!guaranteedPatternRefs.includes(ref)) {
+                    ctx.addIssue({
+                        code: 'custom',
+                        message: `Derived measure ${measure.key} references non-guaranteed pattern ref: ${ref}`,
+                    });
+                }
+            }
+        }
+        const oversized = collectPatternDurationsMs(value.patternV2.root)
+            .filter((duration) => duration > value.withinMs);
+        if (oversized.length) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `Pattern AST v2 duration exceeds trigger withinMs: ${Math.max(...oversized)} > ${value.withinMs}`,
+            });
+        }
+    }
     const conditionIds = new Set();
     for (const condition of value.temporal) {
         if (conditionIds.has(condition.id)) {
@@ -331,8 +478,10 @@ export const CorrelatableEventSchema = z.object({
     sourceEventId: Id,
     name: z.string().min(1),
     occurredAt: Timestamp,
+    receivedAt: Timestamp.optional(),
     provider: z.string().min(1).optional(),
     serverId: Id.optional(),
+    subscriptionArguments: z.record(z.string(), z.unknown()).default({}),
     payloadHash: z.string().regex(/^[a-f0-9]{64}$/).optional(),
     data: z.record(z.string(), z.unknown()),
 });
@@ -351,8 +500,10 @@ export const TriggerSourceEventSchema = z.object({
     sourceEventId: Id,
     eventName: z.string().min(1),
     occurredAt: Timestamp,
+    receivedAt: Timestamp.optional(),
     provider: z.string().min(1).optional(),
     serverId: Id.optional(),
+    subscriptionArguments: z.record(z.string(), z.unknown()).default({}),
     payloadHash: z.string().regex(/^[a-f0-9]{64}$/).optional(),
     data: z.record(z.string(), z.unknown()),
 });
@@ -373,6 +524,16 @@ export const TriggerMatchStatusSchema = z.enum([
     'fired',
     'expired',
 ]);
+export const PatternMatchStateSchema = z.object({
+    version: z.literal('2'),
+    role: z.enum(['buffer', 'match']),
+    signature: z.string().min(1).optional(),
+    maxObservedOccurredAt: Timestamp.optional(),
+    semanticDecisions: z.array(z.object({
+        nodeId: Id,
+        decision: CompositeCorrelationDecisionSchema,
+    }).strict()).default([]),
+}).strict();
 export const TriggerMatchRecordSchema = z.object({
     protocolVersion: z.literal(COMPOSITE_TRIGGER_PROTOCOL_VERSION),
     schemaVersion: z.literal(COMPOSITE_TRIGGER_SCHEMA_VERSION),
@@ -386,6 +547,7 @@ export const TriggerMatchRecordSchema = z.object({
     updatedAt: Timestamp,
     sourceEvents: z.array(TriggerSourceEventSchema),
     correlationDecision: CompositeCorrelationDecisionSchema.nullable(),
+    patternState: PatternMatchStateSchema.optional(),
     firedWakeId: Id.nullable(),
     derivedEventIds: z.array(Id).default([]),
 });

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

@@ -4,4 +4,6 @@ export declare function mcpOccurrenceToCorrelatableEvent(event: EventOccurrence,
     traceId: string;
     provider?: string;
     serverId?: string;
+    subscriptionArguments?: Record<string, unknown>;
+    receivedAt?: string;
 }): Promise<CorrelatableEvent>;

package/dist/src/mcpEvents/consumer.js

@@ -6,8 +6,10 @@ export async function mcpOccurrenceToCorrelatableEvent(event, input) {
         sourceEventId: event.eventId,
         name: event.name,
         occurredAt: event.timestamp,
+        ...(input.receivedAt ? { receivedAt: input.receivedAt } : {}),
         ...(input.provider ? { provider: input.provider } : {}),
         ...(input.serverId ? { serverId: input.serverId } : {}),
+        subscriptionArguments: input.subscriptionArguments ?? {},
         payloadHash: await sha256Hex(event.data),
         data: event.data,
     });

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

@@ -14,7 +14,5 @@ export type ErpNextEventPoller<TContext = unknown> = (request: ProviderPollReque
 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

@@ -15,9 +15,6 @@ export function createErpNextEventsProvider(options) {
         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: {

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

@@ -1,11 +1,24 @@
 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_EXTENSION_ID: "io.modelcontextprotocol/events";
+export declare const MCP_EVENTS_CAPABILITY_KEY: "io.modelcontextprotocol/events";
 export declare const MCP_EVENTS_CAPABILITY: Readonly<{
-    status: "draft";
-    designDate: "2026-02-19";
-    methods: readonly ["events/list", "events/poll"];
     listChanged: false;
 }>;
+export declare const MCP_EVENTS_ERROR: Readonly<{
+    INVALID_PARAMS: -32602;
+    METHOD_NOT_FOUND: -32601;
+    INTERNAL_ERROR: -32603;
+    NOT_FOUND: -32011;
+    FORBIDDEN: -32012;
+    RESOURCE_EXHAUSTED: -32013;
+    UNSUPPORTED: -32014;
+    CALLBACK_ENDPOINT_ERROR: -32015;
+}>;
+export declare class McpEventsProtocolError extends Error {
+    readonly code: number;
+    readonly data?: unknown;
+    constructor(code: number, message: string, data?: unknown);
+}
 export interface ProviderPollRequest<TContext = unknown> {
     name: string;
     arguments: Record<string, unknown>;
@@ -16,7 +29,7 @@ export interface ProviderPollRequest<TContext = unknown> {
 }
 export interface ProviderPollResult {
     events: EventOccurrence[];
-    cursor: string;
+    cursor: string | null;
     truncated?: boolean;
     hasMore?: boolean;
     nextPollMs?: number;
@@ -27,17 +40,18 @@ export interface McpProviderEvent<TContext = unknown> {
 }
 export interface CreateMcpEventsProviderOptions<TContext = unknown> {
     events: McpProviderEvent<TContext>[];
-    supportedVersions?: string[];
-    instructions?: string;
+    listPageSize?: number;
 }
 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;
+    private readonly listPageSize;
     constructor(options: CreateMcpEventsProviderOptions<TContext>);
     canHandle(method: string): boolean;
-    listEvents(): EventDescriptor[];
+    listEvents(paramsInput?: unknown): {
+        events: EventDescriptor[];
+        nextCursor?: string;
+    };
     handleRequest(request: JsonRpcRequest, context?: TContext): Promise<JsonRpcResponse>;
     private poll;
     private ok;