@wordbricks/playwright-mcp 0.1.20 → 0.1.23

package/lib/tools/networkSearch/bodySearch.js

@@ -1,147 +0,0 @@
-import { withTimeout } from '../../utils/withTimeout.js';
-import { searchInHtml } from './searchHtml.js';
-import { highlightMatch } from './helpers.js';
-const CONTEXT_LENGTH_BODY = 400;
-const CONTEXT_LENGTH_DEFAULT = 300;
-const MAX_SEARCH_DEPTH = 20;
-export const searchInObject = (obj, keyword, path, matches, source, depth = 0) => {
-    if (depth > MAX_SEARCH_DEPTH || !obj || typeof obj !== 'object')
-        return;
-    for (const key in obj) {
-        const newPath = path ? `${path}.${key}` : key;
-        const value = obj[key];
-        if (key.toLowerCase().includes(keyword)) {
-            const highlightedKey = highlightMatch(key, keyword, CONTEXT_LENGTH_DEFAULT);
-            const valueContext = typeof value === 'object' && value !== null
-                ? truncateJsonPreview(value)
-                : truncateStringPreview(String(value));
-            matches.push({
-                path: newPath,
-                value: typeof value === 'object' && value !== null ? JSON.stringify(value) : String(value),
-                context: `${highlightedKey}: ${valueContext}`,
-                source,
-            });
-        }
-        if (typeof value === 'string' && value.toLowerCase().includes(keyword)) {
-            matches.push({
-                path: newPath,
-                value: value,
-                context: `${key}: ${highlightMatch(value, keyword, CONTEXT_LENGTH_DEFAULT)}`,
-                source,
-            });
-        }
-        else if (typeof value === 'number' && String(value).includes(keyword)) {
-            const valueStr = String(value);
-            matches.push({
-                path: newPath,
-                value: valueStr,
-                context: `${key}: ${highlightMatch(valueStr, keyword, CONTEXT_LENGTH_DEFAULT)}`,
-                source,
-            });
-        }
-        if (typeof value === 'object' && value !== null)
-            searchInObject(value, keyword, newPath, matches, source, depth + 1);
-    }
-};
-const truncateStringPreview = (text) => text.length > CONTEXT_LENGTH_DEFAULT ? text.slice(0, CONTEXT_LENGTH_DEFAULT) + '...' : text;
-const truncateJsonPreview = (obj) => {
-    try {
-        return JSON.stringify(obj).slice(0, CONTEXT_LENGTH_BODY) + '...';
-    }
-    catch {
-        return '[Object]';
-    }
-};
-export const searchInRequestBody = (request, keyword, matches) => {
-    const body = request.postData();
-    if (!body || !body.toLowerCase().includes(keyword))
-        return;
-    const requestContentType = request.headers()['content-type'] || '';
-    let handled = false;
-    if (requestContentType.includes('application/json') || body.trim().startsWith('{') || body.trim().startsWith('[')) {
-        try {
-            const parsed = JSON.parse(body);
-            searchInObject(parsed, keyword, 'request.body', matches, 'requestBody');
-            handled = true;
-        }
-        catch { }
-    }
-    if (!handled && (requestContentType.includes('text/html') || body.trim().startsWith('<'))) {
-        searchInHtml(body, keyword, 'request.body', matches, 'requestBody');
-        handled = true;
-    }
-    if (!handled && requestContentType.includes('application/x-www-form-urlencoded')) {
-        try {
-            const sp = new URLSearchParams(body);
-            for (const [k, v] of sp.entries()) {
-                const vStr = v || '';
-                if (!vStr.toLowerCase().includes(keyword))
-                    continue;
-                const trimmed = vStr.trim();
-                let parsedOk = false;
-                if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
-                    try {
-                        const parsed = JSON.parse(trimmed);
-                        searchInObject(parsed, keyword, `request.body.form.${k}`, matches, 'requestBody');
-                        parsedOk = true;
-                    }
-                    catch { }
-                }
-                if (!parsedOk) {
-                    matches.push({
-                        path: `request.body.form.${k}`,
-                        value: vStr,
-                        context: `${k}=${highlightMatch(vStr, keyword, CONTEXT_LENGTH_DEFAULT)}`,
-                        source: 'requestBody',
-                    });
-                }
-            }
-            handled = true;
-        }
-        catch { }
-    }
-    if (!handled) {
-        matches.push({
-            path: 'request.body',
-            value: body,
-            context: highlightMatch(body, keyword, CONTEXT_LENGTH_BODY),
-            source: 'requestBody',
-        });
-    }
-};
-export const searchInResponseBody = async (response, keyword, matches) => {
-    const contentTypeHeader = response.headers()['content-type'] || '';
-    if (!(contentTypeHeader.startsWith('text/') || contentTypeHeader.includes('application/json') || contentTypeHeader.includes('application/xml')))
-        return;
-    try {
-        const responseBody = await withTimeout(response.text(), 2000);
-        if (!responseBody || !responseBody.toLowerCase().includes(keyword))
-            return;
-        let handled = false;
-        const trimmed = responseBody.trimStart();
-        const xssiPrefix = ")]}'";
-        const hasXssi = trimmed.startsWith(xssiPrefix);
-        const jsonCandidate = hasXssi ? trimmed.slice(xssiPrefix.length) : trimmed;
-        if (contentTypeHeader.includes('application/json') || jsonCandidate.startsWith('{') || jsonCandidate.startsWith('[')) {
-            try {
-                const parsed = JSON.parse(jsonCandidate);
-                searchInObject(parsed, keyword, 'response.body', matches, 'responseBody');
-                handled = true;
-            }
-            catch { }
-        }
-        if (!handled && (contentTypeHeader.includes('text/html') || responseBody.trim().startsWith('<'))) {
-            searchInHtml(responseBody, keyword, 'response.body', matches, 'responseBody');
-            handled = true;
-        }
-        if (!handled) {
-            matches.push({
-                path: 'response.body',
-                value: responseBody,
-                context: highlightMatch(responseBody, keyword, CONTEXT_LENGTH_BODY),
-                source: 'responseBody',
-            });
-        }
-    }
-    catch { }
-};

