mcp-event-intelligence 0.3.0 → 0.4.0

package/scripts/lib/persistent-event-store.mjs

@@ -32,6 +32,22 @@ function scopeIdFromDirectoryName(name) {
   }
 }
 
+function canonicalStateValue(value) {
+  if (Array.isArray(value)) return value.map(canonicalStateValue);
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.keys(value)
+        .sort()
+        .map((key) => [key, canonicalStateValue(value[key])]),
+    );
+  }
+  return value;
+}
+
+function mcpClientStateKey(connectionId, eventName, args = {}) {
+  return `${String(connectionId)}::${String(eventName)}::${JSON.stringify(canonicalStateValue(args ?? {}))}`;
+}
+
 async function readJsonLines(filePath) {
   try {
     const raw = await readFile(filePath, 'utf8');
@@ -263,6 +279,7 @@ export class PersistentEventStore {
       const record = {
         sequence: Number(raw.sequence),
         serverId: String(raw.serverId),
+        subscriptionId: raw.subscriptionId ? String(raw.subscriptionId) : null,
         event: McpEventOccurrenceSchema.parse(raw.event),
       };
       if (!Number.isInteger(record.sequence) || record.sequence < 1) {
@@ -270,7 +287,7 @@ export class PersistentEventStore {
       }
       this.#mcpOccurrences.push(record);
       this.#mcpOccurrenceKeys.add(
-        `${record.serverId}:${record.event.eventId}`,
+        `${record.serverId}:${record.subscriptionId ?? ''}:${record.event.eventId}`,
       );
     }
     this.#mcpOccurrences.sort((a, b) => a.sequence - b.sequence);
@@ -282,15 +299,27 @@ export class PersistentEventStore {
         connectionId: String(raw.connectionId),
         serverId: String(raw.serverId || raw.connectionId),
         eventName: String(raw.eventName),
+        arguments:
+          raw.arguments && !Array.isArray(raw.arguments) && typeof raw.arguments === 'object'
+            ? raw.arguments
+            : {},
+        subscriptionId: raw.subscriptionId ? String(raw.subscriptionId) : null,
+        deliveryMode: raw.deliveryMode ? String(raw.deliveryMode) : 'poll',
         cursor: raw.cursor === null || raw.cursor === undefined
           ? null
           : String(raw.cursor),
         updatedAt: String(raw.updatedAt || new Date(0).toISOString()),
+        ...(raw.nextPollAt ? { nextPollAt: String(raw.nextPollAt) } : {}),
         ...(raw.lastEventAt ? { lastEventAt: String(raw.lastEventAt) } : {}),
         ...(raw.lastError ? { lastError: String(raw.lastError) } : {}),
+        ...(typeof raw.truncated === 'boolean' ? { truncated: raw.truncated } : {}),
       };
       this.#mcpClientStates.set(
-        `${state.connectionId}::${state.eventName}`,
+        mcpClientStateKey(
+          state.connectionId,
+          state.eventName,
+          state.arguments,
+        ),
         state,
       );
     }
@@ -776,13 +805,19 @@ export class PersistentEventStore {
       .filter((record) => !matchId || record.matchId === matchId);
   }
 
