mcp-event-intelligence 0.4.0 → 0.6.0

package/scripts/mcp-stdio-server.mjs

@@ -2,6 +2,8 @@ import { McpServer } from '@modelcontextprotocol/server';
 import { serveStdio } from '@modelcontextprotocol/server/stdio';
 import * as z from 'zod/v4';
 import {
+  TriggerPlanInputSchema,
+  describeTriggerLanguage,
   parseCompositeTriggerDefinition,
 } from '../dist/src/intelligenceProtocol/index.js';
 import {
@@ -57,59 +59,26 @@ function ownerFromEnv(env) {
   };
 }
 
-const predicateInputSchema = z.object({
-  path: z.string().min(1),
-  op: z.enum(['eq', 'neq', 'contains', 'in', 'exists', 'gt', 'gte', 'lt', 'lte']),
-  value: z.unknown().optional(),
-});
+const triggerPlanInputSchema = TriggerPlanInputSchema;
 
-const triggerPlanInputSchema = z.object({
-  triggerId: z.string().min(1).optional(),
-  version: z.string().min(1).optional(),
-  description: z.string().max(500).optional(),
-  events: z.array(z.object({
-    id: z.string().min(1).optional(),
-    event: z.string().min(1),
-    serverId: z.string().min(1).optional(),
-    arguments: z.record(z.string(), z.unknown()).optional(),
-    where: z.array(predicateInputSchema).optional(),
-  })).min(1),
-  match: z.union([
-    z.enum(['all', 'any', 'sequence']),
-    z.object({
-      kind: z.literal('count'),
-      eventId: z.string().min(1),
-      atLeast: z.number().int().min(1),
-    }),
+const triggerLanguageDescribeInputSchema = z.object({
+  category: z.enum([
+    'predicates',
+    'composition',
+    'temporal',
+    'pattern',
+    'windows',
+    'aggregates',
+    'state',
+    'selection',
+    'semantic',
+    'execution',
+    'correlation',
+    'timing',
+    'lifecycle',
   ]).optional(),
-  withinMs: z.number().int().positive().optional(),
-  lifecycle: z.object({
-    oneShot: z.boolean().optional(),
-    maxFirings: z.number().int().min(1).optional(),
-    cooldownMs: z.number().int().nonnegative().optional(),
-    expiresAt: z.string().optional(),
-    leaseUntil: z.string().optional(),
-    completeOnGoal: z.boolean().optional(),
-  }).optional(),
-  target: z.object({
-    runtime: z.string().min(1),
-    kind: z.enum(['goal', 'session', 'conversation', 'task', 'spawn_template']),
-    id: z.string().min(1),
-  }),
-  continuation: z.object({
-    instruction: z.string().min(1).max(4000),
-    contextPolicy: z.object({
-      evidence: z.enum(['matched_events', 'refs_only']).optional(),
-      maxEvents: z.number().int().min(1).max(50).optional(),
-      includeData: z.boolean().optional(),
-    }).optional(),
-  }),
-  correlateBy: z.array(z.object({
-    eventId: z.string().min(1),
-    path: z.string().min(1),
-  })).min(2).optional(),
-  semanticCorrelation: z.record(z.string(), z.unknown()).optional(),
-});
+  operator: z.string().min(1).optional(),
+}).strict();
 
 function registerReadTools(server, runtime) {
   server.registerTool(
@@ -124,7 +93,7 @@ function registerReadTools(server, runtime) {
     async ({ connectionIds }) => {
       try {
         return jsonResult({
-          sources: runtime.triggerControl.listEventSources({
+          sources: await runtime.triggerControl.listEventSources({
             ...(connectionIds ? { connectionIds } : {}),
           }),
         });
@@ -134,6 +103,22 @@ function registerReadTools(server, runtime) {
     },
   );
 
+  server.registerTool(
+    'trigger_language_describe',
+    {
+      description:
+        'Describe the public Event Intelligence trigger authoring language. Use this when you need to discover supported predicates, composition, temporal, correlation, timing, or lifecycle operators before planning a trigger.',
+      inputSchema: triggerLanguageDescribeInputSchema,
+    },
+    async (input) => {
+      try {
+        return jsonResult(describeTriggerLanguage(input));
+      } catch (error) {
+        return errorResult(error);
+      }
+    },
+  );
+
   server.registerTool(
     'trigger_plan',
     {
@@ -162,7 +147,7 @@ function registerReadTools(server, runtime) {
     async ({ ownerOnly }) => {
       try {
         return jsonResult({
-          triggers: runtime.triggerControl.listTriggers(
+          triggers: await runtime.triggerControl.listTriggers(
             ownerOnly ? { owner: ownerFromEnv(process.env) } : {},
           ),
         });
@@ -225,7 +210,7 @@ function registerReadTools(server, runtime) {
     async ({ eventName }) => {
       try {
         return jsonResult({
-          contracts: runtime.store.listDerivedContracts(eventName),
+          contracts: await runtime.store.listDerivedContracts(eventName),
         });
       } catch (error) {
         return errorResult(error);
@@ -244,7 +229,7 @@ function registerReadTools(server, runtime) {
     },
     async ({ wakeId }) => {
       try {
-        return jsonResult(runtime.activationHydrator.hydrateWake(wakeId));
+        return jsonResult(await runtime.activationHydrator.hydrateWake(wakeId));
       } catch (error) {
         return errorResult(error);
       }
@@ -262,11 +247,11 @@ function registerReadTools(server, runtime) {
       try {
         return jsonResult({
           restored: runtime.restored,
-          hostMcpEventConnections: runtime.mcpEventsClient.status(),
+          hostMcpEventConnections: await runtime.mcpEventsClient.status(),
           pendingTemporalDeadlines:
-            runtime.store.listTemporalDeadlines({ status: 'pending' }).length,
-          derivedEvents: runtime.store.listDerivedEvents().length,
-          derivedContracts: runtime.store.listDerivedContracts().length,
+            (await runtime.store.listTemporalDeadlines({ status: 'pending' })).length,
+          derivedEvents: (await runtime.store.listDerivedEvents()).length,
+          derivedContracts: (await runtime.store.listDerivedContracts()).length,
           writeEnabled: process.env.MCP_WRITE_ENABLED === 'true',
         });
       } catch (error) {
@@ -452,11 +437,11 @@ export async function buildEventIntelligenceMcpServer({
   const server = new McpServer(
     {
       name: 'mcp-event-intelligence',
-      version: '0.3.1',
+      version: '0.5.0',
     },
     {
       instructions:
-        'Use Event Intelligence to discover event sources, inspect/simulate durable trigger programs, and govern continuations. The agent authors structured trigger definitions using the discovered source schemas. Persistent mutations are unavailable unless the operator enables MCP_WRITE_ENABLED=true, and each mutation requires confirmationId.',
+        'Use Event Intelligence to discover event sources and the trigger authoring language, plan/inspect/simulate durable trigger programs, and govern continuations. Prefer event_sources_list plus trigger_language_describe when needed, then author through trigger_plan instead of raw canonical definitions. Persistent mutations are unavailable unless the operator enables MCP_WRITE_ENABLED=true, and each mutation requires confirmationId.',
     },
   );
 

package/scripts/service.mjs

@@ -13,13 +13,10 @@ import {
 import {
   ExperimentalMcpEventsServer,
 } from '../dist/src/mcpEvents/server.js';
-import { EventProcessor } from './lib/event-processor.mjs';
 import {
-  githubEventPassesStructuredFilter,
   translateGitHubWebhook,
   verifyGitHubWebhookSignature,
 } from './lib/github-webhook.mjs';
-import { createHttpWakeDeliverer } from './lib/http-wake-deliverer.mjs';
 import {
   CompositeWakeCoordinator,
 } from './lib/composite-wake-coordinator.mjs';
@@ -65,10 +62,6 @@ const evaluator = process.env.TYPESAFE_API_KEY
   ? TypeSafeJevEvaluator.fromEnvironment(process.env)
   : null;
 
-const wakeDeliverer = createHttpWakeDeliverer(
-  process.env.RUNTIME_WAKE_URL ?? '',
-);
-
 const deliveryOptions = {
   leaseMs: Number(process.env.WAKE_DELIVERY_LEASE_MS ?? 30000),
   maxAttempts: Number(process.env.WAKE_DELIVERY_MAX_ATTEMPTS ?? 5),
@@ -76,12 +69,6 @@ const deliveryOptions = {
   retryMaxDelayMs: Number(process.env.WAKE_RETRY_MAX_DELAY_MS ?? 60000),
 };
 
-const processor = new EventProcessor({
-  store,
-  evaluator,
-  wakeDeliverer,
-  ...deliveryOptions,
-});
 const compositeTriggers = new CompositeTriggerEngine(store, evaluator);
 const runtimeWakeTargets = readRuntimeWakeTargets(
   process.env.RUNTIME_WAKE_TARGETS_JSON,
@@ -104,7 +91,6 @@ const compositeEventConsumer = new CompositeEventConsumer({
   triggerEngine: compositeTriggers,
   wakeCoordinators,
   derivedEventCoordinator,
-  processor,
   maxDerivedDepth: Number(process.env.MAX_DERIVED_EVENT_DEPTH ?? 16),
 });
 const temporalScheduler = new TemporalDeadlineScheduler({
@@ -116,7 +102,6 @@ temporalScheduler.start();
 
 const wakeRetryScheduler = new WakeRetryScheduler({
   store,
-  eventProcessor: processor,
   resolveCoordinator: (runtime) => wakeCoordinators.get(runtime) ?? null,
   intervalMs: Number(process.env.WAKE_RETRY_TICK_MS ?? 1000),
 });
@@ -167,59 +152,6 @@ function requireBearer(request, response) {
   return true;
 }
 
-function githubSemanticCondition() {
-  const instruction = process.env.SEMANTIC_INSTRUCTION;
-  if (!instruction) return undefined;
-
-  return {
-    type: 'semantic_boolean',
-    instruction,
-    input: ['data.title', 'data.bodyPreview', 'data.labels'],
-    matchThreshold: Number(process.env.SEMANTIC_MATCH_THRESHOLD ?? 0.8),
-    rejectThreshold: Number(process.env.SEMANTIC_REJECT_THRESHOLD ?? 0.2),
-    uncertain: process.env.SEMANTIC_UNCERTAIN_POLICY ?? 'escalate',
-  };
-}
-
-function logProcessingResult(result) {
-  console.log(
-    JSON.stringify({
-      message: 'event_intelligence_result',
-      traceId: result.traceId,
-      sourceEventId: result.sourceEventId,
-      status: result.status,
-      decisionId: result.decision?.decisionId ?? null,
-      outcome: result.decision?.outcome ?? null,
-      probability: result.decision?.probability ?? null,
-      evaluator: result.decision?.evaluator ?? null,
-      providerEvidence: result.decision?.providerEvidence ?? null,
-      wakeId: result.wake?.wakeId ?? null,
-      wakeStatus: result.wake?.status ?? null,
-    }),
-  );
-}
-
-function githubContext() {
-  const targetId = process.env.RUNTIME_TARGET_ID;
-  if (!targetId) {
-    throw new Error('RUNTIME_TARGET_ID is required for GitHub webhook delivery');
-  }
-
-  return {
-    environmentId,
-    subscriptionId:
-      process.env.GITHUB_SUBSCRIPTION_ID ?? 'github-issues-default',
-    serverId: process.env.GITHUB_SERVER_ID ?? 'github-webhook-adapter',
-    transport: 'webhook',
-    provider: 'github',
-    target: {
-      runtime: process.env.RUNTIME_TARGET_RUNTIME ?? 'agent-runtime',
-      kind: process.env.RUNTIME_TARGET_KIND ?? 'session',
-      id: targetId,
-    },
-  };
-}
-
 const server = createServer(async (request, response) => {
   try {
     const url = new URL(
@@ -237,28 +169,20 @@ const server = createServer(async (request, response) => {
 
     if (request.method === 'GET' && url.pathname === '/readyz') {
       const auditValid = await store.verifyAudit();
-      const semanticRequired = Boolean(process.env.SEMANTIC_INSTRUCTION);
       const evaluatorConfigured = Boolean(evaluator);
-      const ready =
-        auditValid &&
-        (!semanticRequired || evaluatorConfigured);
+      const ready = auditValid;
 
       return sendJson(response, ready ? 200 : 503, {
-        status: ready
-          ? 'ready'
-          : !auditValid
-            ? 'audit_invalid'
-            : 'semantic_evaluator_unavailable',
+        status: ready ? 'ready' : 'audit_invalid',
         auditValid,
-        semanticRequired,
         evaluatorConfigured,
-        wakeCallbackConfigured: Boolean(wakeDeliverer),
+        wakeCallbackConfigured: runtimeWakeTargets.size > 0,
         genericRuntimeWakeTargets: [...runtimeWakeTargets.keys()],
-        eventSources: store.listEventSources().length,
+        eventSources: (await store.listEventSources()).length,
         pendingTemporalDeadlines:
-          store.listTemporalDeadlines({ status: 'pending' }).length,
-        derivedEvents: store.listDerivedEvents().length,
-        derivedContracts: store.listDerivedContracts().length,
+          (await store.listTemporalDeadlines({ status: 'pending' })).length,
+        derivedEvents: (await store.listDerivedEvents()).length,
+        derivedContracts: (await store.listDerivedContracts()).length,
       });
     }
 
@@ -338,27 +262,11 @@ const server = createServer(async (request, response) => {
         }));
       }
 
-      if (
-        !githubEventPassesStructuredFilter(translated.event, {
-          repository: process.env.GITHUB_REPOSITORY,
-          label: process.env.GITHUB_LABEL,
-        })
-      ) {
-        return sendJson(response, 202, {
-          status: 'filtered_structured',
-        });
-      }
-
-      const result = await processor.ingest({
-        event: translated.event,
-        context: githubContext(),
-        semanticCondition: githubSemanticCondition(),
-        wakeOnEscalation:
-          process.env.WAKE_ON_ESCALATION === 'true',
+      return sendJson(response, 202, {
+        status: mcpReceipt.accepted ? 'accepted' : 'duplicate',
+        mcpReceipt,
+        composite,
       });
-
-      logProcessingResult(result);
-      return sendJson(response, 202, result);
     }
 
     if (request.method === 'POST' && url.pathname === '/mcp') {
@@ -422,7 +330,7 @@ const server = createServer(async (request, response) => {
       url.pathname === '/v1/derived-contracts'
     ) {
       return sendJson(response, 200, {
-        contracts: store.listDerivedContracts(
+        contracts: await store.listDerivedContracts(
           url.searchParams.get('eventName') ?? undefined,
         ),
       });
@@ -433,7 +341,7 @@ const server = createServer(async (request, response) => {
       url.pathname === '/v1/derived-events'
     ) {
       return sendJson(response, 200, {
-        events: store.listDerivedEvents({
+        events: await store.listDerivedEvents({
           ...(url.searchParams.get('triggerId')
             ? { triggerId: url.searchParams.get('triggerId') }
             : {}),
@@ -454,7 +362,7 @@ const server = createServer(async (request, response) => {
       const triggerId = decodeURIComponent(
         url.pathname.slice('/v1/inspector/triggers/'.length),
       );
-      return sendJson(response, 200, triggerInspector.inspect({
+      return sendJson(response, 200, await triggerInspector.inspect({
         triggerId,
         version: url.searchParams.get('version') ?? undefined,
         matchId: url.searchParams.get('matchId') ?? undefined,
@@ -481,7 +389,7 @@ const server = createServer(async (request, response) => {
       url.pathname === '/v1/temporal/deadlines'
     ) {
       return sendJson(response, 200, {
-        deadlines: store.listTemporalDeadlines({
+        deadlines: await store.listTemporalDeadlines({
           ...(url.searchParams.get('triggerId')
             ? { triggerId: url.searchParams.get('triggerId') }
             : {}),
@@ -507,7 +415,7 @@ const server = createServer(async (request, response) => {
     if (request.method === 'GET' && url.pathname === '/v1/event-sources') {
       const connectionIds = url.searchParams.getAll('connectionId');
       return sendJson(response, 200, {
-        eventSources: triggerControl.listEventSources({
+        eventSources: await triggerControl.listEventSources({
           ...(connectionIds.length ? { connectionIds } : {}),
         }),
       });
@@ -528,7 +436,7 @@ const server = createServer(async (request, response) => {
       const ownerId = url.searchParams.get('ownerId');
       const tenantId = url.searchParams.get('tenantId');
       return sendJson(response, 200, {
-        triggers: triggerControl.listTriggers({
+        triggers: await triggerControl.listTriggers({
           ...(ownerType && ownerId
             ? {
               owner: {
@@ -633,14 +541,14 @@ const server = createServer(async (request, response) => {
 
     if (request.method === 'GET' && url.pathname === '/v1/triggers') {
       return sendJson(response, 200, {
-        triggers: store.listTriggers(),
+        triggers: await store.listTriggers(),
       });
     }
 
     if (request.method === 'GET' && url.pathname === '/v1/trigger-matches') {
       const triggerId = url.searchParams.get('triggerId') ?? undefined;
       return sendJson(response, 200, {
-        matches: store.listTriggerMatches(triggerId),
+        matches: await store.listTriggerMatches(triggerId),
       });
     }
 
@@ -704,13 +612,6 @@ const server = createServer(async (request, response) => {
       });
     }
 
-    if (request.method === 'POST' && url.pathname === '/v1/events/ingest') {
-      const raw = await readRawBody(request);
-      const body = JSON.parse(raw.toString('utf8'));
-      const result = await processor.ingest(body);
-      logProcessingResult(result);
-      return sendJson(response, 202, result);
-    }
 
     if (request.method === 'GET' && url.pathname === '/v1/audit') {
       const afterSequence = Number(url.searchParams.get('afterSequence') ?? -1);
@@ -731,26 +632,6 @@ const server = createServer(async (request, response) => {
       return sendJson(response, 200, store.trace(traceId));
     }
 
-    if (
-      request.method === 'POST' &&
-      url.pathname.startsWith('/v1/wakes/') &&
-      url.pathname.endsWith('/ack')
-    ) {
-      const wakeId = decodeURIComponent(
-        url.pathname.slice('/v1/wakes/'.length, -'/ack'.length),
-      );
-      const raw = await readRawBody(request);
-      const body = raw.length
-        ? JSON.parse(raw.toString('utf8'))
-        : {};
-      const handled = await processor.acknowledgeWake(
-        wakeId,
-        typeof body.runtimeReceiptId === 'string'
-          ? body.runtimeReceiptId
-          : undefined,
-      );
-      return sendJson(response, 200, handled);
-    }
 
     return sendJson(response, 404, { error: 'NOT_FOUND' });
   } catch (error) {

package/server.json

@@ -2,8 +2,8 @@
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.sarooo17/event-intelligence",
   "title": "MCP Event Intelligence",
-  "description": "Durable temporal event intelligence: composite triggers, derived events, and runtime wakeups.",
-  "version": "0.4.0",
+  "description": "MCP-native CEP for durable agents: event-time patterns, semantic predicates, derived events.",
+  "version": "0.6.0",
   "repository": {
     "url": "https://github.com/sarooo17/event-intelligence",
     "source": "github"
@@ -13,7 +13,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "mcp-event-intelligence",
-      "version": "0.4.0",
+      "version": "0.6.0",
       "transport": {
         "type": "stdio"
       },
@@ -49,7 +49,7 @@
         },
         {
           "name": "TYPESAFE_API_KEY",
-          "description": "Optional TypeSafe Jev API key for semantic-correlation triggers.",
+          "description": "Optional TypeSafe Jev API key for explicit semantic Pattern AST nodes.",
           "isRequired": false,
           "isSecret": true,
           "format": "string"

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

@@ -1,3 +0,0 @@
-import type { EventLineage, SemanticDecisionRecord, WakeRecord } from './schemas.js';
-export declare function assertDecisionLineage(event: EventLineage, decision: SemanticDecisionRecord): void;
-export declare function assertWakeLineage(event: EventLineage, decision: SemanticDecisionRecord | null, wake: WakeRecord): void;

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,
-        },
-    });
-}