@wordbricks/playwright-mcp 0.1.19 → 0.1.22

package/lib/tools/networkSearch/bodySearch.js

@@ -1,28 +1,30 @@
-import { withTimeout } from '../../utils/withTimeout.js';
-import { searchInHtml } from './searchHtml.js';
-import { highlightMatch } from './helpers.js';
+import { withTimeout } from "../../utils/withTimeout.js";
+import { highlightMatch } from "./helpers.js";
+import { searchInHtml } from "./searchHtml.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')
+    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
+            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),
+                value: typeof value === "object" && value !== null
+                    ? JSON.stringify(value)
+                    : String(value),
                 context: `${highlightedKey}: ${valueContext}`,
                 source,
             });
         }
-        if (typeof value === 'string' && value.toLowerCase().includes(keyword)) {
+        if (typeof value === "string" && value.toLowerCase().includes(keyword)) {
             matches.push({
                 path: newPath,
                 value: value,
@@ -30,7 +32,7 @@ export const searchInObject = (obj, keyword, path, matches, source, depth = 0) =
                 source,
             });
         }
-        else if (typeof value === 'number' && String(value).includes(keyword)) {
+        else if (typeof value === "number" && String(value).includes(keyword)) {
             const valueStr = String(value);
             matches.push({
                 path: newPath,
@@ -39,50 +41,56 @@ export const searchInObject = (obj, keyword, path, matches, source, depth = 0) =
                 source,
             });
         }
-        if (typeof value === 'object' && value !== null)
+        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 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) + '...';
+        return JSON.stringify(obj).slice(0, CONTEXT_LENGTH_BODY) + "...";
     }
     catch {
-        return '[Object]';
+        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'] || '';
+    const requestContentType = request.headers()["content-type"] || "";
     let handled = false;
-    if (requestContentType.includes('application/json') || body.trim().startsWith('{') || body.trim().startsWith('[')) {
+    if (requestContentType.includes("application/json") ||
+        body.trim().startsWith("{") ||
+        body.trim().startsWith("[")) {
         try {
             const parsed = JSON.parse(body);
-            searchInObject(parsed, keyword, 'request.body', matches, 'requestBody');
+            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');
+    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')) {
+    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 || '';
+                const vStr = v || "";
                 if (!vStr.toLowerCase().includes(keyword))
                     continue;
                 const trimmed = vStr.trim();
                 let parsedOk = false;
-                if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+                if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
                     try {
                         const parsed = JSON.parse(trimmed);
-                        searchInObject(parsed, keyword, `request.body.form.${k}`, matches, 'requestBody');
+                        searchInObject(parsed, keyword, `request.body.form.${k}`, matches, "requestBody");
                         parsedOk = true;
                     }
                     catch { }
@@ -92,7 +100,7 @@ export const searchInRequestBody = (request, keyword, matches) => {
                         path: `request.body.form.${k}`,
                         value: vStr,
                         context: `${k}=${highlightMatch(vStr, keyword, CONTEXT_LENGTH_DEFAULT)}`,
-                        source: 'requestBody',
+                        source: "requestBody",
                     });
                 }
             }
@@ -102,16 +110,18 @@ export const searchInRequestBody = (request, keyword, matches) => {
     }
     if (!handled) {
         matches.push({
-            path: 'request.body',
+            path: "request.body",
             value: body,
             context: highlightMatch(body, keyword, CONTEXT_LENGTH_BODY),
-            source: 'requestBody',
+            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')))
+    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);
@@ -122,24 +132,28 @@ export const searchInResponseBody = async (response, keyword, matches) => {
         const xssiPrefix = ")]}'";
         const hasXssi = trimmed.startsWith(xssiPrefix);
         const jsonCandidate = hasXssi ? trimmed.slice(xssiPrefix.length) : trimmed;
-        if (contentTypeHeader.includes('application/json') || jsonCandidate.startsWith('{') || jsonCandidate.startsWith('[')) {
+        if (contentTypeHeader.includes("application/json") ||
+            jsonCandidate.startsWith("{") ||
+            jsonCandidate.startsWith("[")) {
             try {
                 const parsed = JSON.parse(jsonCandidate);
-                searchInObject(parsed, keyword, 'response.body', matches, 'responseBody');
+                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');
+        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',
+                path: "response.body",
                 value: responseBody,
                 context: highlightMatch(responseBody, keyword, CONTEXT_LENGTH_BODY),
-                source: 'responseBody',
+                source: "responseBody",
             });
         }
     }

package/lib/tools/networkSearch/grouping.js

@@ -1,7 +1,7 @@
 export const normalizePath = (path) => {
-    if (path.includes(' > '))
-        return path.replace(/:nth-child\(\d+\)/g, ':nth-child(*)');
-    return path.replace(/\.(?:\d+)(?=\.|$)/g, '.*');
+    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) || [];
@@ -10,18 +10,27 @@ export const getDepth = (path) => {
 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) });
+        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))
+                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) });
+            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,4 +1,4 @@
-import { truncateStringTo } from '../../utils/truncate.js';
+import { truncateStringTo } from "../../utils/truncate.js";
 export const parseKeywordParams = (keyword) => {
     const out = [];
     try {
@@ -20,13 +20,13 @@ export const highlightMatch = (text, keyword, maxLength = 50) => {
     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 = '';
+    let result = "";
     if (start > 0)
-        result += '...';
+        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 += '...';
+        result += "...";
     return result;
 };

package/lib/tools/networkSearch/searchHtml.js

@@ -1,21 +1,26 @@
-import * as cheerio from 'cheerio';
-import { highlightMatch } from './helpers.js';
+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') {
+    while (current.length &&
+        current[0].type === "tag" &&
+        current[0].name !== "html") {
         let selector = current[0].name.toLowerCase();
-        const id = current.attr('id');
+        const id = current.attr("id");
         if (id) {
             selector += `#${id}`;
             path.unshift(selector);
             break;
         }
-        const classes = current.attr('class');
+        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);
+            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})`;
@@ -23,13 +28,15 @@ export const getElementPath = ($el) => {
         path.unshift(selector);
         current = current.parent();
     }
-    return path.join(' > ');
+    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();
+    $("*")
+        .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) {
@@ -45,14 +52,16 @@ export const searchInHtml = (html, keyword, basePath, matches, source) => {
             }
         }
     });
-    $('*').each((_, el) => {
-        if (el.type === 'tag') {
+    $("*").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)) {
+                    if (typeof val === "string" && val.toLowerCase().includes(keyword)) {
                         const elPath = getElementPath($(el));
-                        const path = elPath ? `${basePath} > ${elPath}@${key}` : `${basePath}@${key}`;
+                        const path = elPath
+                            ? `${basePath} > ${elPath}@${key}`
+                            : `${basePath}@${key}`;
                         matches.push({
                             path,
                             value: val,

package/lib/tools/networkSearch/urlSearch.js

@@ -1,22 +1,38 @@
-import { highlightMatch } from './helpers.js';
+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];
+        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' });
+            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' });
+            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' });
+                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 { }
         }
@@ -29,12 +45,17 @@ export const searchInUrls = (request, response, keyword, keywordParams, matches)
                     const pageVal = u.searchParams.get(name);
                     if (!pageVal)
                         continue;
-                    const valLower = (value || '').toLowerCase();
+                    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' });
+                        matches.push({
+                            path: `request.url.query.${name}`,
+                            value: pageVal,
+                            context: `${name}=${highlightMatch(pageVal, value, CONTEXT_LENGTH_DEFAULT)}`,
+                            source: "requestUrl",
+                        });
                 }
             }
             catch { }
@@ -43,17 +64,33 @@ export const searchInUrls = (request, response, keyword, keywordParams, matches)
             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' });
+                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' });
+                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' });
+                    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 { }
             }
@@ -66,12 +103,17 @@ export const searchInUrls = (request, response, keyword, keywordParams, matches)
                         const pageVal = u2.searchParams.get(name);
                         if (!pageVal)
                             continue;
-                        const valLower = (value || '').toLowerCase();
+                        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' });
+                            matches.push({
+                                path: `response.url.query.${name}`,
+                                value: pageVal,
+                                context: `${name}=${highlightMatch(pageVal, value, CONTEXT_LENGTH_DEFAULT)}`,
+                                source: "responseUrl",
+                            });
                     }
                 }
                 catch { }

package/lib/tools/networkSearch.js

@@ -1,24 +1,27 @@
-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 } from './networkSearch/helpers.js';
+import { z } from "zod";
+import { normalizeUrlForGrouping } from "../hooks/networkFilters.js";
+import { getNetworkEventEntry } from "../hooks/networkSetup.js";
+import { listNetworkEvents } from "../hooks/networkTrackingHook.js";
+import { formatNetworkSummaryLine } from "../utils/networkFormat.js";
+import { toJsonPathNormalized, truncateStringTo } from "../utils/truncate.js";
+import { searchInRequestBody, searchInResponseBody, } from "./networkSearch/bodySearch.js";
+import { getDepth, mergeGroupedMatches, normalizePath, } from "./networkSearch/grouping.js";
+import { highlightMatch, parseKeywordParams } from "./networkSearch/helpers.js";
+import { searchInUrls } from "./networkSearch/urlSearch.js";
+import { defineTool } from "./tool.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.'),
+    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();
@@ -31,6 +34,7 @@ const cloneSourceCounts = (counts) => ({
     requestBody: counts.requestBody,
     responseUrl: counts.responseUrl,
     responseBody: counts.responseBody,
+    responseHeaders: counts.responseHeaders,
 });
 const computeEventScore = (match) => {
     const ageMs = Math.max(0, Date.now() - match.timestamp);
@@ -40,22 +44,23 @@ const computeEventScore = (match) => {
     const responseBonus = match.sourceCounts.responseBody * 2;
     const requestBonus = match.sourceCounts.requestBody;
     const urlBonus = (match.sourceCounts.requestUrl + match.sourceCounts.responseUrl) * 0.25;
-    return base + responseBonus + requestBonus + urlBonus + recencyBoost;
+    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(' > '))
+    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()
+    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('>')
+    const noLeadingArrow = trimmedPrefix.startsWith(">")
         ? trimmedPrefix.slice(1).trim()
         : trimmedPrefix;
     return `css: ${noLeadingArrow}`;
@@ -74,21 +79,36 @@ const extractExamples = (group) => {
     }
     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',
+    capability: "core",
     schema: {
-        name: 'browser_network_search',
-        title: 'Search network requests',
-        description: 'Search for keywords in network request/response bodies and URLs',
+        name: "browser_network_search",
+        title: "Search network requests",
+        description: "Search for keywords in network request/response bodies and URLs",
         inputSchema: networkSearchSchema,
-        type: 'readOnly',
+        type: "readOnly",
     },
     handle: async (context, params, response) => {
         await context.ensureTab();
         try {
             const keyword = params.keyword?.toLowerCase();
             if (!keyword) {
-                response.addResult('keyword parameter is required');
+                response.addResult("keyword parameter is required");
                 return;
             }
             const events = listNetworkEvents(context);
@@ -103,8 +123,10 @@ const networkSearch = defineTool({
                 const matches = [];
                 searchInUrls(request, resp, keyword, keywordParams, matches);
                 searchInRequestBody(request, keyword, matches);
-                if (resp)
+                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) {
@@ -116,12 +138,17 @@ const networkSearch = defineTool({
                         }
                         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))
+                            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 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({
@@ -169,7 +196,9 @@ const networkSearch = defineTool({
                 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);
+                const replacePrimary = eventScore > existing.primaryScore ||
+                    (eventScore === existing.primaryScore &&
+                        m.timestamp > existing.primaryTimestamp);
                 if (!replacePrimary)
                     continue;
                 existing.request = m.request;
@@ -191,7 +220,7 @@ const networkSearch = defineTool({
             const topMatches = aggregatedMatches.slice(0, MAX_SEARCH_RESULTS);
             const structured = {
                 keyword: params.keyword,
-                requests: topMatches.map(m => {
+                requests: topMatches.map((m) => {
                     const method = m.request.method().toUpperCase();
                     const url = m.request.url();
                     // Normalize URL for grouping only; not returned in output
@@ -212,9 +241,10 @@ const networkSearch = defineTool({
                     })();
                     const primaryGroups = m.primaryGroups
                         .slice()
-                        .sort((a, b) => b.count - a.count || getDepth(b.normalized) - getDepth(a.normalized))
+                        .sort((a, b) => b.count - a.count ||
+                        getDepth(b.normalized) - getDepth(a.normalized))
                         .slice(0, MAX_GROUPS_TO_SHOW);
-                    const paths = primaryGroups.map(group => ({
+                    const paths = primaryGroups.map((group) => ({
                         path: formatGroupPath(group),
                         examples: extractExamples(group),
                     }));
@@ -236,7 +266,7 @@ const networkSearch = defineTool({
                         params: queryKeys.slice(0, 6),
                         paths,
                     };
-                })
+                }),
             };
             response.addResult(JSON.stringify(structured));
         }