package/lib/tools/networkSearch/grouping.js

@@ -1,28 +0,0 @@
-export const normalizePath = (path) => {
-    if (path.includes(' > '))
-        return path.replace(/:nth-child\(\d+\)/g, ':nth-child(*)');
-    return path.replace(/\.(?:\d+)(?=\.|$)/g, '.*');
-};
-export const getDepth = (path) => {
-    const separators = path.match(/\.|>/g) || [];
-    return separators.length;
-};
-export const mergeGroupedMatches = (a, b) => {
-    const map = new Map();
-    for (const g of a)
-        map.set(g.normalized, { normalized: g.normalized, count: g.count, examples: g.examples.slice(0, 3) });
-    for (const g of b) {
-        const existing = map.get(g.normalized);
-        if (existing) {
-            existing.count += g.count;
-            for (const e of g.examples) {
-                if (existing.examples.length < 3 && !existing.examples.some(x => x.context === e.context))
-                    existing.examples.push(e);
-            }
-        }
-        else {
-            map.set(g.normalized, { normalized: g.normalized, count: g.count, examples: g.examples.slice(0, 3) });
-        }
-    }
-    return Array.from(map.values());
-};

package/lib/tools/networkSearch/helpers.js

@@ -1,32 +0,0 @@
-import { truncateStringTo } from '../../utils/truncate.js';
-export const parseKeywordParams = (keyword) => {
-    const out = [];
-    try {
-        const sp = new URLSearchParams(keyword);
-        sp.forEach((value, key) => {
-            if (key)
-                out.push({ name: key, value });
-        });
-    }
-    catch { }
-    return out;
-};
-export const highlightMatch = (text, keyword, maxLength = 50) => {
-    const lowerText = text.toLowerCase();
-    const index = lowerText.indexOf(keyword);
-    if (index === -1)
-        return truncateStringTo(text, maxLength).text;
-    const contextBefore = Math.floor((maxLength - keyword.length) / 2);
-    const contextAfter = maxLength - keyword.length - contextBefore;
-    const start = Math.max(0, index - contextBefore);
-    const end = Math.min(text.length, index + keyword.length + contextAfter);
-    let result = '';
-    if (start > 0)
-        result += '...';
-    result += text.substring(start, index);
-    result += text.substring(index, index + keyword.length);
-    result += text.substring(index + keyword.length, end);
-    if (end < text.length)
-        result += '...';
-    return result;
-};

