fix: reset the relay's request-response waits on progress notifications (#2028)

The web client drives its MCP Client through a two-hop relay
(RemoteClientTransport -> Node backend -> upstream transport). The relay
added two request-response waits that the direct transports don't have —
the backend's RemoteSession.waitForRequestResponse and the browser's
RemoteClientTransport.waitForSseResponse — and both were hardcoded to 60s
and blind to notifications/progress. The SDK Client's own request timeout
resets on progress (resetTimeoutOnProgress, which the Inspector enables),
but the relay's progress-blind waits fire first and shadow it, so a
long-running tool that reports progress is cancelled at 60s on the web
client alone while it completes over the CLI/TUI and other MCP clients.

Reset both relay waits on a notifications/progress whose progressToken
matches the pending request id, mirroring the SDK's resetTimeoutOnProgress.
A shared browser-safe progressTokenOf helper extracts the token. Log
messages (notifications/message, i.e. ctx.info) deliberately do not reset
the deadline, matching the SDK and every other client.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PsmUAZ6aLUAFqenjJKSSRp
Signed-off-by: cliffhall <cliff@futurescale.com>
This commit is contained in:
cliffhall 2026-09-13 21:13:30 -04:00
commit cd31d76371

View file

@ -231,6 +231,74 @@ describe("RemoteSession", () => {
await expect(wait).resolves.toBeUndefined();
});
it("a matching progress notification re-arms the wait past its original deadline (#2028)", async () => {
vi.useFakeTimers();
const session = new RemoteSession("s-progress-reset");
const wait = session.waitForRequestResponse(5, 1000);
// Almost at the deadline, then a progress note for this request arrives.
await vi.advanceTimersByTimeAsync(900);
session.onMessage({
jsonrpc: "2.0",
method: "notifications/progress",
params: { progressToken: 5, progress: 1, total: 10 },
});
// Past the *original* 1000ms deadline: without the re-arm this would have
// already rejected, and the resolve below would be a no-op on a dead wait.
await vi.advanceTimersByTimeAsync(900);
session.onMessage({ jsonrpc: "2.0", id: 5, result: {} });
await expect(wait).resolves.toBeUndefined();
vi.useRealTimers();
});
it("a notifications/message does NOT re-arm the wait (log messages don't extend the deadline, #2028)", async () => {
vi.useFakeTimers();
const session = new RemoteSession("s-message-no-reset");
const wait = session.waitForRequestResponse(6, 1000);
const rejection = expect(wait).rejects.toThrow(/timed out/);
await vi.advanceTimersByTimeAsync(500);
session.onMessage({
jsonrpc: "2.0",
method: "notifications/message",
params: { level: "info", data: { msg: "tick" } },
});
await vi.advanceTimersByTimeAsync(500);
await rejection;
vi.useRealTimers();
});
it("noteRequestProgress is a no-op for an id with no pending wait", () => {
const session = new RemoteSession("s-progress-noop");
expect(() => session.noteRequestProgress(999)).not.toThrow();
});
it("a progress notification on a timeoutMs=0 wait leaves it timerless and it still resolves", async () => {
const session = new RemoteSession("s-progress-notimer");
const wait = session.waitForRequestResponse(7, 0);
session.onMessage({
jsonrpc: "2.0",
method: "notifications/progress",
params: { progressToken: 7, progress: 1 },
});
session.onMessage({ jsonrpc: "2.0", id: 7, result: {} });
await expect(wait).resolves.toBeUndefined();
});
it("a progress notification with a non-token progressToken re-arms nothing", async () => {
vi.useFakeTimers();
const session = new RemoteSession("s-progress-bad-token");
const wait = session.waitForRequestResponse(8, 1000);
const rejection = expect(wait).rejects.toThrow(/timed out/);
// A malformed token (object) must be ignored, not coerced to a key.
session.onMessage({
jsonrpc: "2.0",
method: "notifications/progress",
params: { progressToken: { bad: true }, progress: 1 },
} as unknown as Parameters<RemoteSession["onMessage"]>[0]);
await vi.advanceTimersByTimeAsync(1000);
await rejection;
vi.useRealTimers();
});
it("endSend is a no-op when no send is active", () => {
const session = new RemoteSession("s-endsend-noop");
expect(session.hasActiveSend()).toBe(false);