gsd-pi 2.33.1-dev.235d83a → 2.33.1-dev.29a8268

package/dist/resources/extensions/browser-tools/tools/injection-detect.js

@@ -1,178 +0,0 @@
-import { Type } from "@sinclair/typebox";
-/**
- * Prompt injection detection — scan page content for text attempting to hijack the agent.
- */
-// Known injection patterns — regex patterns that match common prompt injection attempts
-const INJECTION_PATTERNS = [
-    // Direct instruction override attempts
-    { pattern: /ignore\s+(all\s+)?previous\s+(instructions?|prompts?)/i, category: "instruction_override", severity: "high" },
-    { pattern: /disregard\s+(all\s+)?previous\s+(instructions?|prompts?)/i, category: "instruction_override", severity: "high" },
-    { pattern: /forget\s+(all\s+)?previous\s+(instructions?|prompts?)/i, category: "instruction_override", severity: "high" },
-    { pattern: /override\s+(all\s+)?previous\s+(instructions?|prompts?)/i, category: "instruction_override", severity: "high" },
-    // System prompt extraction
-    { pattern: /(?:what|show|reveal|display|repeat|tell)\s+(?:me\s+)?(?:your|the)\s+system\s+prompt/i, category: "prompt_extraction", severity: "high" },
-    { pattern: /print\s+(?:your|the)\s+(?:system\s+)?(?:prompt|instructions)/i, category: "prompt_extraction", severity: "high" },
-    // Role reassignment
-    { pattern: /you\s+are\s+now\s+(?:a\s+)?(?:DAN|jailbreak|unrestricted|unfiltered)/i, category: "role_reassignment", severity: "high" },
-    { pattern: /act\s+as\s+(?:a\s+)?(?:DAN|jailbreak|unrestricted|unfiltered)/i, category: "role_reassignment", severity: "high" },
-    { pattern: /entering\s+(?:a\s+)?(?:developer|admin|root|sudo)\s+mode/i, category: "role_reassignment", severity: "high" },
-    // Hidden instruction injection
-    { pattern: /\[SYSTEM\]\s*:/i, category: "fake_system_message", severity: "high" },
-    { pattern: /\[INST\]\s*:/i, category: "fake_system_message", severity: "medium" },
-    { pattern: /<\/?system>/i, category: "fake_system_message", severity: "high" },
-    // Tool/action manipulation
-    { pattern: /execute\s+(?:the\s+following\s+)?(?:command|code|script)/i, category: "command_injection", severity: "medium" },
-    { pattern: /run\s+(?:this|the\s+following)\s+(?:command|code|script)/i, category: "command_injection", severity: "medium" },
-    // Invisible text / social engineering
-    { pattern: /do\s+not\s+(?:read|process|show)\s+(?:the\s+)?(?:following|rest)/i, category: "social_engineering", severity: "low" },
-    { pattern: /(?:this|the\s+following)\s+(?:is|are)\s+(?:your\s+)?new\s+instructions/i, category: "instruction_override", severity: "high" },
-    // Base64/encoded content markers
-    { pattern: /base64\s*:\s*[A-Za-z0-9+\/=]{50,}/i, category: "encoded_payload", severity: "medium" },
-];
-export function registerInjectionDetectionTools(pi, deps) {
-    pi.registerTool({
-        name: "browser_check_injection",
-        label: "Browser Check Injection",
-        description: "Scan current page content for potential prompt injection attempts. " +
-            "Checks visible text and hidden elements for patterns that might hijack the agent. " +
-            "Returns findings with severity levels. Use after navigating to untrusted pages.",
-        parameters: Type.Object({
-            includeHidden: Type.Optional(Type.Boolean({
-                description: "Also scan hidden/invisible text (default: true). " +
-                    "Hidden text is a common vector for injection attacks.",
-            })),
-        }),
-        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            try {
-                const { page: p } = await deps.ensureBrowser();
-                const includeHidden = params.includeHidden ?? true;
-                // Extract text content from the page
-                const pageContent = await p.evaluate((scanHidden) => {
-                    const results = [];
-                    // 1. Visible text content
-                    const bodyText = document.body?.innerText ?? "";
-                    results.push({ text: bodyText, source: "body_visible_text", visible: true });
-                    // 2. Title and meta
-                    results.push({ text: document.title, source: "page_title", visible: true });
-                    // Meta descriptions and keywords
-                    const metas = document.querySelectorAll("meta[name], meta[property]");
-                    for (const meta of metas) {
-                        const content = meta.getAttribute("content");
-                        if (content) {
-                            results.push({
-                                text: content,
-                                source: `meta:${meta.getAttribute("name") || meta.getAttribute("property")}`,
-                                visible: false,
-                            });
-                        }
-                    }
-                    if (scanHidden) {
-                        // 3. Hidden elements (display:none, visibility:hidden, opacity:0, off-screen, aria-hidden)
-                        const allElements = document.querySelectorAll("*");
-                        for (const el of allElements) {
-                            const htmlEl = el;
-                            const style = window.getComputedStyle(htmlEl);
-                            const isHidden = style.display === "none" ||
-                                style.visibility === "hidden" ||
-                                style.opacity === "0" ||
-                                htmlEl.getAttribute("aria-hidden") === "true" ||
-                                (htmlEl.offsetWidth === 0 && htmlEl.offsetHeight === 0);
-                            if (isHidden && htmlEl.textContent?.trim()) {
-                                const text = htmlEl.textContent.trim();
-                                if (text.length > 5 && text.length < 5000) {
-                                    results.push({ text, source: "hidden_element", visible: false });
-                                }
-                            }
-                        }
-                        // 4. HTML comments
-                        const walker = document.createTreeWalker(document.documentElement, NodeFilter.SHOW_COMMENT);
-                        let node;
-                        while ((node = walker.nextNode())) {
-                            const text = node.textContent?.trim() ?? "";
-                            if (text.length > 10) {
-                                results.push({ text, source: "html_comment", visible: false });
-                            }
-                        }
-                        // 5. Data attributes with text content
-                        const dataElements = document.querySelectorAll("[data-prompt], [data-instruction], [data-system]");
-                        for (const el of dataElements) {
-                            for (const attr of el.attributes) {
-                                if (attr.name.startsWith("data-") && attr.value.length > 10) {
-                                    results.push({
-                                        text: attr.value,
-                                        source: `data_attribute:${attr.name}`,
-                                        visible: false,
-                                    });
-                                }
-                            }
-                        }
-                    }
-                    return results;
-                }, includeHidden);
-                // Scan all extracted text against injection patterns
-                const findings = [];
-                for (const { text, source, visible } of pageContent) {
-                    for (const { pattern, category, severity } of INJECTION_PATTERNS) {
-                        const match = text.match(pattern);
-                        if (match) {
-                            findings.push({
-                                pattern: pattern.source.slice(0, 60),
-                                category,
-                                severity,
-                                source,
-                                visible,
-                                matchedText: match[0].slice(0, 100),
-                            });
-                        }
-                    }
-                }
-                // Deduplicate findings by category + source
-                const seen = new Set();
-                const uniqueFindings = findings.filter((f) => {
-                    const key = `${f.category}|${f.source}|${f.matchedText}`;
-                    if (seen.has(key))
-                        return false;
-                    seen.add(key);
-                    return true;
-                });
-                const highCount = uniqueFindings.filter((f) => f.severity === "high").length;
-                const medCount = uniqueFindings.filter((f) => f.severity === "medium").length;
-                const lowCount = uniqueFindings.filter((f) => f.severity === "low").length;
-                if (uniqueFindings.length === 0) {
-                    return {
-                        content: [{
-                                type: "text",
-                                text: `No prompt injection patterns detected.\nScanned: ${pageContent.length} text regions (hidden: ${includeHidden})`,
-                            }],
-                        details: {
-                            clean: true,
-                            scannedRegions: pageContent.length,
-                            includeHidden,
-                        },
-                    };
-                }
-                const findingLines = uniqueFindings.map((f) => `  [${f.severity.toUpperCase()}] ${f.category} in ${f.source}${!f.visible ? " (HIDDEN)" : ""}: "${f.matchedText}"`);
-                return {
-                    content: [{
-                            type: "text",
-                            text: `⚠️ Prompt injection patterns detected: ${uniqueFindings.length} finding(s)\nHigh: ${highCount} | Medium: ${medCount} | Low: ${lowCount}\n\n${findingLines.join("\n")}\n\n⚠️ This page may be attempting to manipulate the agent. Proceed with caution.`,
-                        }],
-                    details: {
-                        clean: false,
-                        findings: uniqueFindings,
-                        counts: { high: highCount, medium: medCount, low: lowCount, total: uniqueFindings.length },
-                        scannedRegions: pageContent.length,
-                        includeHidden,
-                    },
-                };
-            }
-            catch (err) {
-                return {
-                    content: [{ type: "text", text: `Injection check failed: ${err.message}` }],
-                    details: { error: err.message },
-                    isError: true,
-                };
-            }
-        },
-    });
-}

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