package/lib/tools/networkSearch/searchHtml.js

@@ -1,67 +0,0 @@
-import * as cheerio from 'cheerio';
-import { highlightMatch } from './helpers.js';
-export const getElementPath = ($el) => {
-    const path = [];
-    let current = $el;
-    while (current.length && current[0].type === 'tag' && current[0].name !== 'html') {
-        let selector = current[0].name.toLowerCase();
-        const id = current.attr('id');
-        if (id) {
-            selector += `#${id}`;
-            path.unshift(selector);
-            break;
-        }
-        const classes = current.attr('class');
-        if (classes)
-            selector += `.${classes.trim().split(/\s+/).join('.')}`;
-        const tagName = current[0].type === 'tag' ? current[0].name : '';
-        const siblings = current.parent().children().filter((_, el) => el.type === 'tag' && el.name === tagName);
-        if (siblings.length > 1) {
-            const index = siblings.index(current) + 1;
-            selector += `:nth-child(${index})`;
-        }
-        path.unshift(selector);
-        current = current.parent();
-    }
-    return path.join(' > ');
-};
-export const searchInHtml = (html, keyword, basePath, matches, source) => {
-    const $ = cheerio.load(html);
-    $('*').contents().each((_, node) => {
-        if (node.type === 'text') {
-            const text = (node.data || '').trim();
-            if (text && text.toLowerCase().includes(keyword)) {
-                const parent = $(node).parent();
-                if (parent.length) {
-                    const elPath = getElementPath(parent);
-                    const path = elPath ? `${basePath} > ${elPath}` : basePath;
-                    matches.push({
-                        path,
-                        value: text,
-                        context: highlightMatch(text, keyword, 300),
-                        source,
-                    });
-                }
-            }
-        }
-    });
-    $('*').each((_, el) => {
-        if (el.type === 'tag') {
-            const attrs = el.attribs;
-            if (attrs) {
-                Object.entries(attrs).forEach(([key, val]) => {
-                    if (typeof val === 'string' && val.toLowerCase().includes(keyword)) {
-                        const elPath = getElementPath($(el));
-                        const path = elPath ? `${basePath} > ${elPath}@${key}` : `${basePath}@${key}`;
-                        matches.push({
-                            path,
-                            value: val,
-                            context: highlightMatch(val, keyword, 300),
-                            source,
-                        });
-                    }
-                });
-            }
-        }
-    });
-};

package/lib/tools/networkSearch/types.js

@@ -1 +0,0 @@
-export {};

package/lib/tools/networkSearch/urlSearch.js

