If you run a service that an agent should react to, such as a deploy finishing, a ticket opening or an alert firing, you can offer it as an event type in the MCP Events extension. This guide builds that in one file of plain Node, with no SDK, then adds a client that polls the server and picks up where it left off after a restart.
MCP Events is in beta. The official docs list SEP-3415 as Final and the extension as Beta, and Peter Alexander said on 21 November, NZ time, that the beta is there so the working group can fix spec issues and stabilise it, which I covered in my report on the announcement. Method names, error codes and fields can still change. I checked this code against the beta spec in the ext-events repository on 21 November 2026, NZ time. The official TypeScript SDK pull request for Events was still open on 20 November, so nothing below uses an SDK.
| Item | Detail |
|---|---|
| Who it’s for | Developers who run a service and want an agent to react to what happens in it |
| You end up with | An MCP endpoint that advertises Events, lists one event type and answers polls, plus a client that resumes from a saved cursor |
| You need | Node 20 or later (I ran Node 22) and curl. No packages to install |
| Delivery mode | Poll only |
| Protocol | Revision 2026-07-28 over Streamable HTTP, with JSON responses |
Why start with poll
The Events docs say an event type can offer poll, push or webhook delivery, and none of the three is mandatory. Poll is the smallest to build because the server holds no state for each client. Every events/poll request carries the event name, the arguments and the cursor, and the server answers from those alone. There’s no subscribe step. The first poll with a null cursor is the subscription.
Poll suits clients you write yourself, serverless hosts and tests. OpenAI’s docs describe ChatGPT’s MCP Events support as webhook delivery, so a poll-only server isn’t the one to point it at. The last section covers what changes when you add webhook.
Step 1: Describe the event type
An event type is a name, a description, the delivery modes it supports, a JSON Schema for the subscription arguments (inputSchema) and a JSON Schema for the data each occurrence carries (payloadSchema). This one is deploy.finished, which a client can filter by service and by status.
const EVENT_TYPES = [
{
name: "deploy.finished",
description: "Fires when a deploy finishes, successfully or not",
delivery: ["poll"],
inputSchema: {
type: "object",
properties: {
service: { type: "string", description: "Only deploys of this service" },
status: { type: "string", enum: ["succeeded", "failed"] },
},
additionalProperties: false,
},
payloadSchema: {
type: "object",
properties: {
deployId: { type: "string" },
service: { type: "string" },
status: { type: "string", enum: ["succeeded", "failed"] },
url: { type: "string", description: "Link to the deploy, fetch details with a tool" },
},
required: ["deployId", "service", "status"],
},
},
];
Keep the payload small. The docs say servers should send enough to identify and triage an event and let the client fetch the full content with tools, so this payload carries a link to the deploy and no build log. Evolve both schemas additively: add optional fields, and don’t rename or retype existing ones. The spec says a breaking change belongs under a new event name.
Step 2: Keep a log and mint cursors
A cursor is an opaque string that the server chooses, and clients only store it and send it back. This server’s cursor encodes a run ID plus the sequence number of the last occurrence the client has seen. The log is an array in memory, capped at 200 entries. That makes this an emit-only event type, and the spec says those are at-most-once across server restarts, because the buffer and its cursors don’t survive one.
Set eventId to the upstream system’s own stable ID. Here it’s the deploy ID, so one deploy can never show up under two IDs, and a client can discard duplicates.
let nextSeq = 1;
const log = []; // { seq, occurrence }
function emit(data) {
const seq = nextSeq++;
log.push({ seq, occurrence: {
eventId: data.deployId, // the upstream's stable ID, so clients can deduplicate
name: "deploy.finished",
timestamp: new Date().toISOString(),
data,
}});
if (log.length > MAX_LOG) log.shift();
}
const RUN = Date.now().toString(36); // changes on every restart
const encodeCursor = (seq) => Buffer.from(`v1:${RUN}:${seq}`).toString("base64url");
Step 3: Answer the discovery calls
server/discover returns the protocol versions the server supports and its capabilities. Events is advertised as a key under capabilities.extensions. An empty settings object declares support without listChanged notifications, which suits a list that never changes while the server runs. events/list returns the event types from step 1. The spec says every result this extension defines carries resultType: "complete".
// server/discover
{ supportedVersions: ["2026-07-28"],
capabilities: { extensions: { "io.modelcontextprotocol/events": {} } },
_meta: { "io.modelcontextprotocol/serverInfo": { name: "deploy-events", version: "0.1.0" } } }
// events/list
{ events: EVENT_TYPES }
Step 4: Check the headers
Over Streamable HTTP, every POST carries an MCP-Protocol-Version header and an Mcp-Method header. Requests that name an event, events/poll among them, also carry Mcp-Name, set to the event name. Each header has to match the JSON body, and a mismatch gets HTTP 400 with error -32020, HeaderMismatch. The same page says a server running locally should bind to 127.0.0.1 and validate the Origin header, which the full file does.
const meta = params._meta ?? {};
const version = meta["io.modelcontextprotocol/protocolVersion"];
if (req.headers["mcp-protocol-version"] !== version || version !== PROTOCOL)
return send(400, rpcError(id, E.HeaderMismatch, "Header mismatch: MCP-Protocol-Version"));
if (req.headers["mcp-method"] !== method)
return send(400, rpcError(id, E.HeaderMismatch, "Header mismatch: Mcp-Method"));
if (method.startsWith("events/") && method !== "events/list" && req.headers["mcp-name"] !== params.name)
return send(400, rpcError(id, E.HeaderMismatch, "Header mismatch: Mcp-Name must equal params.name"));
Step 5: Serve events/poll
events/poll holds most of the logic. The handler works through these checks in order:
- An unknown event name gets
NotFound(-32023). Arguments that fail theinputSchemagetInvalidParams(-32602). - A
nullor missing cursor means start from now. The server returns no events and a fresh cursor. - Otherwise it reads forward from the cursor, keeps the occurrences that match the arguments, and returns at most
maxEventsof them (the server caps this at 50). If more are waiting, it setshasMore: true. - The cursor advances past occurrences that didn’t match the filter too, so a quiet filter never leaves the client holding a stale position.
- A cursor that points at events the server no longer has isn’t an error. The server resumes from the oldest event it still holds, or from now, and sets
truncated: true. The spec says poll never answers this with a JSON-RPC error. maxAgeMssets a floor on how old a replayed event can be. Anything older is skipped, and the reply saystruncated: true.nextPollMstells the client how long to wait. It’s 5,000 here, and 0 whenhasMoreis true.
function handlePoll(id, params) {
const type = EVENT_TYPES.find((t) => t.name === params.name);
if (!type) return [200, rpcError(id, E.NotFound, "NotFound", { kind: "event" })];
const bad = validateArgs(type.inputSchema, params.arguments);
if (bad) return [200, rpcError(id, E.InvalidParams, `Invalid arguments: ${bad}`)];
const head = nextSeq - 1;
if (params.cursor == null) // start from now
return [200, rpcResult(id, { events: [], cursor: encodeCursor(head), truncated: false, hasMore: false, nextPollMs: 5000 })];
const decoded = decodeCursor(params.cursor);
if (!decoded) return [200, rpcError(id, E.InvalidParams, "Invalid cursor")];
let after = decoded.seq;
let truncated = false;
const oldest = log.length ? log[0].seq : nextSeq;
if (decoded.run !== RUN) { after = head; truncated = true; } // minted before a restart
else if (after < oldest - 1) { after = oldest - 1; truncated = true; } // fell off the front of the log
const floorTime = params.maxAgeMs ? Date.now() - params.maxAgeMs : 0;
const maxEvents = Math.min(params.maxEvents ?? 50, 50);
const events = [];
let last = after, hasMore = false;
for (const { seq, occurrence } of log) {
if (seq <= after) continue;
if (events.length >= maxEvents) { hasMore = true; break; }
last = seq; // advance past everything we looked at, matching or not
if (Date.parse(occurrence.timestamp) < floorTime) { truncated = true; continue; }
const a = params.arguments ?? {};
if (a.service && occurrence.data.service !== a.service) continue;
if (a.status && occurrence.data.status !== a.status) continue;
events.push(occurrence);
}
return [200, rpcResult(id, { events, cursor: encodeCursor(last), truncated, hasMore, nextPollMs: hasMore ? 0 : 5000 })];
}