@@ -1,426 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import { StringEnum } from "@gsd/pi-ai";
-import { getConsoleLogs, setConsoleLogs, getNetworkLogs, setNetworkLogs, getDialogLogs, setDialogLogs, } from "../state.js";
-export function registerInspectionTools(pi, deps) {
-    // -------------------------------------------------------------------------
-    // browser_get_console_logs
-    // -------------------------------------------------------------------------
-    pi.registerTool({
-        name: "browser_get_console_logs",
-        label: "Browser Console Logs",
-        description: "Get all buffered browser console logs and JavaScript errors captured since the last clear. Each entry includes timestamp and page URL. Note: JS errors are also auto-surfaced in interaction tool responses — use this for the full log.",
-        parameters: Type.Object({
-            clear: Type.Optional(Type.Boolean({
-                description: "Clear the buffer after returning logs (default: true)",
-            })),
-        }),
-        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            const shouldClear = params.clear !== false;
-            const logs = [...getConsoleLogs()];
-            if (shouldClear) {
-                setConsoleLogs([]);
-            }
-            if (logs.length === 0) {
-                return {
-                    content: [{ type: "text", text: "No console logs captured." }],
-                    details: { logs: [], count: 0 },
-                };
-            }
-            const formatted = logs
-                .map((entry) => {
-                const time = new Date(entry.timestamp).toISOString().slice(11, 23);
-                return `[${time}] [${entry.type.toUpperCase()}] ${entry.text}`;
-            })
-                .join("\n");
-            const truncated = deps.truncateText(formatted);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `${logs.length} console log(s):\n\n${truncated}`,
-                    },
-                ],
-                details: { logs, count: logs.length },
-            };
-        },
-    });
-    // -------------------------------------------------------------------------
-    // browser_get_network_logs
-    // -------------------------------------------------------------------------
-    pi.registerTool({
-        name: "browser_get_network_logs",
-        label: "Browser Network Logs",
-        description: "Get buffered network requests and responses. Shows method, URL, status code, and resource type for all requests. Includes response body for failed requests (4xx/5xx). Use to debug API failures, CORS issues, missing resources, and auth problems.",
-        parameters: Type.Object({
-            clear: Type.Optional(Type.Boolean({
-                description: "Clear the buffer after returning logs (default: true)",
-            })),
-            filter: Type.Optional(StringEnum(["all", "errors", "fetch-xhr"])),
-        }),
-        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            const shouldClear = params.clear !== false;
-            let logs = [...getNetworkLogs()];
-            if (shouldClear) {
-                setNetworkLogs([]);
-            }
-            if (params.filter === "errors") {
-                logs = logs.filter(e => e.failed || (e.status !== null && e.status >= 400));
-            }
-            else if (params.filter === "fetch-xhr") {
-                logs = logs.filter(e => e.resourceType === "fetch" || e.resourceType === "xhr");
-            }
-            if (logs.length === 0) {
-                return {
-                    content: [{ type: "text", text: "No network requests captured." }],
-                    details: { logs: [], count: 0 },
-                };
-            }
-            const formatted = logs
-                .map((entry) => {
-                const time = new Date(entry.timestamp).toISOString().slice(11, 23);
-                const status = entry.failed
-                    ? `FAILED (${entry.failureText})`
-                    : `${entry.status}`;
-                let line = `[${time}] ${entry.method} ${entry.url} → ${status} (${entry.resourceType})`;
-                if (entry.responseBody) {
-                    line += `\n  Response: ${entry.responseBody}`;
-                }
-                return line;
-            })
-                .join("\n");
-            const truncated = deps.truncateText(formatted);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `${logs.length} network request(s):\n\n${truncated}`,
-                    },
-                ],
-                details: { count: logs.length },
-            };
-        },
-    });
-    // -------------------------------------------------------------------------
-    // browser_get_dialog_logs
-    // -------------------------------------------------------------------------
-    pi.registerTool({
-        name: "browser_get_dialog_logs",
-        label: "Browser Dialog Logs",
-        description: "Get buffered JavaScript dialog events (alert, confirm, prompt, beforeunload). Dialogs are auto-accepted to prevent page freezes. Use this to see what dialogs appeared and their messages.",
-        parameters: Type.Object({
-            clear: Type.Optional(Type.Boolean({
-                description: "Clear the buffer after returning logs (default: true)",
-            })),
-        }),
-        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            const shouldClear = params.clear !== false;
-            const logs = [...getDialogLogs()];
-            if (shouldClear) {
-                setDialogLogs([]);
-            }
-            if (logs.length === 0) {
-                return {
-                    content: [{ type: "text", text: "No dialog events captured." }],
-                    details: { logs: [], count: 0 },
-                };
-            }
-            const formatted = logs
-                .map((entry) => {
-                const time = new Date(entry.timestamp).toISOString().slice(11, 23);
-                let line = `[${time}] ${entry.type}: "${entry.message}"`;
-                if (entry.defaultValue) {
-                    line += ` (default: "${entry.defaultValue}")`;
-                }
-                line += ` → auto-accepted`;
-                return line;
-            })
-                .join("\n");
-            const truncated = deps.truncateText(formatted);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `${logs.length} dialog(s):\n\n${truncated}`,
-                    },
-                ],
-                details: { logs, count: logs.length },
-            };
-        },
-    });
-    // -------------------------------------------------------------------------
-    // browser_evaluate
-    // -------------------------------------------------------------------------
-    pi.registerTool({
-        name: "browser_evaluate",
-        label: "Browser Evaluate",
-        description: "Execute a JavaScript expression in the browser context and return the result. Useful for reading DOM state, checking values, etc.",
-        parameters: Type.Object({
-            expression: Type.String({
-                description: "JavaScript expression to evaluate in the page context",
-            }),
-        }),
-        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            try {
-                await deps.ensureBrowser();
-                const target = deps.getActiveTarget();
-                const result = await target.evaluate(params.expression);
-                let serialized;
-                if (result === undefined) {
-                    serialized = "undefined";
-                }
-                else {
-                    try {
-                        serialized = JSON.stringify(result, null, 2) ?? "undefined";
-                    }
-                    catch {
-                        serialized = `[non-serializable: ${typeof result}]`;
-                    }
-                }
-                const truncated = deps.truncateText(serialized);
-                return {
-                    content: [{ type: "text", text: truncated }],
-                    details: { expression: params.expression },
-                };
-            }
-            catch (err) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Evaluation failed: ${err.message}`,
-                        },
-                    ],
-                    details: { error: err.message },
-                    isError: true,
-                };
-            }
-        },
-    });
-    // -------------------------------------------------------------------------
-    // browser_get_accessibility_tree
-    // -------------------------------------------------------------------------
-    pi.registerTool({
-        name: "browser_get_accessibility_tree",
-        label: "Browser Accessibility Tree",
-        description: "Get the accessibility tree of the current page as structured text. Shows roles, names, labels, values, and states of all interactive elements. Use this to understand page structure before clicking — it reveals buttons, inputs, links, and their labels without needing to guess CSS selectors or coordinates. Much more reliable than inspecting the DOM directly.",
-        parameters: Type.Object({
-            selector: Type.Optional(Type.String({
-                description: "Scope the accessibility tree to a specific element by CSS selector (e.g. 'main', 'form', '#modal'). If omitted, returns the full page tree.",
-            })),
-        }),
-        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            try {
-                const { page: p } = await deps.ensureBrowser();
-                const target = deps.getActiveTarget();
-                let snapshot;
-                if (params.selector) {
-                    const locator = target.locator(params.selector).first();
-                    snapshot = await locator.ariaSnapshot();
-                }
-                else {
-                    snapshot = await target.locator("body").ariaSnapshot();
-                }
-                const truncated = deps.truncateText(snapshot);
-                const scope = params.selector ? `element "${params.selector}"` : "full page";
-                const viewport = p.viewportSize();
-                const vpText = viewport ? `${viewport.width}x${viewport.height}` : "unknown";
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Accessibility tree for ${scope} (viewport: ${vpText}):\n\n${truncated}`,
-                        },
-                    ],
-                    details: { scope, snapshot, viewport: vpText },
-                };
-            }
-            catch (err) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Accessibility tree failed: ${err.message}`,
-                        },
-                    ],
-                    details: { error: err.message },
-                    isError: true,
-                };
-            }
-        },
-    });
-    // -------------------------------------------------------------------------
-    // browser_find
-    // -------------------------------------------------------------------------
-    pi.registerTool({
-        name: "browser_find",
-        label: "Browser Find",
-        description: "Find elements on the page by text content, ARIA role, or CSS selector. Returns only the matched nodes as a compact accessibility snapshot — far cheaper than browser_get_accessibility_tree. Use this after any action to locate a specific button, input, heading, or link before clicking it.",
-        promptGuidelines: [
-            "Use browser_find for cheap targeted discovery before requesting the full accessibility tree.",
-            "Prefer browser_find when you need one button, input, heading, dialog, or alert rather than a full-page structure dump.",
-        ],
-        parameters: Type.Object({
-            text: Type.Optional(Type.String({
-                description: "Find elements whose visible text contains this string (case-insensitive).",
-            })),
-            role: Type.Optional(Type.String({
-                description: "ARIA role to filter by, e.g. 'button', 'link', 'heading', 'textbox', 'dialog', 'alert'.",
-            })),
-            selector: Type.Optional(Type.String({
-                description: "CSS selector to scope the search. If omitted, searches the full page.",
-            })),
-            limit: Type.Optional(Type.Number({
-                description: "Maximum number of results to return (default: 20).",
-            })),
-        }),
-        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            try {
-                await deps.ensureBrowser();
-                const target = deps.getActiveTarget();
-                const limit = params.limit ?? 20;
-                const results = await target.evaluate(({ text, role, selector, limit }) => {
-                    const root = selector ? document.querySelector(selector) : document.body;
-                    if (!root)
-                        return [];
-                    let candidates;
-                    if (role) {
-                        const roleMap = {
-                            button: 'button,[role="button"]',
-                            link: 'a[href],[role="link"]',
-                            heading: 'h1,h2,h3,h4,h5,h6,[role="heading"]',
-                            textbox: 'input:not([type="hidden"]):not([type="checkbox"]):not([type="radio"]):not([type="submit"]):not([type="button"]),textarea,[role="textbox"]',
-                            checkbox: 'input[type="checkbox"],[role="checkbox"]',
-                            radio: 'input[type="radio"],[role="radio"]',
-                            combobox: 'select,[role="combobox"]',
-                            dialog: 'dialog,[role="dialog"]',
-                            alert: '[role="alert"]',
-                            navigation: 'nav,[role="navigation"]',
-                            listitem: 'li,[role="listitem"]',
-                        };
-                        const cssForRole = roleMap[role.toLowerCase()] ?? `[role="${role}"]`;
-                        candidates = Array.from(root.querySelectorAll(cssForRole));
-                    }
-                    else {
-                        candidates = Array.from(root.querySelectorAll('*'));
-                    }
-                    if (text) {
-                        const lower = text.toLowerCase();
-                        candidates = candidates.filter(el => (el.textContent ?? "").toLowerCase().includes(lower) ||
-                            (el.getAttribute("aria-label") ?? "").toLowerCase().includes(lower) ||
-                            (el.getAttribute("placeholder") ?? "").toLowerCase().includes(lower) ||
-                            (el.getAttribute("value") ?? "").toLowerCase().includes(lower));
-                    }
-                    return candidates.slice(0, limit).map(el => {
-                        const tag = el.tagName.toLowerCase();
-                        const id = el.id ? `#${el.id}` : "";
-                        const classes = Array.from(el.classList).slice(0, 2).map(c => `.${c}`).join("");
-                        const ariaLabel = el.getAttribute("aria-label") ?? "";
-                        const placeholder = el.getAttribute("placeholder") ?? "";
-                        const textContent = (el.textContent ?? "").trim().slice(0, 80);
-                        const role = el.getAttribute("role") ?? "";
-                        const type = el.getAttribute("type") ?? "";
-                        const href = el.getAttribute("href") ?? "";
-                        const value = el.value ?? "";
-                        return { tag, id, classes, ariaLabel, placeholder, textContent, role, type, href, value };
-                    });
-                }, { text: params.text, role: params.role, selector: params.selector, limit });
-                if (results.length === 0) {
-                    return {
-                        content: [{ type: "text", text: "No elements found matching the criteria." }],
-                        details: { count: 0 },
-                    };
-                }
-                const lines = results.map((r) => {
-                    const parts = [`${r.tag}${r.id}${r.classes}`];
-                    if (r.role)
-                        parts.push(`role="${r.role}"`);
-                    if (r.type)
-                        parts.push(`type="${r.type}"`);
-                    if (r.ariaLabel)
-                        parts.push(`aria-label="${r.ariaLabel}"`);
-                    if (r.placeholder)
-                        parts.push(`placeholder="${r.placeholder}"`);
-                    if (r.href)
-                        parts.push(`href="${r.href.slice(0, 60)}"`);
-                    if (r.value)
-                        parts.push(`value="${r.value.slice(0, 40)}"`);
-                    if (r.textContent && !r.ariaLabel)
-                        parts.push(`"${r.textContent}"`);
-                    return "  " + parts.join(" ");
-                });
-                const criteria = [];
-                if (params.role)
-                    criteria.push(`role="${params.role}"`);
-                if (params.text)
-                    criteria.push(`text="${params.text}"`);
-                if (params.selector)
-                    criteria.push(`within="${params.selector}"`);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Found ${results.length} element(s) [${criteria.join(", ")}]:\n${lines.join("\n")}`,
-                        },
-                    ],
-                    details: { count: results.length, results },
-                };
-            }
-            catch (err) {
-                return {
-                    content: [{ type: "text", text: `Find failed: ${err.message}` }],
-                    details: { error: err.message },
-                    isError: true,
-                };
-            }
-        },
-    });
-    // -------------------------------------------------------------------------
-    // browser_get_page_source
-    // -------------------------------------------------------------------------
-    pi.registerTool({
-        name: "browser_get_page_source",
-        label: "Browser Page Source",
-        description: "Get the current HTML source of the page (or a specific element). Use when you need to inspect the actual DOM structure — verify semantic HTML, check that elements rendered correctly, debug why a selector isn't matching, or audit accessibility markup. Output is truncated for large pages.",
-        parameters: Type.Object({
-            selector: Type.Optional(Type.String({
-                description: "CSS selector to scope the output to a specific element (e.g. 'main', 'form', '#app'). If omitted, returns the full page HTML.",
-            })),
-        }),
-        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            try {
-                await deps.ensureBrowser();
-                const target = deps.getActiveTarget();
-                let html;
-                if (params.selector) {
-                    html = await target.locator(params.selector).first().evaluate((el) => el.outerHTML);
-                }
-                else {
-                    html = await target.content();
-                }
-                const truncated = deps.truncateText(html);
-                const scope = params.selector ? `element "${params.selector}"` : "full page";
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `HTML source of ${scope}:\n\n${truncated}`,
-                        },
-                    ],
-                    details: { scope },
-                };
-            }
-            catch (err) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Get page source failed: ${err.message}`,
-                        },
-                    ],
-                    details: { error: err.message },
-                    isError: true,
-                };
-            }
-        },
-    });
-}