Skip to content

Commit 131d912

Browse files
cyphercodesclaude
authored andcommitted
fix(everything): replay streamable HTTP events by stream
Ported from modelcontextprotocol#4099 onto v2/main (conflict in streamableHttp.ts resolved against the createApp() refactor; the new files run through prettier). The in-memory event store now resolves the stream of the last event id and replays only later events of that same stream, returning the stream id rather than an event id (modelcontextprotocol#4087). getStreamIdForEventId lets the SDK refuse an unknown event id instead of mapping it to a bogus stream. Co-Authored-By: Claude Opus 5.5 <[email protected]> Signed-off-by: cliffhall <[email protected]>
1 parent 571e2b3 commit 131d912

3 files changed

Lines changed: 150 additions & 33 deletions

File tree

Lines changed: 86 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,86 @@
1+
import { describe, it, expect } from "vitest";
2+
import type { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
3+
import { InMemoryEventStore } from "../transports/inMemoryEventStore.js";
4+
5+
const message = (method: string): JSONRPCMessage => ({
6+
jsonrpc: "2.0",
7+
method,
8+
});
9+
10+
describe("InMemoryEventStore", () => {
11+
it("replays only events from the same stream after the requested event", async () => {
12+
const eventStore = new InMemoryEventStore();
13+
const firstStreamEvent = await eventStore.storeEvent(
14+
"stream-a",
15+
message("notifications/stream-a/first"),
16+
);
17+
const otherStreamEvent = await eventStore.storeEvent(
18+
"stream-b",
19+
message("notifications/stream-b/first"),
20+
);
21+
const secondStreamEvent = await eventStore.storeEvent(
22+
"stream-a",
23+
message("notifications/stream-a/second"),
24+
);
25+
await eventStore.storeEvent(
26+
"stream-b",
27+
message("notifications/stream-b/second"),
28+
);
29+
30+
const replayedEvents: Array<{ eventId: string; message: JSONRPCMessage }> =
31+
[];
32+
const replayedStreamId = await eventStore.replayEventsAfter(
33+
firstStreamEvent,
34+
{
35+
send: async (eventId, replayedMessage) => {
36+
replayedEvents.push({ eventId, message: replayedMessage });
37+
},
38+
},
39+
);
40+
41+
expect(replayedStreamId).toBe("stream-a");
42+
expect(replayedEvents).toEqual([
43+
{
44+
eventId: secondStreamEvent,
45+
message: message("notifications/stream-a/second"),
46+
},
47+
]);
48+
expect(replayedEvents.map(({ eventId }) => eventId)).not.toContain(
49+
otherStreamEvent,
50+
);
51+
});
52+
53+
it("returns undefined without replaying events for unknown event ids", async () => {
54+
const eventStore = new InMemoryEventStore();
55+
await eventStore.storeEvent("stream-a", message("notifications/stream-a"));
56+
57+
const replayedEvents: Array<{ eventId: string; message: JSONRPCMessage }> =
58+
[];
59+
const replayedStreamId = await eventStore.replayEventsAfter(
60+
"unknown-event-id",
61+
{
62+
send: async (eventId, replayedMessage) => {
63+
replayedEvents.push({ eventId, message: replayedMessage });
64+
},
65+
},
66+
);
67+
68+
expect(replayedStreamId).toBeUndefined();
69+
expect(replayedEvents).toEqual([]);
70+
});
71+
72+
it("looks up the stream id for a stored event id", async () => {
73+
const eventStore = new InMemoryEventStore();
74+
const eventId = await eventStore.storeEvent(
75+
"stream-a",
76+
message("notifications/stream-a"),
77+
);
78+
79+
await expect(eventStore.getStreamIdForEventId(eventId)).resolves.toBe(
80+
"stream-a",
81+
);
82+
await expect(
83+
eventStore.getStreamIdForEventId("unknown-event-id"),
84+
).resolves.toBeUndefined();
85+
});
86+
});
Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
import { randomUUID } from "node:crypto";
2+
import type { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
3+
import type {
4+
EventId,
5+
EventStore,
6+
StreamId,
7+
} from "@modelcontextprotocol/sdk/server/streamableHttp.js";
8+
9+
// Simple in-memory event store for SSE resumability.
10+
// Primarily intended for examples and testing, not production use.
11+
export class InMemoryEventStore implements EventStore {
12+
private events: Map<
13+
EventId,
14+
{ streamId: StreamId; message: JSONRPCMessage }
15+
> = new Map();
16+
17+
async storeEvent(
18+
streamId: StreamId,
19+
message: JSONRPCMessage,
20+
): Promise<EventId> {
21+
const eventId = randomUUID();
22+
this.events.set(eventId, { streamId, message });
23+
return eventId;
24+
}
25+
26+
async getStreamIdForEventId(eventId: EventId): Promise<StreamId | undefined> {
27+
return this.events.get(eventId)?.streamId;
28+
}
29+
30+
async replayEventsAfter(
31+
lastEventId: EventId,
32+
{
33+
send,
34+
}: { send: (eventId: EventId, message: JSONRPCMessage) => Promise<void> },
35+
): Promise<StreamId> {
36+
const lastEvent = this.events.get(lastEventId);
37+
if (!lastEvent) {
38+
// The SDK type currently requires a StreamId, but unknown event IDs have
39+
// no stream to resume. Return undefined at runtime to match the intended
40+
// EventStore semantics and Python API behavior.
41+
return undefined as unknown as StreamId;
42+
}
43+
44+
const { streamId } = lastEvent;
45+
let foundLastEvent = false;
46+
47+
for (const [eventId, event] of this.events) {
48+
if (eventId === lastEventId) {
49+
foundLastEvent = true;
50+
continue;
51+
}
52+
53+
if (!foundLastEvent || event.streamId !== streamId) {
54+
continue;
55+
}
56+
57+
await send(eventId, event.message);
58+
}
59+
60+
return streamId;
61+
}
62+
}

‎src/everything/transports/streamableHttp.ts‎

Lines changed: 2 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -7,45 +7,14 @@
77
// a real client, and call its shutdown handler directly; each app has its own
88
// session map. `startStreamableHttpServer()` is what the launcher runs.
99

10-
import {
11-
StreamableHTTPServerTransport,
12-
EventStore,
13-
} from "@modelcontextprotocol/sdk/server/streamableHttp.js";
10+
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
1411
import express, { Express, Request, Response } from "express";
1512
import type { Server } from "node:http";
1613
import { createServer } from "../server/index.js";
1714
import { randomUUID } from "node:crypto";
1815
import cors from "cors";
1916
import { listenOrExit } from "./listen.js";
20-
21-
// Simple in-memory event store for SSE resumability
22-
class InMemoryEventStore implements EventStore {
23-
private events: Map<string, { streamId: string; message: unknown }> =
24-
new Map();
25-
26-
async storeEvent(streamId: string, message: unknown): Promise<string> {
27-
const eventId = randomUUID();
28-
this.events.set(eventId, { streamId, message });
29-
return eventId;
30-
}
31-
32-
async replayEventsAfter(
33-
lastEventId: string,
34-
{ send }: { send: (eventId: string, message: unknown) => Promise<void> },
35-
): Promise<string> {
36-
const entries = Array.from(this.events.entries());
37-
const startIndex = entries.findIndex(([id]) => id === lastEventId);
38-
if (startIndex === -1) return lastEventId;
39-
40-
let lastId: string = lastEventId;
41-
for (let i = startIndex + 1; i < entries.length; i++) {
42-
const [eventId, { message }] = entries[i];
43-
await send(eventId, message);
44-
lastId = eventId;
45-
}
46-
return lastId;
47-
}
48-
}
17+
import { InMemoryEventStore } from "./inMemoryEventStore.js";
4918

5019
/** The Streamable HTTP app, and the handler the launcher installs for SIGINT. */
5120
export type StreamableHttpApp = {

0 commit comments

Comments
 (0)