mcp-event-intelligence 0.3.1 → 0.4.0

package/dist/src/mcpEvents/provider.js

@@ -1,15 +1,37 @@
 import { McpEventOccurrenceSchema, } from '../intelligenceProtocol/schemas.js';
-export const MCP_EVENTS_CAPABILITY_KEY = 'io.modelcontextprotocol.experimental/events';
+export const MCP_EVENTS_EXTENSION_ID = 'io.modelcontextprotocol/events';
+export const MCP_EVENTS_CAPABILITY_KEY = MCP_EVENTS_EXTENSION_ID;
 export const MCP_EVENTS_CAPABILITY = Object.freeze({
-    status: 'draft',
-    designDate: '2026-02-19',
-    methods: ['events/list', 'events/poll'],
     listChanged: false,
 });
+export const MCP_EVENTS_ERROR = Object.freeze({
+    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 class McpEventsProtocolError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.name = 'McpEventsProtocolError';
+        this.code = code;
+        this.data = data;
+    }
+}
 const ALLOWED_DELIVERY = new Set(['poll', 'push', 'webhook']);
+const LIST_CURSOR_PREFIX = 'mcp-events-list-v1:';
+function invalidParams(message, data) {
+    throw new McpEventsProtocolError(MCP_EVENTS_ERROR.INVALID_PARAMS, message, data);
+}
 function assertRecord(value, message) {
     if (!value || Array.isArray(value) || typeof value !== 'object') {
-        throw new Error(message);
+        invalidParams(message);
     }
     return value;
 }
@@ -17,7 +39,7 @@ function optionalFiniteNumber(value, name) {
     if (value === undefined)
         return undefined;
     if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
-        throw new Error(`${name} must be a non-negative finite number`);
+        invalidParams(`${name} must be a non-negative finite number`);
     }
     return value;
 }
