lsd-pi 1.3.2 → 1.3.6

package/dist/resources/extensions/browser-tools/tools/codegen.js

@@ -62,9 +62,10 @@ export function registerCodegenTools(pi, deps) {
                             }
                             break;
                         }
-                        case "browser_click_ref": {
+                        case "browser_ref": {
                             // Refs are session-specific — add comment
-                            testLines.push(`    // browser_click_ref: ${entry.paramsSummary} — replace with stable selector`);
+                            const refAction = params.action ?? "click";
+                            testLines.push(`    // browser_ref (${refAction}): ${entry.paramsSummary} — replace with stable selector`);
                             actionCount++;
                             break;
                         }
@@ -77,9 +78,8 @@ export function registerCodegenTools(pi, deps) {
                             }
                             break;
                         }
-                        case "browser_fill_ref": {
-                            testLines.push(`    // browser_fill_ref: ${entry.paramsSummary} — replace with stable selector`);
-                            actionCount++;
+                        case "browser_fill_ref_handled": {
+                            // Already handled by browser_ref above
                             break;
                         }
                         case "browser_key_press": {

package/dist/resources/extensions/browser-tools/tools/navigation.js

@@ -8,201 +8,130 @@ export function registerNavigationTools(pi, deps) {
     pi.registerTool({
         name: "browser_navigate",
         label: "Browser Navigate",
-        description: "Open the browser (if not already open) and navigate to a URL. Waits for network idle. Returns page title and current URL. Use ONLY for visually verifying locally-running web apps (e.g. http://localhost:3000). Do NOT use for documentation sites, GitHub, search results, or any external URL — use web_search instead. Screenshots are only captured when the `screenshot` parameter is set to true.",
+        description: "Navigate to a URL, go back/forward in history, or reload the page. " +
+            "Use ONLY for locally-running web apps (e.g. http://localhost:3000). " +
+            "Do NOT use for documentation sites, GitHub, or external URLs — use web_search instead.",
         parameters: Type.Object({
-            url: Type.String({ description: "URL to navigate to, e.g. http://localhost:3000" }),
+            action: Type.Union([
+                Type.Literal("goto"),
+                Type.Literal("go_back"),
+                Type.Literal("go_forward"),
+                Type.Literal("reload"),
+            ], { description: "'goto' — navigate to url (default), 'go_back'/'go_forward' — history, 'reload' — refresh page" }),
+            url: Type.Optional(Type.String({ description: "URL to navigate to (required for goto action)." })),
             screenshot: Type.Optional(Type.Boolean({ description: "Capture and return a screenshot (default: false)", default: false })),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            let actionId = null;
-            let beforeState = null;
+            const action = params.action ?? "goto";
             try {
-                const { page: p } = await deps.ensureBrowser();
-                beforeState = await deps.captureCompactPageState(p, { includeBodyText: true });
-                actionId = deps.beginTrackedAction("browser_navigate", params, beforeState.url).id;
-                await p.goto(params.url, { waitUntil: "domcontentloaded", timeout: 30000 });
-                await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { });
-                await new Promise(resolve => setTimeout(resolve, 300));
-                const title = await p.title();
-                const url = p.url();
-                const viewport = p.viewportSize();
-                const vpText = viewport ? `${viewport.width}x${viewport.height}` : "unknown";
-                const afterState = await deps.captureCompactPageState(p, { includeBodyText: true });
-                const summary = deps.formatCompactStateSummary(afterState);
-                const jsErrors = deps.getRecentErrors(p.url());
-                const diff = diffCompactStates(beforeState, afterState);
-                setLastActionBeforeState(beforeState);
-                setLastActionAfterState(afterState);
-                deps.finishTrackedAction(actionId, {
-                    status: "success",
-                    afterUrl: afterState.url,
-                    warningSummary: jsErrors.trim() || undefined,
-                    diffSummary: diff.summary,
-                    changed: diff.changed,
-                    beforeState,
-                    afterState,
-                });
-                let screenshotContent = [];
-                if (params.screenshot) {
-                    try {
-                        let buf = await p.screenshot({ type: "jpeg", quality: 80, scale: "css" });
-                        buf = await deps.constrainScreenshot(p, buf, "image/jpeg", 80);
-                        screenshotContent = [{ type: "image", data: buf.toString("base64"), mimeType: "image/jpeg" }];
-                    }
-                    catch { /* non-fatal — screenshot is optional, navigation result is still valid */ }
+                if (action === "goto") {
+                    return await gotoAction(params);
                 }
-                return {
-                    content: [
-                        { type: "text", text: `Navigated to: ${url}\nTitle: ${title}\nViewport: ${vpText}\nAction: ${actionId}${jsErrors}\n\nDiff:\n${deps.formatDiffText(diff)}\n\nPage summary:\n${summary}` },
-                        ...screenshotContent,
-                    ],
-                    details: { title, url, status: "loaded", viewport: vpText, actionId, diff },
-                };
-            }
-            catch (err) {
-                if (actionId !== null) {
-                    deps.finishTrackedAction(actionId, { status: "error", afterUrl: deps.getActivePageOrNull()?.url() ?? "", error: err.message, beforeState: beforeState ?? undefined });
+                else if (action === "go_back") {
+                    return await goBackForward("back");
                 }
-                const errorShot = await deps.captureErrorScreenshot(deps.getActivePageOrNull());
-                const content = [{ type: "text", text: `Navigation failed: ${err.message}` }];
-                if (errorShot) {
-                    content.push({ type: "image", data: errorShot.data, mimeType: errorShot.mimeType });
+                else if (action === "go_forward") {
+                    return await goBackForward("forward");
                 }
-                return {
-                    content,
-                    details: { status: "error", error: err.message, actionId },
-                    isError: true,
-                };
-            }
-        },
-    });
-    // -------------------------------------------------------------------------
-    // browser_go_back
-    // -------------------------------------------------------------------------
-    pi.registerTool({
-        name: "browser_go_back",
-        label: "Browser Go Back",
-        description: "Navigate back in browser history. Returns a compact page summary after navigation.",
-        parameters: Type.Object({}),
-        async execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
-            try {
-                const { page: p } = await deps.ensureBrowser();
-                const response = await p.goBack({ waitUntil: "domcontentloaded", timeout: 10000 });
-                if (!response) {
-                    return {
-                        content: [{ type: "text", text: "No previous page in history." }],
-                        details: {},
-                        isError: true,
-                    };
-                }
-                await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { });
-                const title = await p.title();
-                const url = p.url();
-                const summary = await deps.postActionSummary(p);
-                const jsErrors = deps.getRecentErrors(p.url());
-                return {
-                    content: [{ type: "text", text: `Navigated back to: ${url}\nTitle: ${title}${jsErrors}\n\nPage summary:\n${summary}` }],
-                    details: { title, url },
-                };
-            }
-            catch (err) {
-                const errorShot = await deps.captureErrorScreenshot(deps.getActivePageOrNull());
-                const content = [{ type: "text", text: `Go back failed: ${err.message}` }];
-                if (errorShot) {
-                    content.push({ type: "image", data: errorShot.data, mimeType: errorShot.mimeType });
-                }
-                return { content, details: { error: err.message }, isError: true };
-            }
-        },
-    });
-    // -------------------------------------------------------------------------
-    // browser_go_forward
-    // -------------------------------------------------------------------------
-    pi.registerTool({
-        name: "browser_go_forward",
-        label: "Browser Go Forward",
-        description: "Navigate forward in browser history. Returns a compact page summary after navigation.",
-        parameters: Type.Object({}),
-        async execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
-            try {
-                const { page: p } = await deps.ensureBrowser();
-                const response = await p.goForward({ waitUntil: "domcontentloaded", timeout: 10000 });
-                if (!response) {
-                    return {
-                        content: [{ type: "text", text: "No forward page in history." }],
-                        details: {},
-                        isError: true,
-                    };
+                else {
+                    return await reloadAction();
                 }
-                await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { });
-                const title = await p.title();
-                const url = p.url();
-                const summary = await deps.postActionSummary(p);
-                const jsErrors = deps.getRecentErrors(p.url());
-                return {
-                    content: [{ type: "text", text: `Navigated forward to: ${url}\nTitle: ${title}${jsErrors}\n\nPage summary:\n${summary}` }],
-                    details: { title, url },
-                };
             }
             catch (err) {
                 const errorShot = await deps.captureErrorScreenshot(deps.getActivePageOrNull());
-                const content = [{ type: "text", text: `Go forward failed: ${err.message}` }];
-                if (errorShot) {
+                const content = [{ type: "text", text: `Navigation '${action}' failed: ${err.message}` }];
+                if (errorShot)
                     content.push({ type: "image", data: errorShot.data, mimeType: errorShot.mimeType });
-                }
                 return { content, details: { error: err.message }, isError: true };
             }
         },
     });
-    // -------------------------------------------------------------------------
-    // browser_reload
-    // -------------------------------------------------------------------------
-    pi.registerTool({
-        name: "browser_reload",
-        label: "Browser Reload",
-        description: "Reload the current page. Returns a screenshot, compact page summary, and page metadata (same shape as browser_navigate).",
-        parameters: Type.Object({}),
-        async execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
+    // ── action implementations ──
+    async function gotoAction(params) {
+        if (!params.url) {
+            return { content: [{ type: "text", text: "Goto requires a 'url' parameter." }], details: { error: "missing_url" }, isError: true };
+        }
+        let actionId = null;
+        let beforeState = null;
+        const { page: p } = await deps.ensureBrowser();
+        beforeState = await deps.captureCompactPageState(p, { includeBodyText: true });
+        actionId = deps.beginTrackedAction("browser_navigate", params, beforeState.url).id;
+        await p.goto(params.url, { waitUntil: "domcontentloaded", timeout: 30000 });
+        await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { });
+        await new Promise(resolve => setTimeout(resolve, 300));
+        const title = await p.title();
+        const url = p.url();
+        const viewport = p.viewportSize();
+        const vpText = viewport ? `${viewport.width}x${viewport.height}` : "unknown";
+        const afterState = await deps.captureCompactPageState(p, { includeBodyText: true });
+        const summary = deps.formatCompactStateSummary(afterState);
+        const jsErrors = deps.getRecentErrors(p.url());
+        const diff = diffCompactStates(beforeState, afterState);
+        setLastActionBeforeState(beforeState);
+        setLastActionAfterState(afterState);
+        deps.finishTrackedAction(actionId, {
+            status: "success", afterUrl: afterState.url, warningSummary: jsErrors.trim() || undefined,
+            diffSummary: diff.summary, changed: diff.changed, beforeState, afterState,
+        });
+        let screenshotContent = [];
+        if (params.screenshot) {
             try {
-                const { page: p } = await deps.ensureBrowser();
-                await p.reload({ waitUntil: "domcontentloaded", timeout: 30000 });
-                await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { });
-                const title = await p.title();
-                const url = p.url();
-                const viewport = p.viewportSize();
-                const vpText = viewport ? `${viewport.width}x${viewport.height}` : "unknown";
-                const summary = await deps.postActionSummary(p);
-                const jsErrors = deps.getRecentErrors(p.url());
-                let screenshotContent = [];
-                try {
-                    let buf = await p.screenshot({ type: "jpeg", quality: 80, scale: "css" });
-                    buf = await deps.constrainScreenshot(p, buf, "image/jpeg", 80);
-                    screenshotContent = [{
-                            type: "image",
-                            data: buf.toString("base64"),
-                            mimeType: "image/jpeg",
-                        }];
-                }
-                catch { /* non-fatal — screenshot is optional, reload result is still valid */ }
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Reloaded: ${url}\nTitle: ${title}\nViewport: ${vpText}${jsErrors}\n\nPage summary:\n${summary}`,
-                        },
-                        ...screenshotContent,
-                    ],
-                    details: { title, url, viewport: vpText },
-                };
+                let buf = await p.screenshot({ type: "jpeg", quality: 80, scale: "css" });
+                buf = await deps.constrainScreenshot(p, buf, "image/jpeg", 80);
+                screenshotContent = [{ type: "image", data: buf.toString("base64"), mimeType: "image/jpeg" }];
             }
-            catch (err) {
-                const errorShot = await deps.captureErrorScreenshot(deps.getActivePageOrNull());
-                const content = [{ type: "text", text: `Reload failed: ${err.message}` }];
-                if (errorShot) {
-                    content.push({ type: "image", data: errorShot.data, mimeType: errorShot.mimeType });
-                }
-                return { content, details: { error: err.message }, isError: true };
-            }
-        },
-    });
+            catch { /* non-fatal */ }
+        }
+        return {
+            content: [
+                { type: "text", text: `Navigated to: ${url}\nTitle: ${title}\nViewport: ${vpText}\nAction: ${actionId}${jsErrors}\n\nDiff:\n${deps.formatDiffText(diff)}\n\nPage summary:\n${summary}` },
+                ...screenshotContent,
+            ],
+            details: { title, url, status: "loaded", viewport: vpText, actionId, diff },
+        };
+    }
+    async function goBackForward(direction) {
+        const { page: p } = await deps.ensureBrowser();
+        const response = direction === "back"
+            ? await p.goBack({ waitUntil: "domcontentloaded", timeout: 10000 })
+            : await p.goForward({ waitUntil: "domcontentloaded", timeout: 10000 });
+        if (!response) {
+            return {
+                content: [{ type: "text", text: `No ${direction} page in history.` }],
+                details: {},
+                isError: true,
+            };
+        }
+        await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { });
+        const title = await p.title();
+        const url = p.url();
+        const summary = await deps.postActionSummary(p);
+        const jsErrors = deps.getRecentErrors(p.url());
+        return {
+            content: [{ type: "text", text: `Navigated ${direction} to: ${url}\nTitle: ${title}${jsErrors}\n\nPage summary:\n${summary}` }],
+            details: { title, url },
+        };
+    }
+    async function reloadAction() {
+        const { page: p } = await deps.ensureBrowser();
+        await p.reload({ waitUntil: "domcontentloaded", timeout: 30000 });
+        await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => { });
+        const title = await p.title();
+        const url = p.url();
+        const viewport = p.viewportSize();
+        const vpText = viewport ? `${viewport.width}x${viewport.height}` : "unknown";
+        const summary = await deps.postActionSummary(p);
+        const jsErrors = deps.getRecentErrors(p.url());
+        let screenshotContent = [];
+        try {
+            let buf = await p.screenshot({ type: "jpeg", quality: 80, scale: "css" });
+            buf = await deps.constrainScreenshot(p, buf, "image/jpeg", 80);
+            screenshotContent = [{ type: "image", data: buf.toString("base64"), mimeType: "image/jpeg" }];
+        }
+        catch { /* non-fatal */ }
+        return {
+            content: [{ type: "text", text: `Reloaded: ${url}\nTitle: ${title}\nViewport: ${vpText}${jsErrors}\n\nPage summary:\n${summary}` }, ...screenshotContent],
+            details: { title, url, viewport: vpText },
+        };
+    }
 }

package/dist/resources/extensions/browser-tools/tools/network-mock.js

@@ -3,192 +3,137 @@ let nextRouteId = 1;
 const activeRoutes = [];
 const routeCleanups = new Map();
 export function registerNetworkMockTools(pi, deps) {
-    // -------------------------------------------------------------------------
-    // browser_mock_route
-    // -------------------------------------------------------------------------
     pi.registerTool({
-        name: "browser_mock_route",
-        label: "Browser Mock Route",
-        description: "Intercept network requests matching a URL pattern and respond with custom status, body, and headers. " +
-            "Supports simulating slow responses via delay parameter. " +
-            "Routes survive page navigation within the same context. Use browser_clear_routes to remove all mocks.",
+        name: "browser_network",
+        label: "Browser Network",
+        description: "Manage browser network interception: mock API responses, block URL patterns, or clear active routes. " +
+            "Routes survive page navigation within the same context.",
         parameters: Type.Object({
-            url: Type.String({
-                description: "URL pattern to intercept. Supports glob patterns (e.g., '**/api/users*') or exact URLs.",
-            }),
-            status: Type.Optional(Type.Number({ description: "HTTP status code for the mock response (default: 200)." })),
-            body: Type.Optional(Type.String({ description: "Response body string. For JSON responses, pass a JSON string." })),
-            contentType: Type.Optional(Type.String({ description: "Content-Type header (default: 'application/json' if body looks like JSON, else 'text/plain')." })),
+            action: Type.Union([
+                Type.Literal("mock"),
+                Type.Literal("block"),
+                Type.Literal("clear"),
+            ], { description: "'mock' — intercept and respond, 'block' — abort matching requests, 'clear' — remove all active routes" }),
+            url: Type.Optional(Type.String({
+                description: "URL pattern to intercept (glob or exact). Required for mock/block.",
+            })),
+            status: Type.Optional(Type.Number({ description: "HTTP status code for mock response (default: 200)." })),
+            body: Type.Optional(Type.String({ description: "Response body string for mock." })),
+            contentType: Type.Optional(Type.String({ description: "Content-Type header for mock." })),
             headers: Type.Optional(Type.Record(Type.String(), Type.String(), {
-                description: "Additional response headers as key-value pairs.",
+                description: "Additional response headers for mock.",
+            })),
+            delay: Type.Optional(Type.Number({ description: "Delay in ms before sending mock response." })),
+            patterns: Type.Optional(Type.Array(Type.String(), {
+                description: "URL patterns to block (for block action). Glob syntax.",
             })),
-            delay: Type.Optional(Type.Number({ description: "Delay in milliseconds before sending the response. Simulates slow responses." })),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
             try {
-                const { page: p } = await deps.ensureBrowser();
-                const routeId = nextRouteId++;
-                const status = params.status ?? 200;
-                const body = params.body ?? "";
-                const delay = params.delay ?? 0;
-                // Auto-detect content type
-                let contentType = params.contentType;
-                if (!contentType) {
-                    try {
-                        JSON.parse(body);
-                        contentType = "application/json";
-                    }
-                    catch {
-                        contentType = "text/plain";
-                    }
+                if (params.action === "mock") {
+                    return await handleMock(deps, params);
                 }
-                const headers = {
-                    "content-type": contentType,
-                    "access-control-allow-origin": "*",
-                    ...(params.headers ?? {}),
-                };
-                const handler = async (route) => {
-                    if (delay > 0) {
-                        await new Promise((resolve) => setTimeout(resolve, delay));
-                    }
-                    await route.fulfill({
-                        status,
-                        body,
-                        headers,
-                    });
-                };
-                await p.route(params.url, handler);
-                const cleanup = async () => {
-                    try {
-                        await p.unroute(params.url, handler);
-                    }
-                    catch {
-                        // Page may be closed
-                    }
-                };
-                const routeInfo = {
-                    id: routeId,
-                    pattern: params.url,
-                    type: "mock",
-                    status,
-                    delay: delay > 0 ? delay : undefined,
-                    description: `Mock ${params.url} → ${status}${delay > 0 ? ` (${delay}ms delay)` : ""}`,
-                };
-                activeRoutes.push(routeInfo);
-                routeCleanups.set(routeId, cleanup);
-                return {
-                    content: [{
-                            type: "text",
-                            text: `Route mocked: ${routeInfo.description}\nRoute ID: ${routeId}\nActive routes: ${activeRoutes.length}`,
-                        }],
-                    details: { routeId, ...routeInfo, activeRouteCount: activeRoutes.length },
-                };
-            }
-            catch (err) {
-                return {
-                    content: [{ type: "text", text: `Mock route failed: ${err.message}` }],
-                    details: { error: err.message },
-                    isError: true,
-                };
-            }
-        },
-    });
-    // -------------------------------------------------------------------------
-    // browser_block_urls
-    // -------------------------------------------------------------------------
-    pi.registerTool({
-        name: "browser_block_urls",
-        label: "Browser Block URLs",
-        description: "Block network requests matching URL patterns. Useful for blocking analytics, ads, or third-party scripts. " +
-            "Accepts glob patterns. Routes survive page navigation.",
-        parameters: Type.Object({
-            patterns: Type.Array(Type.String(), {
-                description: "URL patterns to block (glob syntax, e.g., ['**/analytics*', '**/ads*']).",
-            }),
-        }),
-        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            try {
-                const { page: p } = await deps.ensureBrowser();
-                const results = [];
-                for (const pattern of params.patterns) {
-                    const routeId = nextRouteId++;
-                    const handler = async (route) => {
-                        await route.abort("blockedbyclient");
-                    };
-                    await p.route(pattern, handler);
-                    const cleanup = async () => {
-                        try {
-                            await p.unroute(pattern, handler);
-                        }
-                        catch { /* cleanup — route may already be removed or page closed */ }
-                    };
-                    const routeInfo = {
-                        id: routeId,
-                        pattern,
-                        type: "block",
-                        description: `Block ${pattern}`,
-                    };
-                    activeRoutes.push(routeInfo);
-                    routeCleanups.set(routeId, cleanup);
-                    results.push(routeInfo);
+                else if (params.action === "block") {
+                    return await handleBlock(deps, params);
+                }
+                else {
+                    return await handleClear(deps);
                 }
-                return {
-                    content: [{
-                            type: "text",
-                            text: `Blocked ${results.length} URL pattern(s):\n${results.map((r) => `  - ${r.description} (ID: ${r.id})`).join("\n")}\nActive routes: ${activeRoutes.length}`,
-                        }],
-                    details: { blocked: results, activeRouteCount: activeRoutes.length },
-                };
             }
             catch (err) {
                 return {
-                    content: [{ type: "text", text: `Block URLs failed: ${err.message}` }],
+                    content: [{ type: "text", text: `Network action '${params.action}' failed: ${err.message}` }],
                     details: { error: err.message },
                     isError: true,
                 };
             }
         },
     });
-    // -------------------------------------------------------------------------
-    // browser_clear_routes
-    // -------------------------------------------------------------------------
-    pi.registerTool({
-        name: "browser_clear_routes",
-        label: "Browser Clear Routes",
-        description: "Remove all active route mocks and URL blocks. Also lists currently active routes if called with no routes active.",
-        parameters: Type.Object({}),
-        async execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
+    async function handleMock(deps, params) {
+        if (!params.url) {
+            return { content: [{ type: "text", text: "Mock requires a 'url' parameter." }], details: { error: "missing_url" }, isError: true };
+        }
+        const { page: p } = await deps.ensureBrowser();
+        const routeId = nextRouteId++;
+        const status = params.status ?? 200;
+        const body = params.body ?? "";
+        const delay = params.delay ?? 0;
+        let contentType = params.contentType;
+        if (!contentType) {
             try {
-                await deps.ensureBrowser();
-                const count = activeRoutes.length;
-                if (count === 0) {
-                    return {
-                        content: [{ type: "text", text: "No active routes to clear." }],
-                        details: { cleared: 0 },
-                    };
-                }
-                const routeDescriptions = activeRoutes.map((r) => r.description);
-                // Clean up all routes
-                for (const [id, cleanup] of routeCleanups) {
-                    await cleanup();
-                }
-                activeRoutes.length = 0;
-                routeCleanups.clear();
-                return {
-                    content: [{
-                            type: "text",
-                            text: `Cleared ${count} route(s):\n${routeDescriptions.map((d) => `  - ${d}`).join("\n")}`,
-                        }],
-                    details: { cleared: count, routes: routeDescriptions },
-                };
+                JSON.parse(body);
+                contentType = "application/json";
             }
-            catch (err) {
-                return {
-                    content: [{ type: "text", text: `Clear routes failed: ${err.message}` }],
-                    details: { error: err.message },
-                    isError: true,
-                };
+            catch {
+                contentType = "text/plain";
             }
-        },
-    });
+        }
+        const respHeaders = {
+            "content-type": contentType,
+            "access-control-allow-origin": "*",
+            ...(params.headers ?? {}),
+        };
+        const handler = async (route) => {
+            if (delay > 0)
+                await new Promise((r) => setTimeout(r, delay));
+            await route.fulfill({ status, body, headers: respHeaders });
+        };
+        await p.route(params.url, handler);
+        const cleanup = async () => { try {
+            await p.unroute(params.url, handler);
+        }
+        catch { /* page may be closed */ } };
+        const routeInfo = {
+            id: routeId, pattern: params.url, type: "mock", status,
+            delay: delay > 0 ? delay : undefined,
+            description: `Mock ${params.url} → ${status}${delay > 0 ? ` (${delay}ms delay)` : ""}`,
+        };
+        activeRoutes.push(routeInfo);
+        routeCleanups.set(routeId, cleanup);
+        return {
+            content: [{ type: "text", text: `Route mocked: ${routeInfo.description}\nRoute ID: ${routeId}\nActive routes: ${activeRoutes.length}` }],
+            details: { routeId, ...routeInfo, activeRouteCount: activeRoutes.length },
+        };
+    }
+    async function handleBlock(deps, params) {
+        const patterns = params.patterns ?? (params.url ? [params.url] : []);
+        if (patterns.length === 0) {
+            return { content: [{ type: "text", text: "Block requires 'patterns' or 'url' parameter." }], details: { error: "missing_patterns" }, isError: true };
+        }
+        const { page: p } = await deps.ensureBrowser();
+        const results = [];
+        for (const pattern of patterns) {
+            const routeId = nextRouteId++;
+            const handler = async (route) => { await route.abort("blockedbyclient"); };
+            await p.route(pattern, handler);
+            const cleanup = async () => { try {
+                await p.unroute(pattern, handler);
+            }
+            catch { /* cleanup */ } };
+            const routeInfo = { id: routeId, pattern, type: "block", description: `Block ${pattern}` };
+            activeRoutes.push(routeInfo);
+            routeCleanups.set(routeId, cleanup);
+            results.push(routeInfo);
+        }
+        return {
+            content: [{ type: "text", text: `Blocked ${results.length} URL pattern(s):\n${results.map((r) => `  - ${r.description} (ID: ${r.id})`).join("\n")}\nActive routes: ${activeRoutes.length}` }],
+            details: { blocked: results, activeRouteCount: activeRoutes.length },
+        };
+    }
+    async function handleClear(_deps) {
+        await _deps.ensureBrowser();
+        const count = activeRoutes.length;
+        if (count === 0) {
+            return { content: [{ type: "text", text: "No active routes to clear." }], details: { cleared: 0 } };
+        }
+        const descriptions = activeRoutes.map((r) => r.description);
+        for (const [, cleanup] of routeCleanups)
+            await cleanup();
+        activeRoutes.length = 0;
+        routeCleanups.clear();
+        return {
+            content: [{ type: "text", text: `Cleared ${count} route(s):\n${descriptions.map((d) => `  - ${d}`).join("\n")}` }],
+            details: { cleared: count, routes: descriptions },
+        };
+    }
 }