-  async appendMcpOccurrence(serverId, eventInput) {
+  async appendMcpOccurrence(serverId, eventInput, subscriptionIdInput = null) {
     return this.#serialized(async () => {
       const event = McpEventOccurrenceSchema.parse(eventInput);
-      const key = `${serverId}:${event.eventId}`;
+      const subscriptionId =
+        subscriptionIdInput === null || subscriptionIdInput === undefined
+          ? null
+          : String(subscriptionIdInput);
+      const key =
+        `${serverId}:${subscriptionId ?? ''}:${event.eventId}`;
       const existing = this.#mcpOccurrences.find(
         (record) =>
           record.serverId === serverId &&
+          (record.subscriptionId ?? null) === subscriptionId &&
           record.event.eventId === event.eventId,
       );
       if (this.#mcpOccurrenceKeys.has(key)) {
@@ -794,7 +829,12 @@ export class PersistentEventStore {
       }
 
       const sequence = this.latestMcpEventSequence() + 1;
-      const record = { sequence, serverId, event };
+      const record = {
+        sequence,
+        serverId,
+        subscriptionId,
+        event,
+      };
       this.#mcpOccurrenceKeys.add(key);
       this.#mcpOccurrences.push(record);
       await appendFile(
@@ -816,6 +856,7 @@ export class PersistentEventStore {
       .map((record) => ({
         sequence: record.sequence,
         serverId: record.serverId,
+        subscriptionId: record.subscriptionId ?? null,
         event: {
           ...record.event,
           data: { ...record.event.data },
@@ -823,9 +864,9 @@ export class PersistentEventStore {
       }));
   }
 
-  getMcpClientState(connectionId, eventName) {
+  getMcpClientState(connectionId, eventName, args = {}) {
     return this.#mcpClientStates.get(
-      `${String(connectionId)}::${String(eventName)}`,
+      mcpClientStateKey(connectionId, eventName, args),
     ) ?? null;
   }
 
@@ -843,24 +884,42 @@ export class PersistentEventStore {
       if (!connectionId || !eventName) {
         throw new Error('MCP client state requires connectionId and eventName');
       }
-      const previous = this.getMcpClientState(connectionId, eventName);
+      const args =
+        input.arguments && !Array.isArray(input.arguments) && typeof input.arguments === 'object'
+          ? input.arguments
+          : {};
+      const previous = this.getMcpClientState(connectionId, eventName, args);
       const state = {
         connectionId,
         serverId: String(input.serverId || previous?.serverId || connectionId),
         eventName,
+        arguments: args,
+        subscriptionId:
+          input.subscriptionId
+            ? String(input.subscriptionId)
+            : previous?.subscriptionId ?? null,
+        deliveryMode: String(input.deliveryMode || previous?.deliveryMode || 'poll'),
         cursor: input.cursor === null || input.cursor === undefined
           ? null
           : String(input.cursor),
         updatedAt: new Date().toISOString(),
+        ...(input.nextPollAt || previous?.nextPollAt
+          ? { nextPollAt: String(input.nextPollAt || previous.nextPollAt) }
+          : {}),
         ...(input.lastEventAt || previous?.lastEventAt
           ? { lastEventAt: String(input.lastEventAt || previous.lastEventAt) }
           : {}),
         ...(input.lastError
           ? { lastError: String(input.lastError) }
           : {}),
+        ...(typeof input.truncated === 'boolean'
+          ? { truncated: input.truncated }
+          : typeof previous?.truncated === 'boolean'
+            ? { truncated: previous.truncated }
+            : {}),
       };
       this.#mcpClientStates.set(
-        `${connectionId}::${eventName}`,
+        mcpClientStateKey(connectionId, eventName, args),
         state,
       );
       await appendFile(

package/scripts/lib/trigger-control-plane.mjs

@@ -5,6 +5,7 @@ import {
 import {
   DerivedContractRegistry,
 } from './derived-contract-registry.mjs';
+import { assertJsonSchemaValue } from './json-schema.mjs';
 
 function actorIdentity(actor) {
   if (!actor || typeof actor !== 'object') {
@@ -66,6 +67,26 @@ function scalarSchemaForConstant(value) {
   return {};
 }
 
+function assertSubscriptionArguments(source, args, purpose) {
+  const inputSchema = source?.inputSchema;
+  if (
+    !inputSchema ||
+    typeof inputSchema !== 'object' ||
+    Object.keys(inputSchema).length === 0
+  ) {
+    return;
+  }
+  try {
+    assertJsonSchemaValue(inputSchema, args ?? {});
+  } catch (error) {
+    const wrapped = new Error(
+      `${purpose} arguments are invalid for ${source.serverId}/${source.eventName}: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    wrapped.code = 'TRIGGER_SOURCE_ARGUMENTS_INVALID';
+    throw wrapped;
+  }
+}
+
 function assertAdvertisedPath(source, path, purpose) {
   const payloadSchema = source?.payloadSchema;
   if (
@@ -695,6 +716,11 @@ export class TriggerControlPlane {
 
     for (const clause of definition.clauses) {
       const source = resolveSource(clause);
+      assertSubscriptionArguments(
+        source,
+        clause.arguments ?? {},
+        `Trigger clause ${clause.id}`,
+      );
       for (const predicate of clause.where ?? []) {
         assertAdvertisedPath(
           source,

package/scripts/lib/trigger-planner.mjs

@@ -4,6 +4,7 @@ import {
   parseTriggerPlanInput,
   sha256Hex,
 } from '../../dist/src/intelligenceProtocol/index.js';
+import { assertJsonSchemaValue } from './json-schema.mjs';
 
 function schemaNodeAtPath(schema, path) {
   if (!schema || typeof schema !== 'object') return null;
@@ -25,9 +26,28 @@ function sourceSummary(source) {
     serverId: source.serverId,
     eventName: source.eventName,
     description: source.description ?? null,
+    delivery: source.delivery ?? [],
+    inputSchema: source.inputSchema ?? {},
+    payloadSchema: source.payloadSchema ?? {},
   };
 }
 
+function validateArgumentsAgainstSource(source, args) {
+  const schema = source.inputSchema;
+  if (!schema || typeof schema !== 'object' || Object.keys(schema).length === 0) {
+    return;
+  }
+  try {
+    assertJsonSchemaValue(schema, args ?? {});
+  } catch (error) {
+    throw sourceError(
+      'TRIGGER_PLAN_ARGUMENTS_INVALID',
+      `Subscription arguments do not match ${source.serverId}/${source.eventName}: ${error instanceof Error ? error.message : String(error)}`,
+      [source],
+    );
+  }
+}
+
 function sourceError(code, message, sources = []) {
   const error = new Error(message);
   error.code = code;
@@ -149,6 +169,7 @@ export class TriggerPlanner {
       }
 
       const source = matches[0];
+      validateArgumentsAgainstSource(source, event.arguments);
       for (const predicate of event.where) {
         validatePredicateAgainstSource(source, predicate, warnings);
       }
@@ -158,6 +179,7 @@ export class TriggerPlanner {
         id,
         event: event.event,
         serverId: source.serverId,
+        arguments: event.arguments,
         where: event.where,
       };
     });
@@ -230,6 +252,7 @@ export class TriggerPlanner {
             id: clause.id,
             event: clause.event,
             serverId: clause.serverId,
+            arguments: clause.arguments,
             where: clause.where,
           })),
           withinMs: definition.withinMs,

package/scripts/mcp-stdio-server.mjs

@@ -71,6 +71,7 @@ const triggerPlanInputSchema = 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([
@@ -451,7 +452,7 @@ export async function buildEventIntelligenceMcpServer({
   const server = new McpServer(
     {
       name: 'mcp-event-intelligence',
-      version: '0.3.0',
+      version: '0.3.1',
     },
     {
       instructions:

package/server.json

@@ -3,7 +3,7 @@
   "name": "io.github.sarooo17/event-intelligence",
   "title": "MCP Event Intelligence",
   "description": "Durable temporal event intelligence: composite triggers, derived events, and runtime wakeups.",
-  "version": "0.3.0",
+  "version": "0.4.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.3.0",
+      "version": "0.4.0",
       "transport": {
         "type": "stdio"
       },