@@ -1,82 +0,0 @@
-import { highlightMatch } from './helpers.js';
-const CONTEXT_LENGTH_DEFAULT = 300;
-export const searchInUrls = (request, response, keyword, keywordParams, matches) => {
-    try {
-        const reqUrl = request.url();
-        const reqUrlLower = reqUrl.toLowerCase();
-        const keywordPathOnly = keyword.split('?')[0];
-        if (reqUrlLower.includes(keyword)) {
-            matches.push({ path: 'request.url', value: reqUrl, context: `url: ${highlightMatch(reqUrl, keyword, CONTEXT_LENGTH_DEFAULT)}`, source: 'requestUrl' });
-        }
-        else if (keywordPathOnly && reqUrlLower.includes(keywordPathOnly)) {
-            matches.push({ path: 'request.url', value: reqUrl, context: `url: ${highlightMatch(reqUrl, keywordPathOnly, CONTEXT_LENGTH_DEFAULT)}`, source: 'requestUrl' });
-        }
-        else {
-            try {
-                const u = new URL(reqUrl);
-                const pathnameLower = u.pathname.toLowerCase();
-                if (pathnameLower.includes(keyword) || (keywordPathOnly && pathnameLower.includes(keywordPathOnly)))
-                    matches.push({ path: 'request.url', value: reqUrl, context: `url: ${highlightMatch(reqUrl, keywordPathOnly || keyword, CONTEXT_LENGTH_DEFAULT)}`, source: 'requestUrl' });
-            }
-            catch { }
-        }
-        if (keywordParams.length) {
-            try {
-                const u = new URL(reqUrl);
-                for (const { name, value } of keywordParams) {
-                    if (!name)
-                        continue;
-                    const pageVal = u.searchParams.get(name);
-                    if (!pageVal)
-                        continue;
-                    const valLower = (value || '').toLowerCase();
-                    if (!valLower)
-                        continue;
-                    const pageValLower = pageVal.toLowerCase();
-                    if (pageValLower.includes(valLower))
-                        matches.push({ path: `request.url.query.${name}`, value: pageVal, context: `${name}=${highlightMatch(pageVal, value, CONTEXT_LENGTH_DEFAULT)}`, source: 'requestUrl' });
-                }
-            }
-            catch { }
-        }
-        if (response) {
-            const resUrl = response.url();
-            const resUrlLower = resUrl.toLowerCase();
-            if (resUrlLower.includes(keyword)) {
-                matches.push({ path: 'response.url', value: resUrl, context: `url: ${highlightMatch(resUrl, keyword, CONTEXT_LENGTH_DEFAULT)}`, source: 'responseUrl' });
-            }
-            else if (keywordPathOnly && resUrlLower.includes(keywordPathOnly)) {
-                matches.push({ path: 'response.url', value: resUrl, context: `url: ${highlightMatch(resUrl, keywordPathOnly, CONTEXT_LENGTH_DEFAULT)}`, source: 'responseUrl' });
-            }
-            else {
-                try {
-                    const u2 = new URL(resUrl);
-                    const pathnameLower2 = u2.pathname.toLowerCase();
-                    if (pathnameLower2.includes(keyword) || (keywordPathOnly && pathnameLower2.includes(keywordPathOnly)))
-                        matches.push({ path: 'response.url', value: resUrl, context: `url: ${highlightMatch(resUrl, keywordPathOnly || keyword, CONTEXT_LENGTH_DEFAULT)}`, source: 'responseUrl' });
-                }
-                catch { }
-            }
-            if (keywordParams.length) {
-                try {
-                    const u2 = new URL(resUrl);
-                    for (const { name, value } of keywordParams) {
-                        if (!name)
-                            continue;
-                        const pageVal = u2.searchParams.get(name);
-                        if (!pageVal)
-                            continue;
-                        const valLower = (value || '').toLowerCase();
-                        if (!valLower)
-                            continue;
-                        const pageValLower = pageVal.toLowerCase();
-                        if (pageValLower.includes(valLower))
-                            matches.push({ path: `response.url.query.${name}`, value: pageVal, context: `${name}=${highlightMatch(pageVal, value, CONTEXT_LENGTH_DEFAULT)}`, source: 'responseUrl' });
-                    }
-                }
-                catch { }
-            }
-        }
-    }
-    catch { }
-};

package/lib/tools/networkSearch.js

