mcp-event-intelligence 0.5.0 → 0.6.1

package/dist/src/intelligenceProtocol/invariants.js

@@ -1,36 +0,0 @@
-export function assertDecisionLineage(event, decision) {
-    if (decision.traceId !== event.traceId) {
-        throw new Error('Decision traceId does not match source event');
-    }
-    if (decision.subscriptionId !== event.subscriptionId) {
-        throw new Error('Decision subscriptionId does not match source event');
-    }
-    if (decision.sourceEventId !== event.sourceEventId) {
-        throw new Error('Decision sourceEventId does not match source event');
-    }
-}
-export function assertWakeLineage(event, decision, wake) {
-    if (wake.traceId !== event.traceId) {
-        throw new Error('Wake traceId does not match source event');
-    }
-    if (wake.subscriptionId !== event.subscriptionId) {
-        throw new Error('Wake subscriptionId does not match source event');
-    }
-    if (wake.sourceEventId !== event.sourceEventId) {
-        throw new Error('Wake sourceEventId does not match source event');
-    }
-    if (decision) {
-        assertDecisionLineage(event, decision);
-        if (wake.decisionId !== decision.decisionId) {
-            throw new Error('Wake decisionId does not match semantic decision');
-        }
-    }
-    else if (wake.decisionId !== null) {
-        throw new Error('Wake has decisionId but no decision record was supplied');
-    }
-    if (wake.target.runtime !== event.target.runtime ||
-        wake.target.kind !== event.target.kind ||
-        wake.target.id !== event.target.id) {
-        throw new Error('Wake target does not match source event target');
-    }
-}

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

@@ -1,14 +0,0 @@
-import type { EventOccurrence } from '../protocol/types.js';
-import { type EventLineage, type RuntimeTarget } from './schemas.js';
-export interface MapMcpEventInput {
-    event: EventOccurrence;
-    traceId: string;
-    environmentId: string;
-    subscriptionId: string;
-    serverId: string;
-    transport: 'stdio' | 'streamable_http' | 'webhook' | 'poll' | 'internal';
-    provider?: string;
-    target: RuntimeTarget;
-    observedAt: string;
-}
-export declare function mapMcpEventToLineage(input: MapMcpEventInput): Promise<EventLineage>;

package/dist/src/intelligenceProtocol/mapper.js

@@ -1,28 +0,0 @@
-import { sha256Hex } from './canonical.js';
-import { EventLineageSchema, } from './schemas.js';
-import { EVENT_INTELLIGENCE_PROTOCOL, EVENT_INTELLIGENCE_PROTOCOL_VERSION, EVENT_INTELLIGENCE_SCHEMA_VERSION, } from './version.js';
-export async function mapMcpEventToLineage(input) {
-    const payloadHash = await sha256Hex(input.event.data);
-    return EventLineageSchema.parse({
-        protocol: EVENT_INTELLIGENCE_PROTOCOL,
-        protocolVersion: EVENT_INTELLIGENCE_PROTOCOL_VERSION,
-        schemaVersion: EVENT_INTELLIGENCE_SCHEMA_VERSION,
-        traceId: input.traceId,
-        environmentId: input.environmentId,
-        subscriptionId: input.subscriptionId,
-        sourceEventId: input.event.eventId,
-        observedAt: input.observedAt,
-        source: {
-            serverId: input.serverId,
-            transport: input.transport,
-            ...(input.provider ? { provider: input.provider } : {}),
-            cursor: input.event.cursor ?? null,
-        },
-        target: input.target,
-        event: {
-            name: input.event.name,
-            occurredAt: input.event.timestamp,
-            payloadHash,
-        },
-    });
-}

package/dist/src/patternV2/legacyCompiler.d.ts

@@ -1,3 +0,0 @@
-import type { CompositeTriggerDefinition } from '../intelligenceProtocol/triggerSchemas.js';
-import { type PatternAstV2Definition } from '../intelligenceProtocol/patternV2Schemas.js';
-export declare function compileLegacyTriggerToPatternV2(definition: CompositeTriggerDefinition): PatternAstV2Definition;

package/dist/src/patternV2/legacyCompiler.js

