fix(core): reset request timeout on progress without an onprogress handler

A progress notification for an in-flight request with no registered
onprogress handler was treated as an unknown-token error and returned
before the timeout reset ran, so resetTimeoutOnProgress did nothing
unless onprogress was also provided (#2076). Reset the timeout for any
in-flight request, and only report an unknown token when neither a
progress handler nor a response handler is associated with the id.

Adds a regression test covering resetTimeoutOnProgress without onprogress.

Author: minglong51

.changeset/fix-reset-timeout-without-onprogress.md

@@ -0,0 +1,5 @@
+---
+'@modelcontextprotocol/core': patch
+---
+
+Fix `resetTimeoutOnProgress` so it works without an `onprogress` handler. Previously, a progress notification for an in-flight request that had no registered `onprogress` handler was treated as an unknown-token error and returned before the timeout was reset, so `resetTimeoutOnProgress: true` silently did nothing unless `onprogress` was also provided. The request timeout now resets on progress regardless of whether an `onprogress` handler is registered, and a notification is only reported as an unknown token when neither a progress handler nor an in-flight request is associated with it.

packages/core/src/shared/protocol.ts

@@ -695,14 +695,21 @@ export abstract class Protocol<ContextT extends BaseContext> {
         const messageId = Number(progressToken);
 
         const handler = this._progressHandlers.get(messageId);
-        if (!handler) {
+        const responseHandler = this._responseHandlers.get(messageId);
+        const timeoutInfo = this._timeoutInfo.get(messageId);
+
+        // A progress notification is only "unknown" when nothing is associated with
+        // its token — no `onprogress` handler AND no in-flight request. A request
+        // that is in-flight but registered no `onprogress` handler is still known:
+        // `resetTimeoutOnProgress` is documented to work on its own (#2076).
+        if (!handler && !responseHandler) {
             this._onerror(new Error(`Received a progress notification for an unknown token: ${JSON.stringify(notification)}`));
             return;
         }
 
-        const responseHandler = this._responseHandlers.get(messageId);
-        const timeoutInfo = this._timeoutInfo.get(messageId);
-
+        // Reset the request timeout on progress when requested. This must run even
+        // when no `onprogress` handler was registered (#2076) — hence it is no longer
+        // gated behind the handler lookup above.
         if (timeoutInfo && responseHandler && timeoutInfo.resetTimeoutOnProgress) {
             try {
                 this._resetTimeout(messageId);
@@ -716,7 +723,10 @@ export abstract class Protocol<ContextT extends BaseContext> {
             }
         }
 
-        handler(params);
+        // Deliver to the progress handler if one was registered.
+        if (handler) {
+            handler(params);
+        }
     }
 
     private _onresponse(response: JSONRPCResponse | JSONRPCErrorResponse): void {

packages/core/test/shared/protocol.test.ts

@@ -556,6 +556,52 @@ describe('protocol tests', () => {
             await expect(requestPromise).resolves.toEqual({ result: 'success' });
         });
 
+        test('should reset timeout on progress when resetTimeoutOnProgress is set without an onprogress handler (#2076)', async () => {
+            await protocol.connect(transport);
+            const request = { method: 'example', params: {} };
+            const mockSchema: ZodType<{ result: string }> = z.object({
+                result: z.string()
+            });
+            const onErrorMock = vi.fn();
+            protocol.onerror = onErrorMock;
+
+            // resetTimeoutOnProgress requested WITHOUT an onprogress callback.
+            const requestPromise = testRequest(protocol, request, mockSchema, {
+                timeout: 1000,
+                resetTimeoutOnProgress: true
+            });
+
+            // Just before the original deadline, a progress notification arrives.
+            vi.advanceTimersByTime(800);
+            if (transport.onmessage) {
+                transport.onmessage({
+                    jsonrpc: '2.0',
+                    method: 'notifications/progress',
+                    params: {
+                        progressToken: 0,
+                        progress: 50,
+                        total: 100
+                    }
+                });
+            }
+            await Promise.resolve();
+
+            // A known request with no progress handler must NOT raise "unknown token".
+            expect(onErrorMock).not.toHaveBeenCalled();
+
+            // The timer was reset: advancing past the ORIGINAL deadline must not time out.
+            vi.advanceTimersByTime(800);
+            if (transport.onmessage) {
+                transport.onmessage({
+                    jsonrpc: '2.0',
+                    id: 0,
+                    result: { result: 'success' }
+                });
+            }
+            await Promise.resolve();
+            await expect(requestPromise).resolves.toEqual({ result: 'success' });
+        });
+
         test('should respect maxTotalTimeout', async () => {
             await protocol.connect(transport);
             const request = { method: 'example', params: {} };