fix: respect custom timeouts in navigate tools (#865)

Closes #863

Author: OrKoN

src/McpContext.ts

@@ -727,7 +727,10 @@ export class McpContext implements Context {
     return new WaitForHelper(page, cpuMultiplier, networkMultiplier);
   }
 
-  waitForEventsAfterAction(action: () => Promise<unknown>): Promise<void> {
+  waitForEventsAfterAction(
+    action: () => Promise<unknown>,
+    options?: {timeout?: number},
+  ): Promise<void> {
     const page = this.getSelectedPage();
     const cpuMultiplier = this.getCpuThrottlingRate();
     const networkMultiplier = getNetworkMultiplierFromString(
@@ -738,7 +741,7 @@ export class McpContext implements Context {
       cpuMultiplier,
       networkMultiplier,
     );
-    return waitForHelper.waitForEventsAfterAction(action);
+    return waitForHelper.waitForEventsAfterAction(action, options);
   }
 
   getNetworkRequestStableId(request: HTTPRequest): number {

src/WaitForHelper.ts

@@ -125,12 +125,13 @@ export class WaitForHelper {
 
   async waitForEventsAfterAction(
     action: () => Promise<unknown>,
+    options?: {timeout?: number},
   ): Promise<void> {
     const navigationFinished = this.waitForNavigationStarted()
       .then(navigationStated => {
         if (navigationStated) {
           return this.#page.waitForNavigation({
-            timeout: this.#navigationTimeout,
+            timeout: options?.timeout ?? this.#navigationTimeout,
             signal: this.#abortController.signal,
           });
         }

src/tools/ToolDefinition.ts

@@ -131,7 +131,10 @@ export type Context = Readonly<{
     data: Uint8Array<ArrayBufferLike>,
     filename: string,
   ): Promise<{filename: string}>;
-  waitForEventsAfterAction(action: () => Promise<unknown>): Promise<void>;
+  waitForEventsAfterAction(
+    action: () => Promise<unknown>,
+    options?: {timeout?: number},
+  ): Promise<void>;
   waitForTextOnPage(text: string, timeout?: number): Promise<Element>;
   getDevToolsData(): Promise<DevToolsData>;
   /**

src/tools/pages.ts

@@ -98,11 +98,14 @@ export const newPage = defineTool({
   handler: async (request, response, context) => {
     const page = await context.newPage(request.params.background);
 
-    await context.waitForEventsAfterAction(async () => {
-      await page.goto(request.params.url, {
-        timeout: request.params.timeout,
-      });
-    });
+    await context.waitForEventsAfterAction(
+      async () => {
+        await page.goto(request.params.url, {
+          timeout: request.params.timeout,
+        });
+      },
+      {timeout: request.params.timeout},
+    );
 
     response.setIncludePages(true);
   },
@@ -181,62 +184,67 @@ export const navigatePage = defineTool({
     page.on('dialog', dialogHandler);
 
     try {
-      await context.waitForEventsAfterAction(async () => {
-        switch (request.params.type) {
-          case 'url':
-            if (!request.params.url) {
-              throw new Error('A URL is required for navigation of type=url.');
-            }
-            try {
-              await page.goto(request.params.url, options);
-              response.appendResponseLine(
-                `Successfully navigated to ${request.params.url}.`,
-              );
-            } catch (error) {
-              response.appendResponseLine(
-                `Unable to navigate in the  selected page: ${error.message}.`,
-              );
-            }
-            break;
-          case 'back':
-            try {
-              await page.goBack(options);
-              response.appendResponseLine(
-                `Successfully navigated back to ${page.url()}.`,
-              );
-            } catch (error) {
-              response.appendResponseLine(
-                `Unable to navigate back in the selected page: ${error.message}.`,
-              );
-            }
-            break;
-          case 'forward':
-            try {
-              await page.goForward(options);
-              response.appendResponseLine(
-                `Successfully navigated forward to ${page.url()}.`,
-              );
-            } catch (error) {
-              response.appendResponseLine(
-                `Unable to navigate forward in the selected page: ${error.message}.`,
-              );
-            }
-            break;
-          case 'reload':
-            try {
-              await page.reload({
-                ...options,
-                ignoreCache: request.params.ignoreCache,
-              });
-              response.appendResponseLine(`Successfully reloaded the page.`);
-            } catch (error) {
-              response.appendResponseLine(
-                `Unable to reload the selected page: ${error.message}.`,
-              );
-            }
-            break;
-        }
-      });
+      await context.waitForEventsAfterAction(
+        async () => {
+          switch (request.params.type) {
+            case 'url':
+              if (!request.params.url) {
+                throw new Error(
+                  'A URL is required for navigation of type=url.',
+                );
+              }
+              try {
+                await page.goto(request.params.url, options);
+                response.appendResponseLine(
+                  `Successfully navigated to ${request.params.url}.`,
+                );
+              } catch (error) {
+                response.appendResponseLine(
+                  `Unable to navigate in the  selected page: ${error.message}.`,
+                );
+              }
+              break;
+            case 'back':
+              try {
+                await page.goBack(options);
+                response.appendResponseLine(
+                  `Successfully navigated back to ${page.url()}.`,
+                );
+              } catch (error) {
+                response.appendResponseLine(
+                  `Unable to navigate back in the selected page: ${error.message}.`,
+                );
+              }
+              break;
+            case 'forward':
+              try {
+                await page.goForward(options);
+                response.appendResponseLine(
+                  `Successfully navigated forward to ${page.url()}.`,
+                );
+              } catch (error) {
+                response.appendResponseLine(
+                  `Unable to navigate forward in the selected page: ${error.message}.`,
+                );
+              }
+              break;
+            case 'reload':
+              try {
+                await page.reload({
+                  ...options,
+                  ignoreCache: request.params.ignoreCache,
+                });
+                response.appendResponseLine(`Successfully reloaded the page.`);
+              } catch (error) {
+                response.appendResponseLine(
+                  `Unable to reload the selected page: ${error.message}.`,
+                );
+              }
+              break;
+          }
+        },
+        {timeout: request.params.timeout},
+      );
     } finally {
       page.off('dialog', dialogHandler);
       if (initScriptId) {

tests/tools/pages.test.ts

@@ -8,6 +8,7 @@ import assert from 'node:assert';
 import {describe, it} from 'node:test';
 
 import type {Dialog} from 'puppeteer-core';
+import sinon from 'sinon';
 
 import {
   listPages,
@@ -160,6 +161,34 @@ describe('pages', () => {
         }
       });
     });
+
+    it('respects the timeout parameter', async () => {
+      await withMcpContext(async (response, context) => {
+        const page = context.getSelectedPage();
+        const stub = sinon.stub(page, 'waitForNavigation').resolves(null);
+
+        try {
+          await navigatePage.handler(
+            {
+              params: {
+                url: 'about:blank',
+                timeout: 12345,
+              },
+            },
+            response,
+            context,
+          );
+        } finally {
+          stub.restore();
+        }
+
+        assert.strictEqual(
+          stub.firstCall.args[0]?.timeout,
+          12345,
+          'The timeout parameter should be passed to waitForNavigation',
+        );
+      });
+    });
     it('go back', async () => {
       await withMcpContext(async (response, context) => {
         const page = context.getSelectedPage();