mcp-event-intelligence 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,7 +1,47 @@
 # Changelog
 
+## [0.4.0] - 2026-09-25
+
+Current MCP Events draft alignment.
+
+### MCP Events boundary
+
+- switched event capability negotiation to `capabilities.extensions["io.modelcontextprotocol/events"]`;
+- removed the legacy `server/discover` / `io.modelcontextprotocol.experimental/events` compatibility surface;
+- added paginated `events/list`, draft error semantics, nullable cursors and `_meta` preservation;
+- validates subscription `arguments` against advertised `inputSchema`;
+- separates EventSource descriptors from durable EventSubscriptions keyed by connection + event name + canonical arguments;
+- stores independent cursor/delivery state per subscription;
+- poll scheduling now follows server `nextPollMs` and keeps `hasMore` distinct from `truncated`;
+- host-owned push and webhook adapters feed the same EventOccurrence pipeline as poll;
+- added current-draft discovery/poll conformance-shaped regression coverage.
+
+### Compatibility
+
+- trigger clauses gain additive `arguments: {}`; existing persisted trigger definitions remain readable because omitted arguments default to an empty object;
+- composite, temporal, derived-event and wake semantics are unchanged;
+- event ingress targets the 2026-09-25 experimental draft direction represented by experimental-ext-triggers-events PR #7 and conformance PR #521, not a finalized MCP specification.
+
 All notable public changes are documented here.
 
+## [0.3.1] - 2026-09-20
+
+Public-polish and reliability patch before wider distribution.
+
+### Reliability
+
+- fixed the lease-claim test cleanup race that could surface intermittent `ENOTEMPTY` errors while an in-flight worker was still writing;
+- added repeated direct lease-claim contention coverage and full coordinator contention stress coverage.
+
+### Documentation and public surface
+
+- refreshed Security Policy and Security Model for scoped multi-tenant hosts, Activation Envelopes and the v0.3 agent-friendly planning flow;
+- clarified the distinction between package version 0.3.x and the intentionally compatible internal protocol/schema v0.1 identifiers;
+- refreshed Architecture and Protocol docs for `planTrigger()`, continuation contracts and wake hydration;
+- updated MCP Registry docs to reflect the package and Registry as live, not deferred;
+- updated the CLI help banner;
+- removed the obsolete one-shot v0.1.0 release workflow.
+
 ## [0.3.0] - 2026-09-20
 
 Agent-integration release focused on making Event Intelligence usable as a plug-and-play future-condition primitive.

package/README.md