@@ -25,15 +47,18 @@ function normalizeDescriptor(input) {
     const raw = assertRecord(input, 'MCP event descriptor must be an object');
     const name = String(raw.name ?? '').trim();
     if (!name)
-        throw new Error('MCP event descriptor requires name');
+        invalidParams('MCP event descriptor requires name');
     const deliveryRaw = Array.isArray(raw.delivery) ? raw.delivery : ['poll'];
     const delivery = deliveryRaw.map((entry) => String(entry));
     if (delivery.length === 0 ||
         delivery.some((entry) => !ALLOWED_DELIVERY.has(entry))) {
-        throw new Error(`MCP event descriptor ${name} has invalid delivery modes`);
+        invalidParams(`MCP event descriptor ${name} has invalid delivery modes`);
     }
+    // createMcpEventsProvider is the poll-backed provider adapter. Hosts may
+    // consume push/webhook sources through the host delivery hooks, but a server
+    // using this adapter must expose poll for the check-since-cursor callback.
     if (!delivery.includes('poll')) {
-        throw new Error(`MCP provider event ${name} must advertise poll delivery in v0.1`);
+        invalidParams(`MCP provider event ${name} must advertise poll delivery`);
     }
     const inputSchema = raw.inputSchema === undefined
         ? {}
@@ -41,12 +66,16 @@ function normalizeDescriptor(input) {
     const payloadSchema = raw.payloadSchema === undefined
         ? {}
         : assertRecord(raw.payloadSchema, `MCP event descriptor ${name} payloadSchema must be an object`);
+    const meta = raw._meta === undefined
+        ? undefined
+        : assertRecord(raw._meta, `MCP event descriptor ${name} _meta must be an object`);
     return {
         name,
         description: String(raw.description ?? ''),
         delivery: delivery,
         inputSchema,
         payloadSchema,
+        ...(meta ? { _meta: meta } : {}),
     };
 }
 function schemaTypes(schema) {
@@ -59,11 +88,11 @@ export function assertJsonSchemaValue(schemaInput, value, path = '$') {
     const schema = assertRecord(schemaInput, `Invalid JSON Schema at ${path}`);
     if (Object.prototype.hasOwnProperty.call(schema, 'const') &&
         !Object.is(schema.const, value)) {
-        throw new Error(`MCP event payload violates schema at ${path}: const mismatch`);
+        throw new Error(`MCP event value violates schema at ${path}: const mismatch`);
     }
     if (Array.isArray(schema.enum) &&
         !schema.enum.some((entry) => Object.is(entry, value))) {
-        throw new Error(`MCP event payload violates schema at ${path}: value not in enum`);
+        throw new Error(`MCP event value violates schema at ${path}: value not in enum`);
     }
     const types = schemaTypes(schema);
     if (types.length > 0) {
@@ -87,23 +116,23 @@ export function assertJsonSchemaValue(schemaInput, value, path = '$') {
             return false;
         });
         if (!matches) {
-            throw new Error(`MCP event payload violates schema at ${path}: expected ${types.join('|')}`);
+            throw new Error(`MCP event value violates schema at ${path}: expected ${types.join('|')}`);
         }
     }
     if (typeof value === 'string') {
         if (typeof schema.minLength === 'number' && value.length < schema.minLength) {
-            throw new Error(`MCP event payload violates schema at ${path}: string too short`);
+            throw new Error(`MCP event value violates schema at ${path}: string too short`);
         }
         if (typeof schema.maxLength === 'number' && value.length > schema.maxLength) {
-            throw new Error(`MCP event payload violates schema at ${path}: string too long`);
+            throw new Error(`MCP event value violates schema at ${path}: string too long`);
         }
     }
     if (typeof value === 'number' && Number.isFinite(value)) {
         if (typeof schema.minimum === 'number' && value < schema.minimum) {
-            throw new Error(`MCP event payload violates schema at ${path}: below minimum`);
+            throw new Error(`MCP event value violates schema at ${path}: below minimum`);
         }
         if (typeof schema.maximum === 'number' && value > schema.maximum) {
-            throw new Error(`MCP event payload violates schema at ${path}: above maximum`);
+            throw new Error(`MCP event value violates schema at ${path}: above maximum`);
         }
     }
     if (value !== null && !Array.isArray(value) && typeof value === 'object') {
@@ -113,7 +142,7 @@ export function assertJsonSchemaValue(schemaInput, value, path = '$') {
             : [];
         for (const key of required) {
             if (!Object.prototype.hasOwnProperty.call(record, key)) {
-                throw new Error(`MCP event payload violates schema at ${path}: missing required property ${key}`);
+                throw new Error(`MCP event value violates schema at ${path}: missing required property ${key}`);
             }
         }
         const properties = schema.properties &&
@@ -132,7 +161,7 @@ export function assertJsonSchemaValue(schemaInput, value, path = '$') {
         if (schema.additionalProperties === false) {
             for (const key of Object.keys(record)) {
                 if (!Object.prototype.hasOwnProperty.call(properties, key)) {
-                    throw new Error(`MCP event payload violates schema at ${path}: unexpected property ${key}`);
+                    throw new Error(`MCP event value violates schema at ${path}: unexpected property ${key}`);
                 }
             }
         }
@@ -148,7 +177,7 @@ function normalizePollParams(paramsInput) {
     const params = assertRecord(paramsInput ?? {}, 'events/poll params must be an object');
     const name = String(params.name ?? '').trim();
     if (!name)
-        throw new Error('events/poll requires name');
+        invalidParams('events/poll requires name');
     const cursor = params.cursor === undefined || params.cursor === null
         ? null
         : String(params.cursor);
@@ -161,7 +190,7 @@ function normalizePollParams(paramsInput) {
         !Number.isInteger(maxEventsRaw) ||
         maxEventsRaw < 1 ||
         maxEventsRaw > 500) {
-        throw new Error('maxEvents must be an integer between 1 and 500');
+        invalidParams('maxEvents must be an integer between 1 and 500');
     }
     return {
         name,
@@ -171,10 +200,22 @@ function normalizePollParams(paramsInput) {
         maxEvents: maxEventsRaw,
     };
 }
+function encodeListCursor(offset) {
+    return `${LIST_CURSOR_PREFIX}${offset}`;
+}
+function decodeListCursor(value) {
+    if (typeof value !== 'string' || !value.startsWith(LIST_CURSOR_PREFIX)) {
+        invalidParams('events/list cursor is invalid');
+    }
+    const offset = Number(value.slice(LIST_CURSOR_PREFIX.length));
+    if (!Number.isInteger(offset) || offset < 0) {
+        invalidParams('events/list cursor is invalid');
+    }
+    return offset;
+}
 export class McpEventsProvider {
     events = new Map();
-    supportedVersions;
-    instructions;
+    listPageSize;
     constructor(options) {
         if (!options || !Array.isArray(options.events)) {
             throw new Error('MCP Events provider requires events[]');
@@ -192,59 +233,79 @@ export class McpEventsProvider {
                 poll: input.poll,
             });
         }
-        this.supportedVersions =
-            options.supportedVersions?.map(String).filter(Boolean) ?? ['2026-07-28'];
-        this.instructions =
-            options.instructions ??
-                'Experimental MCP Events provider compatibility adapter. Events follow the Triggers & Events design sketch; this is not finalized MCP conformance.';
+        const pageSize = options.listPageSize ?? 100;
+        if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > 1000) {
+            throw new Error('MCP Events listPageSize must be between 1 and 1000');
+        }
+        this.listPageSize = pageSize;
     }
     canHandle(method) {
-        return (method === 'server/discover' ||
-            method === 'events/list' ||
-            method === 'events/poll');
+        return method === 'events/list' || method === 'events/poll';
     }
-    listEvents() {
-        return [...this.events.values()].map(({ descriptor }) => descriptor);
+    listEvents(paramsInput) {
+        const params = paramsInput === undefined
+            ? {}
+            : assertRecord(paramsInput, 'events/list params must be an object');
+        const offset = params.cursor === undefined || params.cursor === null
+            ? 0
+            : decodeListCursor(params.cursor);
+        const all = [...this.events.values()].map(({ descriptor }) => descriptor);
+        if (offset > all.length)
+            invalidParams('events/list cursor is out of range');
+        const events = all.slice(offset, offset + this.listPageSize);
+        const nextOffset = offset + events.length;
+        return {
+            events,
+            ...(nextOffset < all.length
+                ? { nextCursor: encodeListCursor(nextOffset) }
+                : {}),
+        };
     }
     async handleRequest(request, context) {
         try {
             switch (request.method) {
-                case 'server/discover':
-                    return this.ok(request.id, {
-                        supportedVersions: this.supportedVersions,
-                        capabilities: {
-                            experimental: {
-                                [MCP_EVENTS_CAPABILITY_KEY]: MCP_EVENTS_CAPABILITY,
-                            },
-                        },
-                        instructions: this.instructions,
-                    });
                 case 'events/list':
-                    return this.ok(request.id, {
-                        events: this.listEvents(),
-                    });
+                    return this.ok(request.id, this.listEvents(request.params));
                 case 'events/poll':
                     return this.ok(request.id, await this.poll(request.params, context));
                 default:
-                    return this.error(request.id, -32601, `Method not found: ${request.method}`);
+                    return this.error(request.id, MCP_EVENTS_ERROR.METHOD_NOT_FOUND, `Method not found: ${request.method}`);
             }
         }
         catch (error) {
-            return this.error(request.id, -32602, error instanceof Error ? error.message : 'Invalid params');
+            if (error instanceof McpEventsProtocolError) {
+                return this.error(request.id, error.code, error.message, error.data);
+            }
+            return this.error(request.id, MCP_EVENTS_ERROR.INTERNAL_ERROR, error instanceof Error ? error.message : 'Internal error');
         }
     }
     async poll(paramsInput, context) {
         const params = normalizePollParams(paramsInput);
         const registered = this.events.get(params.name);
         if (!registered) {
-            throw new Error(`Unknown event: ${params.name}`);
+            throw new McpEventsProtocolError(MCP_EVENTS_ERROR.NOT_FOUND, `Unknown event: ${params.name}`, { kind: 'event' });
+        }
+        try {
+            assertJsonSchemaValue(registered.descriptor.inputSchema, params.arguments);
+        }
+        catch (error) {
+            throw new McpEventsProtocolError(MCP_EVENTS_ERROR.INVALID_PARAMS, error instanceof Error ? error.message : 'Invalid event arguments');
         }
-        const result = assertRecord(await registered.poll({
+        const rawResult = await registered.poll({
             ...params,
             context,
-        }), `MCP provider ${params.name} returned invalid poll result`);
-        if (typeof result.cursor !== 'string') {
-            throw new Error(`MCP provider ${params.name} returned poll result without string cursor`);
+        });
+        if (!rawResult || Array.isArray(rawResult) || typeof rawResult !== 'object') {
+            throw new Error(`MCP provider ${params.name} returned invalid poll result`);
+        }
+        const result = rawResult;
+        const cursor = result.cursor === null
+            ? null
+            : typeof result.cursor === 'string'
+                ? result.cursor
+                : undefined;
+        if (cursor === undefined) {
+            throw new Error(`MCP provider ${params.name} returned poll result without string|null cursor`);
         }
         if (!Array.isArray(result.events)) {
             throw new Error(`MCP provider ${params.name} returned poll result without events[]`);
@@ -277,7 +338,7 @@ export class McpEventsProvider {
         }
         return {
             events,
-            cursor: result.cursor,
+            cursor,
             truncated,
             hasMore,
             nextPollMs,
@@ -286,8 +347,16 @@ export class McpEventsProvider {
     ok(id, result) {
         return { jsonrpc: '2.0', id, result };
     }
-    error(id, code, message) {
-        return { jsonrpc: '2.0', id, error: { code, message } };
+    error(id, code, message, data) {
+        return {
+            jsonrpc: '2.0',
+            id,
+            error: {
+                code,
+                message,
+                ...(data === undefined ? {} : { data }),
+            },
+        };
     }
 }
 export function createMcpEventsProvider(options) {

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

@@ -2,6 +2,8 @@ import type { EventDescriptor, EventOccurrence, JsonRpcRequest, JsonRpcResponse
 export interface PersistedMcpOccurrence {
     sequence: number;
     serverId: string;
+    /** Client-side durable subscription identity when this log is used by EI. */
+    subscriptionId?: string | null;
     event: EventOccurrence;
 }
 export interface McpEventOccurrenceStore {
@@ -21,7 +23,7 @@ export interface PollEventsParams {
 }
 export interface PollEventsResult {
     events: EventOccurrence[];
-    cursor: string;
+    cursor: string | null;
     truncated: boolean;
     hasMore: boolean;
     nextPollMs: number;

package/dist/src/mcpEvents/server.js

@@ -26,27 +26,20 @@ export class ExperimentalMcpEventsServer {
     async handleRequest(request) {
         try {
             switch (request.method) {
-                case 'server/discover':
-                    return this.ok(request.id, {
-                        supportedVersions: ['2026-07-28'],
-                        capabilities: {
-                            experimental: {
-                                'io.modelcontextprotocol.experimental/events': {
-                                    status: 'draft',
-                                    designDate: '2026-02-19',
-                                    methods: ['events/list', 'events/poll'],
-                                    listChanged: false,
-                                },
-                            },
-                        },
-                        instructions: 'Experimental MCP Events provider. Events follow the Triggers & Events WG design sketch; this is not finalized MCP conformance.',
-                    });
                 case 'events/list':
                     return this.ok(request.id, {
                         events: [...this.events.values()].map((entry) => entry.descriptor),
                     });
-                case 'events/poll':
-                    return this.ok(request.id, this.poll((request.params ?? {})));
+                case 'events/poll': {
+                    const params = (request.params ?? {});
+                    if (!params.name || typeof params.name !== 'string') {
+                        return this.error(request.id, -32602, 'events/poll requires name');
+                    }
+                    if (!this.events.has(params.name)) {
+                        return this.error(request.id, -32011, `Unknown event: ${params.name}`, { kind: 'event' });
+                    }
+                    return this.ok(request.id, this.poll(params));
+                }
                 default:
                     return this.error(request.id, -32601, `Method not found: ${request.method}`);
             }
@@ -116,7 +109,15 @@ export class ExperimentalMcpEventsServer {
     ok(id, result) {
         return { jsonrpc: '2.0', id, result };
     }
-    error(id, code, message) {
-        return { jsonrpc: '2.0', id, error: { code, message } };
+    error(id, code, message, data) {
+        return {
+            jsonrpc: '2.0',
+            id,
+            error: {
+                code,
+                message,
+                ...(data === undefined ? {} : { data }),
+            },
+        };
     }
 }

package/dist/src/protocol/types.d.ts

@@ -26,6 +26,7 @@ export interface EventDescriptor {
     delivery: Array<'poll' | 'push' | 'webhook'>;
     inputSchema: Record<string, unknown>;
     payloadSchema: Record<string, unknown>;
+    _meta?: Record<string, unknown>;
 }
 export interface EventOccurrence<TData extends Record<string, unknown> = Record<string, unknown>> {
     eventId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-event-intelligence",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Durable temporal event intelligence for agent hosts: host-owned MCP event discovery, composite triggers, derived events, and targeted wakeups.",
   "license": "Apache-2.0",
   "type": "module",

package/scripts/host-integration.d.mts

@@ -11,6 +11,33 @@ export interface HostMcpClientLike {
   getServerCapabilities?(): unknown;
 }
 
+export interface HostMcpEventDeliveryCallbacks {
+  subscriptionId: string;
+  name: string;
+  arguments: Record<string, unknown>;
+  cursor: string | null;
+  onEvent(event: Record<string, unknown>): Promise<void>;
+  onActive(state?: Record<string, unknown>): Promise<void>;
+  onGap(state?: Record<string, unknown>): Promise<void>;
+  onError(error: unknown): void;
+  onTerminated(detail?: unknown): Promise<void>;
+}
+
+export type HostMcpEventDeliveryHandle =
+  | (() => void | Promise<void>)
+  | {
+      cursor?: string | null;
+      truncated?: boolean;
+      close?(): void | Promise<void>;
+      cancel?(): void | Promise<void>;
+      unsubscribe?(): void | Promise<void>;
+    };
+
+export type HostMcpEventDeliveryOpener = (
+  input: HostMcpEventDeliveryCallbacks,
+) => HostMcpEventDeliveryHandle | Promise<HostMcpEventDeliveryHandle>;
+
+
 export interface HostMcpConnectionOptions {
   connectionId?: string;
   id?: string;
@@ -18,6 +45,8 @@ export interface HostMcpConnectionOptions {
   serverId?: string;
   client?: HostMcpClientLike;
   request?: (method: string, params?: unknown) => Promise<unknown>;
+  getCapabilities?: () => unknown | Promise<unknown>;
+  capabilities?: Record<string, unknown>;
   enabled?: boolean;
   /** Isolation partition used by the shared EI host. Defaults to \"default\". */
   scopeId?: string;
@@ -25,6 +54,12 @@ export interface HostMcpConnectionOptions {
   maxEvents?: number;
   /** Maximum number of immediately drained pages when the provider reports hasMore. */
   maxPollBatches?: number;
+  /** Prefer one advertised delivery mode when the host can provide it. */
+  preferredDelivery?: 'poll' | 'push' | 'webhook';
+  /** Host-owned adapter for events/stream delivery. */
+  openEventStream?: HostMcpEventDeliveryOpener;
+  /** Host-owned adapter for webhook subscription/receiver delivery. */
+  createWebhookSubscription?: HostMcpEventDeliveryOpener;
 }
 
 export interface HostMcpRegistry {
@@ -113,9 +148,14 @@ export function createHostMcpEventsConnection(
   connectionId: string;
   serverId: string;
   request(method: string, params?: unknown): Promise<unknown>;
+  getCapabilities(): unknown | Promise<unknown>;
   enabled: boolean;
   pollIntervalMs: number;
   maxEvents: number;
+  maxPollBatches: number;
+  preferredDelivery: 'poll' | 'push' | 'webhook' | null;
+  openEventStream: HostMcpEventDeliveryOpener | null;
+  createWebhookSubscription: HostMcpEventDeliveryOpener | null;
 };
 
 export function createEventIntelligenceHost(

package/scripts/lib/composite-event-consumer.mjs

@@ -34,6 +34,7 @@ export class CompositeEventConsumer {
     serverId,
     provider,
     traceId,
+    subscriptionArguments,
   }) {
     const correlatable = await mcpOccurrenceToCorrelatableEvent(
       event,
@@ -41,6 +42,7 @@ export class CompositeEventConsumer {
         traceId,
         ...(provider ? { provider } : {}),
         ...(serverId ? { serverId } : {}),
+        subscriptionArguments: subscriptionArguments ?? {},
       },
     );
 

package/scripts/lib/json-schema.mjs

@@ -0,0 +1,134 @@
+function assertRecord(value, message) {
+  if (!value || Array.isArray(value) || typeof value !== 'object') {
+    throw new Error(message);
+  }
+  return value;
+}
+
+function schemaTypes(schema) {
+  if (Array.isArray(schema?.type)) return schema.type.map(String);
+  return schema?.type === undefined ? [] : [String(schema.type)];
+}
+
+export function assertJsonSchemaValue(schemaInput, value, path = '$') {
+  if (!schemaInput || Array.isArray(schemaInput) || typeof schemaInput !== 'object') {
+    return;
+  }
+  const schema = schemaInput;
+
+  if (
+    Object.prototype.hasOwnProperty.call(schema, 'const') &&
+    !Object.is(schema.const, value)
+  ) {
+    throw new Error(`JSON Schema violation at ${path}: const mismatch`);
+  }
+
+  if (
+    Array.isArray(schema.enum) &&
+    !schema.enum.some((entry) => Object.is(entry, value))
+  ) {
+    throw new Error(`JSON Schema violation at ${path}: value not in enum`);
+  }
+
+  const types = schemaTypes(schema);
+  if (types.length) {
+    const matches = types.some((type) => {
+      if (type === 'null') return value === null;
+      if (type === 'array') return Array.isArray(value);
+      if (type === 'object') {
+        return value !== null && !Array.isArray(value) && typeof value === 'object';
+      }
+      if (type === 'integer') return Number.isInteger(value);
+      if (type === 'number') return typeof value === 'number' && Number.isFinite(value);
+      if (type === 'string') return typeof value === 'string';
+      if (type === 'boolean') return typeof value === 'boolean';
+      return false;
+    });
+    if (!matches) {
+      throw new Error(
+        `JSON Schema violation at ${path}: expected ${types.join('|')}`,
+      );
+    }
+  }
+
+  if (typeof value === 'string') {
+    if (typeof schema.minLength === 'number' && value.length < schema.minLength) {
+      throw new Error(`JSON Schema violation at ${path}: string too short`);
+    }
+    if (typeof schema.maxLength === 'number' && value.length > schema.maxLength) {
+      throw new Error(`JSON Schema violation at ${path}: string too long`);
+    }
+    if (typeof schema.pattern === 'string') {
+      const re = new RegExp(schema.pattern);
+      if (!re.test(value)) {
+        throw new Error(`JSON Schema violation at ${path}: pattern mismatch`);
+      }
+    }
+  }
+
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    if (typeof schema.minimum === 'number' && value < schema.minimum) {
+      throw new Error(`JSON Schema violation at ${path}: below minimum`);
+    }
+    if (typeof schema.maximum === 'number' && value > schema.maximum) {
+      throw new Error(`JSON Schema violation at ${path}: above maximum`);
+    }
+  }
+
+  if (value !== null && !Array.isArray(value) && typeof value === 'object') {
+    const record = value;
+    const required = Array.isArray(schema.required)
+      ? schema.required.map(String)
+      : [];
+    for (const key of required) {
+      if (!Object.prototype.hasOwnProperty.call(record, key)) {
+        throw new Error(
+          `JSON Schema violation at ${path}: missing required property ${key}`,
+        );
+      }
+    }
+
+    const properties =
+      schema.properties &&
+      !Array.isArray(schema.properties) &&
+      typeof schema.properties === 'object'
+        ? schema.properties
+        : {};
+
+    for (const [key, childSchema] of Object.entries(properties)) {
+      if (
+        Object.prototype.hasOwnProperty.call(record, key) &&
+        childSchema &&
+        !Array.isArray(childSchema) &&
+        typeof childSchema === 'object'
+      ) {
+        assertJsonSchemaValue(childSchema, record[key], `${path}.${key}`);
+      }
+    }
+
+    if (schema.additionalProperties === false) {
+      for (const key of Object.keys(record)) {
+        if (!Object.prototype.hasOwnProperty.call(properties, key)) {
+          throw new Error(
+            `JSON Schema violation at ${path}: unexpected property ${key}`,
+          );
+        }
+      }
+    }
+  }
+
+  if (
+    Array.isArray(value) &&
+    schema.items &&
+    !Array.isArray(schema.items) &&
+    typeof schema.items === 'object'
+  ) {
+    value.forEach((entry, index) =>
+      assertJsonSchemaValue(schema.items, entry, `${path}[${index}]`),
+    );
+  }
+}
+
+export function assertJsonObject(value, message) {
+  return assertRecord(value, message);
+}

package/scripts/lib/local-event-intelligence-runtime.mjs

@@ -65,6 +65,7 @@ const REQUIRED_STORE_METHODS = [
   'appendAudit',
   'auditLength',
   'getMcpClientState',
+  'listMcpClientStates',
   'putMcpClientState',
   'appendMcpOccurrence',
 ];