mcp-event-intelligence 0.5.0 → 0.6.0

package/dist/src/intelligenceProtocol/lifecycle.js

@@ -1,14 +1,6 @@
 const ALLOWED = {
-    received: new Set(['duplicate', 'evaluating', 'matched', 'failed']),
-    duplicate: new Set(),
-    evaluating: new Set(['matched', 'rejected', 'escalated', 'failed']),
-    matched: new Set(['wake_queued', 'failed']),
-    rejected: new Set(),
-    escalated: new Set(['wake_queued', 'rejected', 'failed']),
-    wake_queued: new Set(['wake_delivered', 'dead_letter', 'failed']),
-    wake_delivered: new Set(['handled', 'dead_letter', 'failed']),
-    handled: new Set(),
-    failed: new Set(['dead_letter']),
+    wake_queued: new Set(['wake_delivered', 'dead_letter']),
+    wake_delivered: new Set(),
     dead_letter: new Set(),
 };
 export function canTransition(from, to) {

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

@@ -1,4 +1,4 @@
-export declare const TRIGGER_LANGUAGE_VERSION: "2";
+export declare const TRIGGER_LANGUAGE_VERSION: "3";
 export declare const PREDICATE_OPERATOR: {
     readonly EQ: "eq";
     readonly NEQ: "neq";
@@ -17,26 +17,8 @@ export declare const PREDICATE_OPERATOR: {
     readonly LT: "lt";
     readonly LTE: "lte";
 };
-export declare const COMPOSITION_OPERATOR: {
-    readonly ALL: "all";
-    readonly ANY: "any";
-    readonly SEQUENCE: "sequence";
-    readonly COUNT: "count";
-};
-export declare const TEMPORAL_OPERATOR: {
-    readonly CALENDAR: "calendar";
-    readonly ABSENCE: "absence";
-    readonly NOT: "not";
-    readonly UNLESS: "unless";
-    readonly AFTER: "after";
-    readonly UNTIL: "until";
-    readonly DEBOUNCE: "debounce";
-    readonly THRESHOLD: "threshold";
-    readonly RATE: "rate";
-    readonly DISTINCT: "distinct";
-};
 export declare const TRIGGER_LANGUAGE_CATALOG: Readonly<{
-    version: "2";
+    version: "3";
     predicates: readonly ({
         id: "eq";
         description: string;
@@ -214,250 +196,6 @@ export declare const TRIGGER_LANGUAGE_CATALOG: Readonly<{
         optionalFields?: undefined;
         values?: undefined;
     })[];
-    composition: readonly ({
-        id: "all";
-        canonicalKind: string;
-        description: string;
-        example: {
-            match: string;
-        };
-    } | {
-        id: "any";
-        canonicalKind: string;
-        description: string;
-        example: {
-            match: string;
-        };
-    } | {
-        id: "sequence";
-        canonicalKind: string;
-        description: string;
-        example: {
-            match: string;
-        };
-    } | {
-        id: "count";
-        canonicalKind: string;
-        description: string;
-        example: {
-            match: {
-                kind: string;
-                eventId: string;
-                atLeast: number;
-            };
-        };
-    })[];
-    temporal: readonly ({
-        id: "calendar";
-        description: string;
-        fields: string[];
-        optionalFields: string[];
-        example: {
-            id: string;
-            kind: string;
-            ref: string;
-            timezone: string;
-            after: string;
-            before: string;
-            weekdays: number[];
-            afterRef?: undefined;
-            forMs?: undefined;
-            beforeRef?: undefined;
-            atLeast?: undefined;
-            perMs?: undefined;
-            path?: undefined;
-        };
-        oneOf?: undefined;
-    } | {
-        id: "absence";
-        description: string;
-        fields: string[];
-        oneOf: string[][];
-        example: {
-            id: string;
-            kind: string;
-            ref: string;
-            afterRef: string;
-            forMs: number;
-            timezone?: undefined;
-            after?: undefined;
-            before?: undefined;
-            weekdays?: undefined;
-            beforeRef?: undefined;
-            atLeast?: undefined;
-            perMs?: undefined;
-            path?: undefined;
-        };
-        optionalFields?: undefined;
-    } | {
-        id: "not";
-        description: string;
-        fields: string[];
-        example: {
-            id: string;
-            kind: string;
-            ref: string;
-            timezone?: undefined;
-            after?: undefined;
-            before?: undefined;
-            weekdays?: undefined;
-            afterRef?: undefined;
-            forMs?: undefined;
-            beforeRef?: undefined;
-            atLeast?: undefined;
-            perMs?: undefined;
-            path?: undefined;
-        };
-        optionalFields?: undefined;
-        oneOf?: undefined;
-    } | {
-        id: "unless";
-        description: string;
-        fields: string[];
-        example: {
-            id: string;
-            kind: string;
-            ref: string;
-            timezone?: undefined;
-            after?: undefined;
-            before?: undefined;
-            weekdays?: undefined;
-            afterRef?: undefined;
-            forMs?: undefined;
-            beforeRef?: undefined;
-            atLeast?: undefined;
-            perMs?: undefined;
-            path?: undefined;
-        };
-        optionalFields?: undefined;
-        oneOf?: undefined;
-    } | {
-        id: "after";
-        description: string;
-        fields: string[];
-        example: {
-            id: string;
-            kind: string;
-            ref: string;
-            afterRef: string;
-            timezone?: undefined;
-            after?: undefined;
-            before?: undefined;
-            weekdays?: undefined;
-            forMs?: undefined;
-            beforeRef?: undefined;
-            atLeast?: undefined;
-            perMs?: undefined;
-            path?: undefined;
-        };
-        optionalFields?: undefined;
-        oneOf?: undefined;
-    } | {
-        id: "until";
-        description: string;
-        fields: string[];
-        example: {
-            id: string;
-            kind: string;
-            ref: string;
-            beforeRef: string;
-            timezone?: undefined;
-            after?: undefined;
-            before?: undefined;
-            weekdays?: undefined;
-            afterRef?: undefined;
-            forMs?: undefined;
-            atLeast?: undefined;
-            perMs?: undefined;
-            path?: undefined;
-        };
-        optionalFields?: undefined;
-        oneOf?: undefined;
-    } | {
-        id: "debounce";
-        description: string;
-        fields: string[];
-        example: {
-            id: string;
-            kind: string;
-            ref: string;
-            forMs: number;
-            timezone?: undefined;
-            after?: undefined;
-            before?: undefined;
-            weekdays?: undefined;
-            afterRef?: undefined;
-            beforeRef?: undefined;
-            atLeast?: undefined;
-            perMs?: undefined;
-            path?: undefined;
-        };
-        optionalFields?: undefined;
-        oneOf?: undefined;
-    } | {
-        id: "threshold";
-        description: string;
-        fields: string[];
-        example: {
-            id: string;
-            kind: string;
-            ref: string;
-            atLeast: number;
-            timezone?: undefined;
-            after?: undefined;
-            before?: undefined;
-            weekdays?: undefined;
-            afterRef?: undefined;
-            forMs?: undefined;
-            beforeRef?: undefined;
-            perMs?: undefined;
-            path?: undefined;
-        };
-        optionalFields?: undefined;
-        oneOf?: undefined;
-    } | {
-        id: "rate";
-        description: string;
-        fields: string[];
-        example: {
-            id: string;
-            kind: string;
-            ref: string;
-            atLeast: number;
-            perMs: number;
-            timezone?: undefined;
-            after?: undefined;
-            before?: undefined;
-            weekdays?: undefined;
-            afterRef?: undefined;
-            forMs?: undefined;
-            beforeRef?: undefined;
-            path?: undefined;
-        };
-        optionalFields?: undefined;
-        oneOf?: undefined;
-    } | {
-        id: "distinct";
-        description: string;
-        fields: string[];
-        example: {
-            id: string;
-            kind: string;
-            ref: string;
-            path: string;
-            atLeast: number;
-            timezone?: undefined;
-            after?: undefined;
-            before?: undefined;
-            weekdays?: undefined;
-            afterRef?: undefined;
-            forMs?: undefined;
-            beforeRef?: undefined;
-            perMs?: undefined;
-        };
-        optionalFields?: undefined;
-        oneOf?: undefined;
-    })[];
     pattern: readonly ({
         id: string;
         description: string;
@@ -537,11 +275,6 @@ export declare const TRIGGER_LANGUAGE_CATALOG: Readonly<{
         fields: string[];
         optionalFields: string[];
     }[];
-    correlation: readonly {
-        id: string;
-        description: string;
-        authoringField: string;
-    }[];
     execution: readonly {
         id: string;
         description: string;
@@ -560,7 +293,7 @@ export declare const TRIGGER_LANGUAGE_CATALOG: Readonly<{
         description: string;
     }[];
 }>;
-export type TriggerLanguageCategory = 'predicates' | 'composition' | 'temporal' | 'pattern' | 'windows' | 'aggregates' | 'state' | 'selection' | 'semantic' | 'execution' | 'correlation' | 'timing' | 'lifecycle';
+export type TriggerLanguageCategory = 'predicates' | 'pattern' | 'windows' | 'aggregates' | 'state' | 'selection' | 'semantic' | 'execution' | 'timing' | 'lifecycle';
 export declare function describeTriggerLanguage(input?: {
     category?: TriggerLanguageCategory;
     operator?: string;

package/dist/src/intelligenceProtocol/operatorRegistry.js

@@ -1,4 +1,4 @@
-export const TRIGGER_LANGUAGE_VERSION = '2';
+export const TRIGGER_LANGUAGE_VERSION = '3';
 export const PREDICATE_OPERATOR = {
     EQ: 'eq',
     NEQ: 'neq',
@@ -17,24 +17,6 @@ export const PREDICATE_OPERATOR = {
     LT: 'lt',
     LTE: 'lte',
 };
-export const COMPOSITION_OPERATOR = {
-    ALL: 'all',
-    ANY: 'any',
-    SEQUENCE: 'sequence',
-    COUNT: 'count',
-};
-export const TEMPORAL_OPERATOR = {
-    CALENDAR: 'calendar',
-    ABSENCE: 'absence',
-    NOT: 'not',
-    UNLESS: 'unless',
-    AFTER: 'after',
-    UNTIL: 'until',
-    DEBOUNCE: 'debounce',
-    THRESHOLD: 'threshold',
-    RATE: 'rate',
-    DISTINCT: 'distinct',
-};
 export const TRIGGER_LANGUAGE_CATALOG = Object.freeze({
     version: TRIGGER_LANGUAGE_VERSION,
     predicates: Object.freeze([
@@ -137,110 +119,6 @@ export const TRIGGER_LANGUAGE_CATALOG = Object.freeze({
             example: { path: 'stock', op: 'lte', value: 10 },
         },
     ]),
-    composition: Object.freeze([
-        {
-            id: COMPOSITION_OPERATOR.ALL,
-            canonicalKind: 'allOf',
-            description: 'All referenced events must satisfy the legacy trigger.',
-            example: { match: 'all' },
-        },
-        {
-            id: COMPOSITION_OPERATOR.ANY,
-            canonicalKind: 'anyOf',
-            description: 'Any referenced event may satisfy the legacy trigger.',
-            example: { match: 'any' },
-        },
-        {
-            id: COMPOSITION_OPERATOR.SEQUENCE,
-            canonicalKind: 'sequence',
-            description: 'Referenced events must occur in event-time order.',
-            example: { match: 'sequence' },
-        },
-        {
-            id: COMPOSITION_OPERATOR.COUNT,
-            canonicalKind: 'count',
-            description: 'One referenced event must occur at least N times.',
-            example: { match: { kind: 'count', eventId: 'comment', atLeast: 3 } },
-        },
-    ]),
-    temporal: Object.freeze([
-        {
-            id: TEMPORAL_OPERATOR.CALENDAR,
-            description: 'Calendar/timezone constraint.',
-            fields: ['id', 'kind', 'ref', 'timezone'],
-            optionalFields: ['before', 'after', 'weekdays', 'dates', 'dateRange', 'dayOfMonth'],
-            example: {
-                id: 'business-hours',
-                kind: 'calendar',
-                ref: 'order',
-                timezone: 'Europe/Rome',
-                after: '09:00',
-                before: '18:00',
-                weekdays: [1, 2, 3, 4, 5],
-            },
-        },
-        {
-            id: TEMPORAL_OPERATOR.ABSENCE,
-            description: 'Referenced event must remain absent after an anchor for a durable period.',
-            fields: ['id', 'kind', 'ref', 'afterRef'],
-            oneOf: [['forMs'], ['untilLocalTime', 'timezone']],
-            example: {
-                id: 'no-errors',
-                kind: 'absence',
-                ref: 'error',
-                afterRef: 'deploy',
-                forMs: 600000,
-            },
-        },
-        {
-            id: TEMPORAL_OPERATOR.NOT,
-            description: 'Referenced event must not be present.',
-            fields: ['id', 'kind', 'ref'],
-            example: { id: 'not-cancelled', kind: 'not', ref: 'cancelled' },
-        },
-        {
-            id: TEMPORAL_OPERATOR.UNLESS,
-            description: 'Condition remains valid unless the referenced event occurs.',
-            fields: ['id', 'kind', 'ref'],
-            example: { id: 'unless-blocked', kind: 'unless', ref: 'blocked' },
-        },
-        {
-            id: TEMPORAL_OPERATOR.AFTER,
-            description: 'ref must occur after afterRef.',
-            fields: ['id', 'kind', 'ref', 'afterRef'],
-            example: { id: 'deploy-after-merge', kind: 'after', ref: 'deploy', afterRef: 'merge' },
-        },
-        {
-            id: TEMPORAL_OPERATOR.UNTIL,
-            description: 'ref must occur no later than beforeRef.',
-            fields: ['id', 'kind', 'ref', 'beforeRef'],
-            example: { id: 'approve-before-expiry', kind: 'until', ref: 'approval', beforeRef: 'expiry' },
-        },
-        {
-            id: TEMPORAL_OPERATOR.DEBOUNCE,
-            description: 'Wait for a quiet period after the latest referenced event.',
-            fields: ['id', 'kind', 'ref', 'forMs'],
-            example: { id: 'quiet', kind: 'debounce', ref: 'change', forMs: 300000 },
-        },
-        {
-            id: TEMPORAL_OPERATOR.THRESHOLD,
-            description: 'At least N occurrences are required.',
-            fields: ['id', 'kind', 'ref', 'atLeast'],
-            example: { id: 'three-comments', kind: 'threshold', ref: 'comment', atLeast: 3 },
-        },
-        {
-            id: TEMPORAL_OPERATOR.RATE,
-            description: 'At least N occurrences are required within a duration.',
-            fields: ['id', 'kind', 'ref', 'atLeast', 'perMs'],
-            example: { id: 'order-spike', kind: 'rate', ref: 'order', atLeast: 5, perMs: 600000 },
-        },
-        {
-            id: TEMPORAL_OPERATOR.DISTINCT,
-            description: 'At least N distinct values are required.',
-            fields: ['id', 'kind', 'ref', 'path', 'atLeast'],
-            example: { id: 'three-customers', kind: 'distinct', ref: 'order', path: 'customer', atLeast: 3 },
-        },
-    ]),
     pattern: Object.freeze([
         {
             id: 'event',
@@ -304,11 +182,11 @@ export const TRIGGER_LANGUAGE_CATALOG = Object.freeze({
         },
         {
             id: 'calendar',
-            description: 'Calendar/timezone filter as a v2 wrapper node.',
+            description: 'Calendar/timezone filter as a Pattern AST wrapper node.',
         },
         {
             id: 'absence',
-            description: 'Durable absence condition as a v2 wrapper node.',
+            description: 'Durable absence condition as a Pattern AST wrapper node.',
         },
         {
             id: 'notPresent',
@@ -402,23 +280,6 @@ export const TRIGGER_LANGUAGE_CATALOG = Object.freeze({
             optionalFields: ['uncertain', 'execution.cache', 'execution.timeoutMs', 'execution.onUnavailable'],
         },
     ]),
-    correlation: Object.freeze([
-        {
-            id: 'same_value',
-            description: 'Legacy deterministic same-value correlation.',
-            authoringField: 'correlateBy',
-        },
-        {
-            id: 'semantic',
-            description: 'Legacy semantic-correlation compatibility field.',
-            authoringField: 'semanticCorrelation',
-        },
-        {
-            id: 'partitionBy',
-            description: 'Pattern AST v2 partitions stream state by one or more named dimensions.',
-            authoringField: 'patternV2.partitionBy',
-        },
-    ]),
     execution: Object.freeze([
         {
             id: 'maxCandidates',
@@ -463,8 +324,8 @@ export function describeTriggerLanguage(input = {}) {
         version: TRIGGER_LANGUAGE_VERSION,
         authoringSurface: 'TriggerPlanInput',
         planner: 'trigger_plan',
-        preferredAuthoring: 'TriggerPlanInput.patternV2',
-        canonicalRepresentation: 'CompositeTriggerDefinition + PatternAstV2',
+        preferredAuthoring: 'TriggerPlanInput.pattern',
+        canonicalRepresentation: 'CompositeTriggerDefinition.pattern',
     };
     for (const key of categories) {
         const entries = TRIGGER_LANGUAGE_CATALOG[key];