@@ -1,184 +0,0 @@
-import { PatternAstV2DefinitionSchema, } from '../intelligenceProtocol/patternV2Schemas.js';
-function eventNode(ref) {
-    return { kind: 'event', ref };
-}
-function expressionNode(definition) {
-    const expression = definition.expression;
-    if (expression.kind === 'allOf') {
-        return {
-            kind: 'allOf',
-            children: expression.refs.map(eventNode),
-        };
-    }
-    if (expression.kind === 'anyOf') {
-        return {
-            kind: 'anyOf',
-            children: expression.refs.map(eventNode),
-        };
-    }
-    if (expression.kind === 'sequence') {
-        return {
-            kind: 'sequence',
-            children: expression.refs.map(eventNode),
-            contiguity: 'followedBy',
-        };
-    }
-    return {
-        kind: 'repeat',
-        child: eventNode(expression.ref),
-        min: expression.atLeast,
-        mode: 'greedy',
-    };
-}
-function wrapTemporal(root, condition) {
-    if (condition.kind === 'calendar') {
-        return {
-            kind: 'calendar',
-            child: root,
-            ref: condition.ref,
-            timezone: condition.timezone,
-            ...(condition.before ? { before: condition.before } : {}),
-            ...(condition.after ? { after: condition.after } : {}),
-            ...(condition.weekdays ? { weekdays: condition.weekdays } : {}),
-            ...(condition.dates ? { dates: condition.dates } : {}),
-            ...(condition.dateRange ? { dateRange: condition.dateRange } : {}),
-            ...(condition.dayOfMonth ? { dayOfMonth: condition.dayOfMonth } : {}),
-        };
-    }
-    if (condition.kind === 'absence') {
-        return {
-            kind: 'absence',
-            id: condition.id,
-            child: root,
-            ref: condition.ref,
-            afterRef: condition.afterRef,
-            ...(condition.forMs ? { forMs: condition.forMs } : {}),
-            ...(condition.untilLocalTime
-                ? { untilLocalTime: condition.untilLocalTime }
-                : {}),
-            ...(condition.timezone ? { timezone: condition.timezone } : {}),
-        };
-    }
-    if (condition.kind === 'not' || condition.kind === 'unless') {
-        return {
-            kind: 'notPresent',
-            child: root,
-            ref: condition.ref,
-        };
-    }
-    if (condition.kind === 'after') {
-        return {
-            kind: 'after',
-            child: root,
-            ref: condition.ref,
-            afterRef: condition.afterRef,
-        };
-    }
-    if (condition.kind === 'until') {
-        return {
-            kind: 'until',
-            child: root,
-            ref: condition.ref,
-            beforeRef: condition.beforeRef,
-        };
-    }
-    if (condition.kind === 'debounce') {
-        return {
-            kind: 'debounce',
-            id: condition.id,
-            child: root,
-            ref: condition.ref,
-            forMs: condition.forMs,
-        };
-    }
-    if (condition.kind === 'threshold') {
-        return {
-            kind: 'threshold',
-            child: root,
-            ref: condition.ref,
-            atLeast: condition.atLeast,
-        };
-    }
-    if (condition.kind === 'rate') {
-        return {
-            kind: 'rate',
-            child: root,
-            ref: condition.ref,
-            atLeast: condition.atLeast,
-            perMs: condition.perMs,
-        };
-    }
-    return {
-        kind: 'distinct',
-        child: root,
-        ref: condition.ref,
-        path: condition.path,
-        atLeast: condition.atLeast,
-    };
-}
-export function compileLegacyTriggerToPatternV2(definition) {
-    let root = expressionNode(definition);
-    const deterministic = definition.correlation?.deterministic;
-    if (deterministic?.fields?.length) {
-        const [anchorField, ...otherFields] = deterministic.fields;
-        if (!anchorField) {
-            throw new Error('Deterministic correlation requires at least one field');
-        }
-        for (const field of otherFields) {
-            root = {
-                kind: 'compare',
-                child: root,
-                left: {
-                    kind: 'field',
-                    ref: anchorField.ref,
-                    path: anchorField.path,
-                    select: 'last',
-                },
-                op: 'eq',
-                right: {
-                    kind: 'field',
-                    ref: field.ref,
-                    path: field.path,
-                    select: 'last',
-                },
-            };
-        }
-    }
-    for (const condition of definition.temporal ?? []) {
-        root = wrapTemporal(root, condition);
-    }
-    if (definition.correlation?.semantic) {
-        const semantic = definition.correlation.semantic;
-        root = {
-            kind: 'semantic',
-            id: 'legacy-semantic-correlation',
-            child: root,
-            refs: [...new Set(semantic.input
-                    .map((path) => path.split('.')[0])
-                    .filter(Boolean))],
-            instruction: semantic.instruction,
-            input: semantic.input,
-            matchThreshold: semantic.matchThreshold,
-            rejectThreshold: semantic.rejectThreshold,
-            uncertain: semantic.uncertain,
-            execution: {
-                cache: true,
-                timeoutMs: 5000,
-            },
-        };
-    }
-    return PatternAstV2DefinitionSchema.parse({
-        version: '2',
-        root,
-        partitionBy: [],
-        selection: {
-            overlap: 'disallow',
-            afterMatch: 'skipPastLast',
-            maxMatchesPerEvent: 10,
-        },
-        execution: {
-            maxCandidates: 512,
-            maxSemanticEvaluations: 16,
-        },
-    });
-}