@@ -1,268 +0,0 @@
-import { z } from 'zod';
-import { defineTool } from './tool.js';
-import { getNetworkEventEntry } from '../hooks/networkSetup.js';
-import { listNetworkEvents } from '../hooks/networkTrackingHook.js';
-import { normalizeUrlForGrouping } from '../hooks/networkFilters.js';
-import { formatNetworkSummaryLine } from '../utils/networkFormat.js';
-import { toJsonPathNormalized, truncateStringTo } from '../utils/truncate.js';
-import { searchInUrls } from './networkSearch/urlSearch.js';
-import { searchInRequestBody, searchInResponseBody } from './networkSearch/bodySearch.js';
-import { normalizePath, getDepth, mergeGroupedMatches } from './networkSearch/grouping.js';
-import { parseKeywordParams, highlightMatch } from './networkSearch/helpers.js';
-const MAX_SEARCH_RESULTS = 10;
-const MAX_GROUPS_TO_SHOW = 3;
-const networkSearchSchema = z.object({
-    keyword: z.string().describe('Keyword or phrase; avoid generic words—specific terms reduce noise and improve precision.'),
-});
-const createSourceCounts = () => ({
-    requestUrl: 0,
-    requestBody: 0,
-    responseUrl: 0,
-    responseBody: 0,
-    responseHeaders: 0,
-});
-const accumulateSourceCounts = (records) => {
-    const counts = createSourceCounts();
-    for (const record of records)
-        counts[record.source] += 1;
-    return counts;
-};
-const cloneSourceCounts = (counts) => ({
-    requestUrl: counts.requestUrl,
-    requestBody: counts.requestBody,
-    responseUrl: counts.responseUrl,
-    responseBody: counts.responseBody,
-    responseHeaders: counts.responseHeaders,
-});
-const computeEventScore = (match) => {
-    const ageMs = Math.max(0, Date.now() - match.timestamp);
-    const recencyWindowMs = 10 * 60 * 1000;
-    const recencyBoost = 1 - Math.min(ageMs / recencyWindowMs, 1);
-    const base = match.totalMatches;
-    const responseBonus = match.sourceCounts.responseBody * 2;
-    const requestBonus = match.sourceCounts.requestBody;
-    const urlBonus = (match.sourceCounts.requestUrl + match.sourceCounts.responseUrl) * 0.25;
-    const headerBonus = match.sourceCounts.responseHeaders;
-    return base + responseBonus + requestBonus + urlBonus + headerBonus + recencyBoost;
-};
-const formatGroupPath = (group) => {
-    const normalized = group.normalized;
-    const jsonPath = toJsonPathNormalized(normalized);
-    if (jsonPath)
-        return `json: ${jsonPath.jsonPath}`;
-    if (!normalized.includes(' > '))
-        return normalized;
-    const withoutWildcard = normalized.replace(/:nth-child\(\*\)/g, '');
-    const trimmedPrefix = withoutWildcard.startsWith('response.body')
-        ? withoutWildcard.slice('response.body'.length).trim()
-        : withoutWildcard.startsWith('request.body')
-            ? withoutWildcard.slice('request.body'.length).trim()
-            : withoutWildcard;
-    const noLeadingArrow = trimmedPrefix.startsWith('>')
-        ? trimmedPrefix.slice(1).trim()
-        : trimmedPrefix;
-    return `css: ${noLeadingArrow}`;
-};
-const extractExamples = (group) => {
-    const items = [];
-    for (const example of group.examples) {
-        const raw = example.value ?? example.context;
-        if (!raw)
-            continue;
-        const trimmed = raw.trim();
-        const base = trimmed.length > 0 ? trimmed : raw;
-        const { text } = truncateStringTo(base, 160);
-        if (!items.includes(text))
-            items.push(text);
-    }
-    return items;
-};
-const searchInResponseSetCookies = async (response, keyword, matches) => {
-    const cookies = await response.headerValues('set-cookie').catch(() => []);
-    if (!cookies.length)
-        return;
-    for (const [index, cookie] of cookies.entries()) {
-        if (!cookie.toLowerCase().includes(keyword))
-            continue;
-        matches.push({
-            path: `response.headers.set-cookie[${index}]`,
-            value: cookie,
-            context: highlightMatch(cookie, keyword, 120),
-            source: 'responseHeaders',
-        });
-    }
-};
-const networkSearch = defineTool({
-    capability: 'core',
-    schema: {
-        name: 'browser_network_search',
-        title: 'Search network requests',
-        description: 'Search for keywords in network request/response bodies and URLs',
-        inputSchema: networkSearchSchema,
-        type: 'readOnly',
-    },
-    handle: async (context, params, response) => {
-        await context.ensureTab();
-        try {
-            const keyword = params.keyword?.toLowerCase();
-            if (!keyword) {
-                response.addResult('keyword parameter is required');
-                return;
-            }
-            const events = listNetworkEvents(context);
-            const keywordParams = parseKeywordParams(params.keyword);
-            const searchMatches = [];
-            for (const ev of events) {
-                const entry = getNetworkEventEntry(context, ev.id);
-                if (!entry)
-                    continue;
-                const request = entry.request;
-                const resp = entry.response ?? null;
-                const matches = [];
-                searchInUrls(request, resp, keyword, keywordParams, matches);
-                searchInRequestBody(request, keyword, matches);
-                if (resp) {
-                    await searchInResponseBody(resp, keyword, matches);
-                    await searchInResponseSetCookies(resp, keyword, matches);
-                }
-                if (matches.length > 0) {
-                    const groupMap = new Map();
-                    for (const m of matches) {
-                        const normalized = normalizePath(m.path);
-                        let group = groupMap.get(normalized);
-                        if (!group) {
-                            group = { normalized, count: 0, examples: [] };
-                            groupMap.set(normalized, group);
-                        }
-                        group.count++;
-                        if (group.examples.length < 3) {
-                            const example = { context: m.context, value: m.value, originalPath: m.path !== normalized ? m.path : undefined };
-                            if (!group.examples.some(e => e.context === example.context))
-                                group.examples.push(example);
-                        }
-                    }
-                    const groups = Array.from(groupMap.values()).sort((a, b) => b.count - a.count || getDepth(b.normalized) - getDepth(a.normalized));
-                    const totalMatches = matches.length;
-                    const sourceCounts = accumulateSourceCounts(matches);
-                    searchMatches.push({
-                        requestId: ev.id,
-                        timestamp: ev.timestamp,
-                        count: 1,
-                        groups,
-                        totalMatches,
-                        sourceCounts,
-                        request,
-                        response: resp,
-                    });
-                }
-            }
-            if (searchMatches.length === 0) {
-                response.addResult(`No network requests found containing keyword: "${params.keyword}"`);
-                return;
-            }
-            const aggMap = new Map();
-            for (const m of searchMatches) {
-                const key = `${m.request.method().toUpperCase()} ${normalizeUrlForGrouping(m.request.url())}`;
-                const existing = aggMap.get(key);
-                const eventScore = computeEventScore(m);
-                if (!existing) {
-                    aggMap.set(key, {
-                        key,
-                        request: m.request,
-                        response: m.response,
-                        ids: [m.requestId],
-                        count: m.count,
-                        totalMatches: m.totalMatches,
-                        groups: [...m.groups],
-                        primaryGroups: m.groups,
-                        primaryEventId: m.requestId,
-                        primaryTimestamp: m.timestamp,
-                        primarySourceCounts: cloneSourceCounts(m.sourceCounts),
-                        primaryMatches: m.totalMatches,
-                        primaryScore: eventScore,
-                    });
-                    continue;
-                }
-                existing.ids.push(m.requestId);
-                existing.count += m.count;
-                existing.totalMatches += m.totalMatches;
-                existing.groups = mergeGroupedMatches(existing.groups, m.groups);
-                if (!existing.response && m.response)
-                    existing.response = m.response;
-                const replacePrimary = eventScore > existing.primaryScore || (eventScore === existing.primaryScore && m.timestamp > existing.primaryTimestamp);
-                if (!replacePrimary)
-                    continue;
-                existing.request = m.request;
-                existing.response = m.response;
-                existing.primaryGroups = m.groups;
-                existing.primaryEventId = m.requestId;
-                existing.primaryTimestamp = m.timestamp;
-                existing.primarySourceCounts = cloneSourceCounts(m.sourceCounts);
-                existing.primaryMatches = m.totalMatches;
-                existing.primaryScore = eventScore;
-            }
-            const aggregatedMatches = Array.from(aggMap.values()).sort((a, b) => {
-                if (a.primaryScore !== b.primaryScore)
-                    return b.primaryScore - a.primaryScore;
-                if (a.primaryMatches !== b.primaryMatches)
-                    return b.primaryMatches - a.primaryMatches;
-                return b.primaryTimestamp - a.primaryTimestamp;
-            });
-            const topMatches = aggregatedMatches.slice(0, MAX_SEARCH_RESULTS);
-            const structured = {
-                keyword: params.keyword,
-                requests: topMatches.map(m => {
-                    const method = m.request.method().toUpperCase();
-                    const url = m.request.url();
-                    // Normalize URL for grouping only; not returned in output
-                    const status = m.response ? m.response.status() : undefined;
-                    const queryKeys = (() => {
-                        try {
-                            const u = new URL(url);
-                            const keys = new Set();
-                            u.searchParams.forEach((_, k) => {
-                                if (k)
-                                    keys.add(k);
-                            });
-                            return Array.from(keys);
-                        }
-                        catch {
-                            return [];
-                        }
-                    })();
-                    const primaryGroups = m.primaryGroups
-                        .slice()
-                        .sort((a, b) => b.count - a.count || getDepth(b.normalized) - getDepth(a.normalized))
-                        .slice(0, MAX_GROUPS_TO_SHOW);
-                    const paths = primaryGroups.map(group => ({
-                        path: formatGroupPath(group),
-                        examples: extractExamples(group),
-                    }));
-                    const sourceCounts = cloneSourceCounts(m.primarySourceCounts);
-                    const score = Number(m.primaryScore.toFixed(2));
-                    return {
-                        summary: formatNetworkSummaryLine({
-                            method,
-                            url,
-                            status: status || 0,
-                            statusText: m.response?.statusText(),
-                            postData: m.request.postData(),
-                            headers: {},
-                        }),
-                        primaryEventId: m.primaryEventId,
-                        eventIds: m.ids.slice(0, 5),
-                        score,
-                        sourceCounts,
-                        params: queryKeys.slice(0, 6),
-                        paths,
-                    };
-                })
-            };
-            response.addResult(JSON.stringify(structured));
-        }
-        catch (error) {
-            response.addResult(`Failed to search network requests: ${error.message}`);
-        }
-    },
-});
-export default [networkSearch];

package/lib/tools/pdf.js

@@ -1,40 +0,0 @@
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { z } from 'zod';
-import { defineTabTool } from './tool.js';
-import * as javascript from '../utils/codegen.js';
-const pdfSchema = z.object({
-    filename: z.string().optional().describe('File name to save the pdf to. Defaults to `page-{timestamp}.pdf` if not specified.'),
-});
-const pdf = defineTabTool({
-    capability: 'pdf',
-    schema: {
-        name: 'browser_pdf_save',
-        title: 'Save as PDF',
-        description: 'Save page as PDF',
-        inputSchema: pdfSchema,
-        type: 'readOnly',
-    },
-    handle: async (tab, params, response) => {
-        const fileName = await tab.context.outputFile(params.filename ?? `page-${new Date().toISOString()}.pdf`);
-        response.addCode(`await page.pdf(${javascript.formatObject({ path: fileName })});`);
-        response.addResult(`Saved page as ${fileName}`);
-        await tab.page.pdf({ path: fileName });
-    },
-});
-export default [
-    pdf,
-];