@@ -4,7 +4,7 @@
 
 [![CI](https://github.com/sarooo17/event-intelligence/actions/workflows/ci.yml/badge.svg)](https://github.com/sarooo17/event-intelligence/actions/workflows/ci.yml)
 [![npm](https://img.shields.io/npm/v/mcp-event-intelligence.svg)](https://www.npmjs.com/package/mcp-event-intelligence)
-[![MCP Registry](https://img.shields.io/badge/MCP%20Registry-v0.3.0-5b5bd6)](https://registry.modelcontextprotocol.io/?q=io.github.sarooo17%2Fevent-intelligence)
+[![MCP Registry](https://img.shields.io/badge/MCP%20Registry-v0.4.0-5b5bd6)](https://registry.modelcontextprotocol.io/?q=io.github.sarooo17%2Fevent-intelligence)
 [![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
 
 MCP Event Intelligence is an experimental event runtime for agents that need to react to **future conditions over multiple event sources** without keeping an LLM or agent loop alive.
@@ -169,9 +169,9 @@ const events = createMcpEventsProvider({
 });
 ```
 
-The package owns capability advertisement, `server/discover`, `events/list`, `events/poll`, common validation and response shapes. The provider owns domain event definitions, authentication, data queries, occurrence IDs and opaque cursor semantics.
+The package owns the current draft Events extension identifier/settings, `events/list`, `events/poll`, common validation and response shapes. The embedding MCP server advertises `capabilities.extensions["io.modelcontextprotocol/events"]`; the provider owns domain event definitions, authentication, data queries, occurrence IDs and opaque cursor semantics.
 
-This adapter remains experimental compatibility work around MCP Events; it is not a claim of finalized MCP Events conformance.
+This adapter tracks the current experimental MCP Events draft. It is not a claim of finalized MCP Events conformance. The v0.4 compatibility snapshot follows the `io.modelcontextprotocol/events` extension-negotiation direction in experimental-ext-triggers-events PR #7 and the discovery/poll contract exercised by conformance PR #521 as of 2026-09-25.
 
 
 An ERPNext-shaped **provider factory** is also exported:
@@ -203,15 +203,18 @@ timezone normalization and deterministic occurrence IDs. The local factory in
 this package should therefore be read as a typed convenience API, not as the
 production ERP connector itself.
 
-## What v0.3 implements
+## What v0.4 implements
 
 ### Host-owned event sources
 
 - automatic discovery from the host's existing MCP registry;
 - reuse of already-connected MCP clients without duplicate credentials;
-- experimental MCP Events capability discovery;
-- `events/list` and `events/poll`;
-- persistent opaque cursors;
+- direct MCP extension negotiation through `capabilities.extensions["io.modelcontextprotocol/events"]`;
+- paginated `events/list` discovery;
+- durable EventSubscription identity over `(connection, event name, arguments)`;
+- `events/poll` with server-directed `nextPollMs`, nullable cursors and bounded page draining;
+- host-owned push and webhook delivery adapters feeding the same EventOccurrence pipeline;
+- persistent opaque cursors and per-subscription delivery state;
 - per-scope source/cursor isolation for shared hosts;
 - single-flight polling per connection plus bounded `hasMore` batch draining;
 - automatic event-source registration;
@@ -228,10 +231,19 @@ production ERP connector itself.
 - calendar-aware conditions with IANA timezones;
 - durable deadlines that continue even when no new provider event arrives.
 
+### Event sources vs subscriptions
+
+`events/list` discovers an **EventSource** descriptor. A durable **EventSubscription** is a separate runtime object identified by the host connection, event name and canonical subscription `arguments`. Each subscription owns its cursor/delivery state independently.
+
+This keeps MCP-side filtering separate from Event Intelligence conditions: `arguments` are validated against the provider's `inputSchema`; trigger `where` predicates are evaluated by EI against delivered payloads. Two triggers may therefore subscribe to the same event name with different arguments without sharing cursors.
+
+Poll, push and webhook are treated only as delivery mechanisms. All three normalize into the same `EventOccurrence` ingestion path before correlation, temporal reasoning, derived events or wake logic.
+
 ### Agent-authored continuations
 
 - event-source discovery;
 - agent-friendly deterministic trigger planning/compilation;
+- MCP subscription `arguments` validated against each source `inputSchema`, kept distinct from EI payload predicates;
 - `eq`, `neq`, `contains`, `in`, `exists`, `gt`, `gte`, `lt`, `lte` predicates;
 - persisted continuation contracts separated from trigger conditions;
 - Activation Envelope hydration with matched event evidence;
@@ -300,13 +312,13 @@ Event Intelligence has one optional AI boundary: **semantic correlation**.
 - embedded hosts may inject a compatible `semanticEvaluator` instead.
 - there is no bundled OpenAI planner and no OpenAI API dependency.
 
-The agent/harness is already responsible for reasoning and can author a structured trigger directly from `event_sources_list` / the discovered schemas. Deterministic correlation, temporal logic, persistence, derived events and wake delivery require no model API.
+The agent/harness is already responsible for natural-language reasoning. It can use `trigger_plan` / `planTrigger()` to compile common requests deterministically against discovered source schemas, or submit a canonical trigger definition directly for advanced cases. Deterministic correlation, temporal logic, persistence, derived events and wake delivery require no model API.
 
 ## Full-system acceptance
 
-The v0.3 acceptance suite verifies:
+The v0.4 acceptance suite verifies:
 
-- host-owned MCP client → event discovery/poll → composite match → in-process wake;
+- host-owned MCP client → extension discovery → durable subscription → poll/push/webhook occurrence → composite match → in-process wake;
 - provider-neutral events → composite match → derived event → derived composition → signed runtime wake;
 - contract schema evolution and ambiguity rejection;
 - refs-only root provenance;
@@ -350,13 +362,13 @@ The standalone service supports manual/provider-native event ingress. It does no
 ### Docker
 
 ```bash
-docker build -t mcp-event-intelligence:0.3.0 .
+docker build -t mcp-event-intelligence:0.4.0 .
 
 docker run --rm \
   -p 3000:3000 \
   -v mcp-event-intelligence-data:/data \
   -e SERVICE_AUTH_TOKEN="$(openssl rand -hex 32)" \
-  mcp-event-intelligence:0.3.0
+  mcp-event-intelligence:0.4.0
 ```
 
 ## Optional MCP control plane
@@ -432,7 +444,7 @@ In embedded mode, the host retains MCP authorization and credentials; Event Inte
 
 There are two separate MCP boundaries:
 
-- **event ingress**: host-owned, already-connected MCP clients exposing experimental Events, plus provider-native adapters;
+- **event ingress**: host-owned, already-connected MCP clients exposing the experimental `io.modelcontextprotocol/events` extension, plus provider-native adapters; poll is native in the reference provider adapter, while push/webhook receivers remain host-owned delivery adapters;
 - **control plane**: optional standard MCP **stdio** server built on the official TypeScript SDK v2 and targeting protocol revision 2026-07-28.
 
 Registry identity:
@@ -445,7 +457,7 @@ io.github.sarooo17/event-intelligence
 
 ## Project status
 
-**v0.3 reference implementation / experimental.**
+**v0.4.x reference implementation / experimental.**
 
 The architecture is implemented and exercised end-to-end. Storage is now injectable and scoped, while the bundled JSONL backend remains a single-process reference implementation. Remaining work is primarily production database adapters/HA validation, scale benchmarks and upstream feedback.
 

package/SECURITY.md

@@ -2,12 +2,12 @@
 
 ## Supported versions
 
-The public reference implementation is currently pre-1.0.
+The public package is pre-1.0. Security fixes are supported on the current 0.3.x line.
 
 | Version | Supported |
 | --- | --- |
-| 0.1.x | Yes |
-| < 0.1 | No |
+| 0.3.x | Yes |
+| < 0.3 | No |
 
 ## Reporting a vulnerability
 
@@ -26,17 +26,21 @@ Useful reports include:
 
 ## Security boundaries
 
-Event Intelligence v0.1 is a reference implementation, not a hardened multi-tenant hosted service.
+Event Intelligence 0.3.x is an experimental reference implementation with scoped multi-tenant host support. It is not a turnkey hardened hosted service.
 
 Important defaults and constraints:
 
-- protected control-plane endpoints require `SERVICE_AUTH_TOKEN`;
+- tenant/workspace isolation is implemented through scoped store partitions; tenant-facing code should receive only the corresponding scoped host view;
+- protected standalone control-plane endpoints require `SERVICE_AUTH_TOKEN`;
 - GitHub ingress verifies provider HMAC when configured;
-- runtime wake packets are HMAC-signed and runtime targets are operator-configured;
+- standalone runtime wake packets are HMAC-signed and runtime targets are operator-configured;
+- embedded wakes preserve the configured continuation separately from untrusted matched-event evidence;
+- event receipt never grants new downstream authorization;
 - arbitrary public HTTP wake targets are rejected;
 - derived-event lineage is refs-only by default;
 - audit records are hash-linked and tamper-evident, not tamper-proof;
-- the JSONL store is single-writer and not safe for horizontal multi-replica deployment;
+- the bundled JSONL store is single-process reference infrastructure and is not safe as a shared multi-replica backend;
+- horizontally scaled custom stores must preserve scope isolation and implement wake claim/lease operations atomically;
 - secrets belong in environment variables / secret managers, never committed files.
 
 See `docs/SECURITY-MODEL.md` for the architectural model.

package/bin/mcp-event-intelligence.mjs

@@ -4,12 +4,12 @@ const args = process.argv.slice(2);
 const flags = new Set(args);
 
 if (flags.has('--version') || flags.has('-v')) {
-  console.log('0.3.0');
+  console.log('0.4.0');
   process.exit(0);
 }
 
 if (flags.has('--help') || flags.has('-h')) {
-  console.log(`MCP Event Intelligence v0.1
+  console.log(`MCP Event Intelligence v0.4
 
 Durable temporal event intelligence for sleeping agents.
 

package/dist/src/composite/matching.d.ts

@@ -4,5 +4,5 @@ export declare function asSourceEvent(clauseId: string, event: CorrelatableEvent
 export declare function expressionSatisfied(definition: CompositeTriggerDefinition, record: TriggerMatchRecord): boolean;
 export declare function semanticSource(record: TriggerMatchRecord): Record<string, unknown>;
 export declare function deterministicKeyForClause(definition: CompositeTriggerDefinition, clauseId: string, event: CorrelatableEvent): string | null;
-export declare function sameEventIdentity(source: Pick<TriggerSourceEvent, 'sourceEventId' | 'serverId'>, event: Pick<CorrelatableEvent, 'sourceEventId' | 'serverId'>): boolean;
+export declare function sameEventIdentity(source: Pick<TriggerSourceEvent, 'sourceEventId' | 'serverId' | 'subscriptionArguments'>, event: Pick<CorrelatableEvent, 'sourceEventId' | 'serverId' | 'subscriptionArguments'>): boolean;
 export declare function matchesCorrelationKey(record: TriggerMatchRecord, key: string | null): boolean;

package/dist/src/composite/matching.js

@@ -9,6 +9,23 @@ function getByPath(source, path) {
     }
     return current;
 }
+function stableValue(value) {
+    if (Array.isArray(value))
+        return value.map(stableValue);
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.keys(value)
+            .sort()
+            .map((key) => [
+            key,
+            stableValue(value[key]),
+        ]));
+    }
+    return value;
+}
+function sameSubscriptionArguments(left, right) {
+    return JSON.stringify(stableValue(left ?? {})) ===
+        JSON.stringify(stableValue(right ?? {}));
+}
 function scalarKey(value) {
     if (typeof value === 'string' ||
         typeof value === 'number' ||
@@ -47,6 +64,7 @@ export function clauseMatches(clause, event) {
     const contractVersion = getByPath(event.data, '_derived.contractVersion');
     return (clause.event === event.name &&
         (!clause.serverId || clause.serverId === event.serverId) &&
+        sameSubscriptionArguments(clause.arguments, event.subscriptionArguments) &&
         (!clause.contractVersion ||
             String(contractVersion ?? '') === String(clause.contractVersion)) &&
         clause.where.every((predicate) => predicateMatches(event, predicate)));
@@ -60,6 +78,7 @@ export function asSourceEvent(clauseId, event) {
         occurredAt: event.occurredAt,
         ...(event.provider ? { provider: event.provider } : {}),
         ...(event.serverId ? { serverId: event.serverId } : {}),
+        subscriptionArguments: event.subscriptionArguments ?? {},
         ...(event.payloadHash ? { payloadHash: event.payloadHash } : {}),
         data: event.data,
     };
@@ -108,7 +127,8 @@ export function deterministicKeyForClause(definition, clauseId, event) {
 }
 export function sameEventIdentity(source, event) {
     return (source.sourceEventId === event.sourceEventId &&
-        (source.serverId ?? null) === (event.serverId ?? null));
+        (source.serverId ?? null) === (event.serverId ?? null) &&
+        sameSubscriptionArguments(source.subscriptionArguments, event.subscriptionArguments));
 }
 export function matchesCorrelationKey(record, key) {
     if (record.correlationKey === null || key === null)

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

@@ -128,6 +128,7 @@ export declare const McpEventOccurrenceSchema: z.ZodObject<{
     timestamp: z.ZodString;
     data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
 export declare const SemanticConditionWireSchema: z.ZodObject<{
     type: z.ZodLiteral<"semantic_boolean">;
@@ -148,6 +149,7 @@ export declare const EventIngestRequestSchema: z.ZodObject<{
         timestamp: z.ZodString;
         data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>;
     context: z.ZodObject<{
         traceId: z.ZodOptional<z.ZodString>;

package/dist/src/intelligenceProtocol/schemas.js

@@ -74,6 +74,7 @@ export const McpEventOccurrenceSchema = z.object({
     timestamp: Timestamp,
     data: z.record(z.string(), z.unknown()),
     cursor: z.string().nullable().optional(),
+    _meta: z.record(z.string(), z.unknown()).optional(),
 });
 export const SemanticConditionWireSchema = z.object({
     type: z.literal('semantic_boolean'),

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

@@ -3,6 +3,7 @@ export declare const TriggerPlanEventSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     event: z.ZodString;
     serverId: z.ZodOptional<z.ZodString>;
+    arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     where: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         path: z.ZodString;
         op: z.ZodLiteral<"eq">;
@@ -58,6 +59,7 @@ export declare const TriggerPlanInputSchema: z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         event: z.ZodString;
         serverId: z.ZodOptional<z.ZodString>;
+        arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         where: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
             path: z.ZodString;
             op: z.ZodLiteral<"eq">;

package/dist/src/intelligenceProtocol/triggerPlanSchemas.js

@@ -6,6 +6,7 @@ export const TriggerPlanEventSchema = z.object({
     id: Id.optional(),
     event: z.string().min(1),
     serverId: Id.optional(),
+    arguments: z.record(z.string(), z.unknown()).default({}),
     where: z.array(StructuredPredicateSchema).default([]),
 }).strict();
 export const TriggerPlanMatchSchema = z.union([

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

@@ -43,6 +43,7 @@ export declare const TriggerClauseSchema: z.ZodObject<{
     event: z.ZodString;
     serverId: z.ZodOptional<z.ZodString>;
     contractVersion: z.ZodOptional<z.ZodString>;
+    arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     where: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         path: z.ZodString;
         op: z.ZodLiteral<"eq">;
@@ -260,6 +261,7 @@ export declare const CompositeTriggerDefinitionSchema: z.ZodObject<{
         event: z.ZodString;
         serverId: z.ZodOptional<z.ZodString>;
         contractVersion: z.ZodOptional<z.ZodString>;
+        arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         where: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
             path: z.ZodString;
             op: z.ZodLiteral<"eq">;
@@ -433,6 +435,7 @@ export declare const CorrelatableEventSchema: z.ZodObject<{
     occurredAt: z.ZodString;
     provider: z.ZodOptional<z.ZodString>;
     serverId: z.ZodOptional<z.ZodString>;
+    subscriptionArguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     payloadHash: z.ZodOptional<z.ZodString>;
     data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strip>;
@@ -444,6 +447,7 @@ export declare const DerivedEventRecordSchema: z.ZodObject<{
         occurredAt: z.ZodString;
         provider: z.ZodOptional<z.ZodString>;
         serverId: z.ZodOptional<z.ZodString>;
+        subscriptionArguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         payloadHash: z.ZodOptional<z.ZodString>;
         data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.core.$strip>;
@@ -480,6 +484,7 @@ export declare const TriggerSourceEventSchema: z.ZodObject<{
     occurredAt: z.ZodString;
     provider: z.ZodOptional<z.ZodString>;
     serverId: z.ZodOptional<z.ZodString>;
+    subscriptionArguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     payloadHash: z.ZodOptional<z.ZodString>;
     data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strip>;
@@ -529,6 +534,7 @@ export declare const TriggerMatchRecordSchema: z.ZodObject<{
         occurredAt: z.ZodString;
         provider: z.ZodOptional<z.ZodString>;
         serverId: z.ZodOptional<z.ZodString>;
+        subscriptionArguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         payloadHash: z.ZodOptional<z.ZodString>;
         data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.core.$strip>>;

package/dist/src/intelligenceProtocol/triggerSchemas.js

@@ -23,6 +23,7 @@ export const TriggerClauseSchema = z.object({
     event: z.string().min(1),
     serverId: Id.optional(),
     contractVersion: z.string().min(1).max(50).optional(),
+    arguments: z.record(z.string(), z.unknown()).default({}),
     where: z.array(StructuredPredicateSchema).default([]),
 });
 const TriggerExpressionSchema = z.discriminatedUnion('kind', [
@@ -333,6 +334,7 @@ export const CorrelatableEventSchema = z.object({
     occurredAt: Timestamp,
     provider: z.string().min(1).optional(),
     serverId: Id.optional(),
+    subscriptionArguments: z.record(z.string(), z.unknown()).default({}),
     payloadHash: z.string().regex(/^[a-f0-9]{64}$/).optional(),
     data: z.record(z.string(), z.unknown()),
 });
@@ -353,6 +355,7 @@ export const TriggerSourceEventSchema = z.object({
     occurredAt: Timestamp,
     provider: z.string().min(1).optional(),
     serverId: Id.optional(),
+    subscriptionArguments: z.record(z.string(), z.unknown()).default({}),
     payloadHash: z.string().regex(/^[a-f0-9]{64}$/).optional(),
     data: z.record(z.string(), z.unknown()),
 });

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

@@ -4,4 +4,5 @@ export declare function mcpOccurrenceToCorrelatableEvent(event: EventOccurrence,
     traceId: string;
     provider?: string;
     serverId?: string;
+    subscriptionArguments?: Record<string, unknown>;
 }): Promise<CorrelatableEvent>;

package/dist/src/mcpEvents/consumer.js

@@ -8,6 +8,7 @@ export async function mcpOccurrenceToCorrelatableEvent(event, input) {
         occurredAt: event.timestamp,
         ...(input.provider ? { provider: input.provider } : {}),
         ...(input.serverId ? { serverId: input.serverId } : {}),
+        subscriptionArguments: input.subscriptionArguments ?? {},
         payloadHash: await sha256Hex(event.data),
         data: event.data,
     });

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

@@ -14,7 +14,5 @@ export type ErpNextEventPoller<TContext = unknown> = (request: ProviderPollReque
 export interface CreateErpNextEventsProviderOptions<TContext = unknown> {
     pollSalesInvoices: ErpNextEventPoller<TContext>;
     pollSalesOrders: ErpNextEventPoller<TContext>;
-    supportedVersions?: string[];
-    instructions?: string;
 }
 export declare function createErpNextEventsProvider<TContext = unknown>(options: CreateErpNextEventsProviderOptions<TContext>): McpEventsProvider<TContext>;

package/dist/src/mcpEvents/erpnextProvider.js

@@ -15,9 +15,6 @@ export function createErpNextEventsProvider(options) {
         throw new Error('ERPNext Events provider requires pollSalesOrders()');
     }
     return createMcpEventsProvider({
-        supportedVersions: options.supportedVersions,
-        instructions: options.instructions ??
-            'ERPNext MCP Events adapter exposing host-owned Sales Invoice and Sales Order changes.',
         events: [
             {
                 descriptor: {

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

@@ -1,11 +1,24 @@
 import type { EventDescriptor, EventOccurrence, JsonRpcRequest, JsonRpcResponse } from '../protocol/types.js';
-export declare const MCP_EVENTS_CAPABILITY_KEY: "io.modelcontextprotocol.experimental/events";
+export declare const MCP_EVENTS_EXTENSION_ID: "io.modelcontextprotocol/events";
+export declare const MCP_EVENTS_CAPABILITY_KEY: "io.modelcontextprotocol/events";
 export declare const MCP_EVENTS_CAPABILITY: Readonly<{
-    status: "draft";
-    designDate: "2026-02-19";
-    methods: readonly ["events/list", "events/poll"];
     listChanged: false;
 }>;
+export declare const MCP_EVENTS_ERROR: Readonly<{
+    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 declare class McpEventsProtocolError extends Error {
+    readonly code: number;
+    readonly data?: unknown;
+    constructor(code: number, message: string, data?: unknown);
+}
 export interface ProviderPollRequest<TContext = unknown> {
     name: string;
     arguments: Record<string, unknown>;
@@ -16,7 +29,7 @@ export interface ProviderPollRequest<TContext = unknown> {
 }
 export interface ProviderPollResult {
     events: EventOccurrence[];
-    cursor: string;
+    cursor: string | null;
     truncated?: boolean;
     hasMore?: boolean;
     nextPollMs?: number;
@@ -27,17 +40,18 @@ export interface McpProviderEvent<TContext = unknown> {
 }
 export interface CreateMcpEventsProviderOptions<TContext = unknown> {
     events: McpProviderEvent<TContext>[];
-    supportedVersions?: string[];
-    instructions?: string;
+    listPageSize?: number;
 }
 export declare function assertJsonSchemaValue(schemaInput: Record<string, unknown>, value: unknown, path?: string): void;
 export declare class McpEventsProvider<TContext = unknown> {
     private readonly events;
-    readonly supportedVersions: string[];
-    readonly instructions: string;
+    private readonly listPageSize;
     constructor(options: CreateMcpEventsProviderOptions<TContext>);
     canHandle(method: string): boolean;
-    listEvents(): EventDescriptor[];
+    listEvents(paramsInput?: unknown): {
+        events: EventDescriptor[];
+        nextCursor?: string;
+    };
     handleRequest(request: JsonRpcRequest, context?: TContext): Promise<JsonRpcResponse>;
     private poll;
     private ok;