Step 6: Put it together and run it
Save this as server.mjs. It adds the HTTP plumbing around the pieces above, a small argument validator, and a POST /emit hook that fakes upstream deploys so you can test with curl. The hook isn’t part of MCP. The validator checks types and enums only, so use a real JSON Schema validator in production.
// Minimal MCP Events server: poll delivery only, no dependencies. Node 20+.
// Targets protocol revision 2026-07-28 and the io.modelcontextprotocol/events extension (beta).
import { createServer } from "node:http";
const PROTOCOL = "2026-07-28";
const EXT = "io.modelcontextprotocol/events";
const MAX_LOG = 200; // how many occurrences we keep for replay
// Error codes from SEP-3415 and the transport spec.
const E = { InvalidParams: -32602, MethodNotFound: -32601, HeaderMismatch: -32020, NotFound: -32023, Unsupported: -32026 };
// 1. The event log. Position = index in the log, so a cursor is just an offset.
let nextSeq = 1; // sequence number of the next occurrence
const log = []; // { seq, occurrence }
function emit(data) {
const seq = nextSeq++;
log.push({
seq,
occurrence: {
eventId: data.deployId, // use the upstream's stable ID so clients can deduplicate
name: "deploy.finished",
timestamp: new Date().toISOString(),
data,
},
});
if (log.length > MAX_LOG) log.shift();
}
// Cursors are opaque to clients. Ours encodes this server run's ID plus the last seq the client has seen.
// The run ID lets us spot a cursor minted before a restart, when the in-memory log was lost.
const RUN = Date.now().toString(36);
const encodeCursor = (seq) => Buffer.from(`v1:${RUN}:${seq}`).toString("base64url");
function decodeCursor(c) {
const m = /^v1:([a-z0-9]+):(\d+)$/.exec(Buffer.from(String(c), "base64url").toString());
return m ? { run: m[1], seq: Number(m[2]) } : null;
}
// 2. The event type this server offers.
const EVENT_TYPES = [
{
name: "deploy.finished",
description: "Fires when a deploy finishes, successfully or not",
delivery: ["poll"],
inputSchema: {
type: "object",
properties: {
service: { type: "string", description: "Only deploys of this service" },
status: { type: "string", enum: ["succeeded", "failed"] },
},
additionalProperties: false,
},
payloadSchema: {
type: "object",
properties: {
deployId: { type: "string" },
service: { type: "string" },
status: { type: "string", enum: ["succeeded", "failed"] },
url: { type: "string", description: "Link to the deploy, fetch details with a tool" },
},
required: ["deployId", "service", "status"],
},
},
];
// 3. JSON-RPC plumbing.
const rpcError = (id, code, message, data) => ({ jsonrpc: "2.0", id, error: { code, message, ...(data && { data }) } });
const rpcResult = (id, result) => ({ jsonrpc: "2.0", id, result: { resultType: "complete", ...result } });
function validateArgs(schema, args = {}) {
for (const [k, v] of Object.entries(args)) {
const p = schema.properties[k];
if (!p) return `unknown argument "${k}"`;
if (p.type === "string" && typeof v !== "string") return `"${k}" must be a string`;
if (p.enum && !p.enum.includes(v)) return `"${k}" must be one of ${p.enum.join(", ")}`;
}
return null;
}
function handlePoll(id, params) {
const type = EVENT_TYPES.find((t) => t.name === params.name);
if (!type) return [200, rpcError(id, E.NotFound, "NotFound", { kind: "event" })];
const bad = validateArgs(type.inputSchema, params.arguments);
if (bad) return [200, rpcError(id, E.InvalidParams, `Invalid arguments: ${bad}`)];
const head = nextSeq - 1;
// cursor null or absent means "start from now": no events, fresh cursor.
if (params.cursor == null) {
return [200, rpcResult(id, { events: [], cursor: encodeCursor(head), truncated: false, hasMore: false, nextPollMs: 5000 })];
}
const decoded = decodeCursor(params.cursor);
if (!decoded) return [200, rpcError(id, E.InvalidParams, "Invalid cursor")];
let after = decoded.seq;
// Two ways a cursor can point at events we no longer have. Both reset the client and say so with truncated.
let truncated = false;
const oldest = log.length ? log[0].seq : nextSeq;
if (decoded.run !== RUN) {
after = head; // minted before a restart: the old log is gone
truncated = true;
} else if (after < oldest - 1) {
after = oldest - 1; // fell off the front of the retained log
truncated = true;
}
// Bounded replay: honour maxAgeMs by dropping older occurrences.
const floorTime = params.maxAgeMs ? Date.now() - params.maxAgeMs : 0;
const maxEvents = Math.min(params.maxEvents ?? 50, 50);
const events = [];
let last = after;
let hasMore = false;
for (const { seq, occurrence } of log) {
if (seq <= after) continue;
if (events.length >= maxEvents) {
hasMore = true;
break;
}
last = seq; // advance past everything we looked at, matching or not
if (Date.parse(occurrence.timestamp) < floorTime) {
truncated = true; // we skipped something because it was too old
continue;
}
const a = params.arguments ?? {};
if (a.service && occurrence.data.service !== a.service) continue;
if (a.status && occurrence.data.status !== a.status) continue;
events.push(occurrence);
}
return [200, rpcResult(id, { events, cursor: encodeCursor(last), truncated, hasMore, nextPollMs: hasMore ? 0 : 5000 })];
}
// 4. The MCP endpoint.
const server = createServer(async (req, res) => {
const send = (status, body) => {
res.writeHead(status, { "content-type": "application/json" });
res.end(JSON.stringify(body));
};
// Test hook: not part of MCP. Lets you fake upstream deploys with curl.
if (req.method === "POST" && req.url === "/emit") {
let raw = "";
for await (const c of req) raw += c;
const d = JSON.parse(raw || "{}");
emit({ deployId: d.deployId ?? `dep_${Date.now()}`, service: d.service ?? "web", status: d.status ?? "succeeded", url: d.url ?? "https://ci.example.com/deploys/1" });
return send(202, { ok: true, head: nextSeq - 1 });
}
if (req.method !== "POST" || req.url !== "/mcp") return send(404, rpcError(null, E.MethodNotFound, "Not found"));
// Spec: validate Origin to stop DNS rebinding. Browsers send it, curl and SDKs usually don't.
const origin = req.headers.origin;
if (origin && !/^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin)) return send(403, rpcError(null, -32000, "Forbidden origin"));
let msg;
try {
let raw = "";
for await (const c of req) raw += c;
msg = JSON.parse(raw);
} catch {
return send(400, rpcError(null, -32700, "Parse error"));
}
const { id, method, params = {} } = msg;
// Required headers must exist and match the body (HeaderMismatch, HTTP 400).
const meta = params._meta ?? {};
const version = meta["io.modelcontextprotocol/protocolVersion"];
if (req.headers["mcp-protocol-version"] !== version || version !== PROTOCOL)
return send(400, rpcError(id, E.HeaderMismatch, `Header mismatch: MCP-Protocol-Version must be ${PROTOCOL} and match _meta`));
if (req.headers["mcp-method"] !== method) return send(400, rpcError(id, E.HeaderMismatch, "Header mismatch: Mcp-Method"));
if (method.startsWith("events/") && method !== "events/list" && req.headers["mcp-name"] !== params.name)
return send(400, rpcError(id, E.HeaderMismatch, "Header mismatch: Mcp-Name must equal params.name"));
switch (method) {
case "server/discover":
return send(200, rpcResult(id, {
supportedVersions: [PROTOCOL],
capabilities: { extensions: { [EXT]: {} } }, // no listChanged: our list is static
_meta: { "io.modelcontextprotocol/serverInfo": { name: "deploy-events", version: "0.1.0" } },
}));
case "events/list":
return send(200, rpcResult(id, { events: EVENT_TYPES }));
case "events/poll": {
const [status, body] = handlePoll(id, params);
return send(status, body);
}
case "events/stream": // we only offer poll, so say which mode is missing
case "events/subscribe":
return send(200, rpcError(id, E.Unsupported, "Unsupported", { feature: "deliveryMode", value: method === "events/stream" ? "push" : "webhook" }));
default:
return send(404, rpcError(id, E.MethodNotFound, "Method not found"));
}
});
// Bind to localhost only, as the spec advises for local servers.
server.listen(3000, "127.0.0.1", () => console.log("MCP Events server on http://127.0.0.1:3000/mcp"));
Start it with node server.mjs. In a second terminal, define a helper that sends the headers and the per-request _meta that revision 2026-07-28 requires, then call each method:
M='"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"curl","version":"1"},"io.modelcontextprotocol/clientCapabilities":{}}'
call() { # method, Mcp-Name (or ""), extra params
curl -s -X POST http://127.0.0.1:3000/mcp \
-H 'content-type: application/json' -H 'accept: application/json, text/event-stream' \
-H 'MCP-Protocol-Version: 2026-07-28' -H "Mcp-Method: $1" ${2:+-H "Mcp-Name: $2"} \
-d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"$1\",\"params\":{$3$M}}"; echo; }
call server/discover "" ""
call events/list "" ""
call events/poll deploy.finished '"name":"deploy.finished","arguments":{"status":"failed"},"cursor":null,'
The first poll comes back empty with a cursor, which is the subscription starting from now. Emit two deploys, then poll again with that cursor (the value below is from my run; use yours):
curl -s -X POST localhost:3000/emit -d '{"deployId":"dep_1","service":"web","status":"failed"}'
curl -s -X POST localhost:3000/emit -d '{"deployId":"dep_2","service":"api","status":"succeeded"}'
call events/poll deploy.finished '"name":"deploy.finished","arguments":{"status":"failed"},"cursor":"djE6bXdwZzZjc286MA",'
The reply holds dep_1 only, because dep_2 succeeded and the subscription asked for failures. Its cursor has moved past both:
{"jsonrpc":"2.0","id":1,"result":{"resultType":"complete","events":[{"eventId":"dep_1","name":"deploy.finished","timestamp":"2026-11-20T20:44:30.578Z","data":{"deployId":"dep_1","service":"web","status":"failed","url":"https://ci.example.com/deploys/1"}}],"cursor":"djE6bXdwZzZjc286Mg","truncated":false,"hasMore":false,"nextPollMs":5000}}
Step 7: Write a client that survives restarts
Save this as client.mjs. It declares the extension in its per-request capabilities and checks that the server advertises Events before it sends any events/* request, which the spec requires. It runs one poll loop for one subscription, drains a backlog without waiting when hasMore is true, keeps its own one-second floor under nextPollMs, skips any eventId it has seen, and writes the cursor to cursor.json after it handles each batch.
// Tiny poll client for the server in server.mjs. Node 20+, no dependencies.
import { readFileSync, writeFileSync } from "node:fs";
const URL_ = process.env.MCP_URL ?? "http://127.0.0.1:3000/mcp";
const PROTOCOL = "2026-07-28";
const STATE = "./cursor.json"; // persist the cursor so a restart resumes
const FLOOR_MS = 1000; // never poll faster than this, whatever the server says
let id = 0;
async function rpc(method, params = {}) {
const headers = {
"content-type": "application/json",
accept: "application/json, text/event-stream",
"mcp-protocol-version": PROTOCOL,
"mcp-method": method,
};
if (method === "events/poll") headers["mcp-name"] = params.name;
const res = await fetch(URL_, {
method: "POST",
headers,
body: JSON.stringify({
jsonrpc: "2.0",
id: ++id,
method,
params: {
...params,
_meta: {
"io.modelcontextprotocol/protocolVersion": PROTOCOL,
"io.modelcontextprotocol/clientInfo": { name: "poll-demo", version: "0.1.0" },
"io.modelcontextprotocol/clientCapabilities": { extensions: { "io.modelcontextprotocol/events": {} } },
},
},
}),
});
const body = await res.json();
if (body.error) throw new Error(`${method}: ${body.error.code} ${body.error.message}`);
return body.result;
}
// Only talk to servers that advertise the extension.
const disco = await rpc("server/discover");
if (!disco.capabilities?.extensions?.["io.modelcontextprotocol/events"]) throw new Error("Server doesn't offer MCP Events");
const { events: types } = await rpc("events/list");
const type = types.find((t) => t.name === "deploy.finished");
if (!type?.delivery.includes("poll")) throw new Error("deploy.finished can't be polled");
const args = process.argv[2] ? JSON.parse(process.argv[2]) : { status: "failed" };
let cursor = null;
try { cursor = JSON.parse(readFileSync(STATE, "utf8")).cursor ?? null; } catch {}
const seen = new Set(); // dedupe by eventId (in memory here, use durable storage for real)
for (;;) {
const r = await rpc("events/poll", { name: type.name, arguments: args, cursor, maxAgeMs: 300000 });
if (r.truncated) console.warn("Gap: older events were skipped. Re-read authoritative state with tools if it matters.");
for (const e of r.events) {
if (seen.has(e.eventId)) continue;
seen.add(e.eventId);
// Payloads are untrusted data. Print or hand them to your agent runtime, never run them.
console.log("event:", e.eventId, JSON.stringify(e.data));
}
cursor = r.cursor;
writeFileSync(STATE, JSON.stringify({ cursor })); // persist after handling the batch
if (!r.hasMore) await new Promise((ok) => setTimeout(ok, Math.max(r.nextPollMs ?? 0, FLOOR_MS)));
}
Saving the cursor after handling gives at-least-once delivery. If the process dies between handling and saving, the batch comes back on restart, which is why the eventId check matters. The client keeps its seen IDs in memory, so a real one needs durable storage for them. It prints the event data and does nothing else with it. The docs say event payloads are untrusted data that can carry prompt injection, so treat them like tool results and sanitise them before they reach a model.

Check that it works
Run these in order, with the server running. Each one tests a promise from the spec.
- Start the client with
node client.mjs '{"status":"failed"}'. Emit one failed and one succeeded deploy. Only the failed one prints. - Stop the client, emit three failed deploys, and start it again. The three print once each, and nothing older repeats, because the client resumed from
cursor.json. - Stop the client, emit 120 failed deploys, and start it again. All 120 print without the client waiting between batches. The server returns them 50 at a time and sets
hasMore: trueuntil the last batch. - Stop the client, emit 250 failed deploys, and start it again. The client prints the gap warning and resumes from the oldest event the server kept,
dep_c51in my run, because the log holds 200. - Restart the server while the client runs. The next poll carries a cursor from the old run, so the reply says
truncated: trueand the client prints the gap warning. Anything emitted before the client’s next poll is lost, which is the at-most-once behaviour the spec describes for emit-only events.
I ran all five on Node 22 on 21 November 2026, NZ time, and each did what’s described.
When something fails
| Symptom | Cause | Fix |
|---|---|---|
| HTTP 400 and error -32020 | A required header is missing, or it differs from the body | Send MCP-Protocol-Version, Mcp-Method and, for event requests, Mcp-Name, and make each match the body |
| Error -32602 | The arguments don’t fit the inputSchema, or the cursor isn’t one this server minted | Check the arguments against the schema from events/list before polling |
| Error -32023 | The event name isn’t one the server lists | Call events/list and copy the name |
| Error -32026 on events/stream or events/subscribe | The event type doesn’t offer that delivery mode | Use poll, or add the mode to the event type and build it |
| Error -32601 | The server doesn’t implement the method, or doesn’t offer Events at all | Check server/discover for the extension key before sending events/* requests |
| The same event twice | Delivery is at-least-once, and a crash between handling and saving replays a batch | Deduplicate by eventId, in storage that survives a restart |
| Events missing after a server restart | The log lives in memory, so a restart empties it | Back the log with a durable store, or an upstream that has its own cursor |
| A tight request loop | The client ignored the interval, or polled on every response | Wait nextPollMs unless hasMore is true, and keep a floor of one second |
Before you put it on a network
This server has no authentication and listens on localhost only. Don’t expose it as it stands. The docs say a server checks permission when a subscription is made, checks again at delivery, and ends the subscription if access is revoked. For poll, the SEP says that ending arrives as a JSON-RPC error on the client’s next poll. Receiving an event never authorises the agent to act: its follow-up tool calls go through normal MCP authorisation.
Adding push or webhook
Push uses events/stream, a long-lived request that delivers events as notifications. Webhook uses events/subscribe. The client sends an https callback URL and a signing secret that starts with whsec_, the server verifies the endpoint before it delivers anything, and each delivery is signed with Standard Webhooks. The server grants a lifetime, and the client refreshes the subscription before it expires. The SEP says unauthenticated servers can offer poll and push but not webhook, because a webhook subscription is keyed to an authenticated principal. Both modes are in the beta spec’s sections on push-based and webhook-based delivery, and the parent report has a table comparing all three.
Pages to keep
- The official Events page, for the overview and the implementation guide
- The beta spec in ext-events, which is the text to check this code against when it changes
- SEP-3415, for the reasoning behind each choice
- The Streamable HTTP transport spec, for headers, origin checks and status codes
- The server/discover spec
- My report on the beta announcement
Discover more from Sulat AI & Tech News
Subscribe to get the latest posts sent to your email.




