browser-debug-mcp-bridge 1.5.0 → 1.9.0

package/apps/mcp-server/dist/mcp/server.js

@@ -27,6 +27,7 @@ const TOOL_SCHEMAS = {
             sinceMinutes: { type: 'number' },
             limit: { type: 'number' },
             offset: { type: 'number' },
+            maxResponseBytes: { type: 'number' },
         },
     },
     get_session_summary: {
@@ -38,31 +39,60 @@ const TOOL_SCHEMAS = {
     },
     get_recent_events: {
         type: 'object',
-        required: ['sessionId'],
         properties: {
             sessionId: { type: 'string' },
+            url: { type: 'string' },
             eventTypes: { type: 'array', items: { type: 'string' } },
             limit: { type: 'number' },
             offset: { type: 'number' },
+            responseProfile: { type: 'string' },
+            includePayload: { type: 'boolean' },
+            maxResponseBytes: { type: 'number' },
         },
     },
     get_navigation_history: {
         type: 'object',
-        required: ['sessionId'],
         properties: {
             sessionId: { type: 'string' },
+            url: { type: 'string' },
             limit: { type: 'number' },
             offset: { type: 'number' },
+            responseProfile: { type: 'string' },
+            includePayload: { type: 'boolean' },
+            maxResponseBytes: { type: 'number' },
         },
     },
     get_console_events: {
         type: 'object',
-        required: ['sessionId'],
         properties: {
             sessionId: { type: 'string' },
+            url: { type: 'string' },
             level: { type: 'string' },
             limit: { type: 'number' },
             offset: { type: 'number' },
+            responseProfile: { type: 'string' },
+            includePayload: { type: 'boolean' },
+            maxResponseBytes: { type: 'number' },
+        },
+    },
+    get_console_summary: {
+        type: 'object',
+        properties: {
+            sessionId: { type: 'string' },
+            url: { type: 'string' },
+            level: { type: 'string' },
+            sinceMinutes: { type: 'number' },
+            limit: { type: 'number' },
+        },
+    },
+    get_event_summary: {
+        type: 'object',
+        properties: {
+            sessionId: { type: 'string' },
+            url: { type: 'string' },
+            eventTypes: { type: 'array', items: { type: 'string' } },
+            sinceMinutes: { type: 'number' },
+            limit: { type: 'number' },
         },
     },
     get_error_fingerprints: {
@@ -72,16 +102,68 @@ const TOOL_SCHEMAS = {
             sinceMinutes: { type: 'number' },
             limit: { type: 'number' },
             offset: { type: 'number' },
+            maxResponseBytes: { type: 'number' },
         },
     },
     get_network_failures: {
         type: 'object',
         properties: {
             sessionId: { type: 'string' },
+            url: { type: 'string' },
             errorType: { type: 'string' },
             groupBy: { type: 'string' },
             limit: { type: 'number' },
             offset: { type: 'number' },
+            maxResponseBytes: { type: 'number' },
+        },
+    },
+    get_network_calls: {
+        type: 'object',
+        required: ['sessionId'],
+        properties: {
+            sessionId: { type: 'string' },
+            urlContains: { type: 'string' },
+            urlRegex: { type: 'string' },
+            method: { type: 'string' },
+            statusIn: { type: 'array', items: { type: 'number' } },
+            tabId: { type: 'number' },
+            timeFrom: { type: 'number' },
+            timeTo: { type: 'number' },
+            includeBodies: { type: 'boolean' },
+            limit: { type: 'number' },
+            offset: { type: 'number' },
+            maxResponseBytes: { type: 'number' },
+        },
+    },
+    wait_for_network_call: {
+        type: 'object',
+        required: ['sessionId', 'urlPattern'],
+        properties: {
+            sessionId: { type: 'string' },
+            urlPattern: { type: 'string' },
+            method: { type: 'string' },
+            timeoutMs: { type: 'number' },
+            includeBodies: { type: 'boolean' },
+        },
+    },
+    get_request_trace: {
+        type: 'object',
+        properties: {
+            sessionId: { type: 'string' },
+            requestId: { type: 'string' },
+            traceId: { type: 'string' },
+            includeBodies: { type: 'boolean' },
+            eventLimit: { type: 'number' },
+        },
+    },
+    get_body_chunk: {
+        type: 'object',
+        required: ['chunkRef'],
+        properties: {
+            chunkRef: { type: 'string' },
+            sessionId: { type: 'string' },
+            offset: { type: 'number' },
+            limit: { type: 'number' },
         },
     },
     get_element_refs: {
@@ -92,6 +174,7 @@ const TOOL_SCHEMAS = {
             selector: { type: 'string' },
             limit: { type: 'number' },
             offset: { type: 'number' },
+            maxResponseBytes: { type: 'number' },
         },
     },
     get_dom_subtree: {
@@ -141,6 +224,27 @@ const TOOL_SCHEMAS = {
             maxDepth: { type: 'number' },
             maxBytes: { type: 'number' },
             maxAncestors: { type: 'number' },
+            includeDom: { type: 'boolean' },
+            includeStyles: { type: 'boolean' },
+            includePngDataUrl: { type: 'boolean' },
+        },
+    },
+    get_live_console_logs: {
+        type: 'object',
+        required: ['sessionId'],
+        properties: {
+            sessionId: { type: 'string' },
+            url: { type: 'string' },
+            tabId: { type: 'number' },
+            levels: { type: 'array', items: { type: 'string' } },
+            contains: { type: 'string' },
+            sinceTs: { type: 'number' },
+            includeRuntimeErrors: { type: 'boolean' },
+            dedupeWindowMs: { type: 'number' },
+            limit: { type: 'number' },
+            responseProfile: { type: 'string' },
+            includeArgs: { type: 'boolean' },
+            maxResponseBytes: { type: 'number' },
         },
     },
     explain_last_failure: {
@@ -170,6 +274,7 @@ const TOOL_SCHEMAS = {
             untilTimestamp: { type: 'number' },
             limit: { type: 'number' },
             offset: { type: 'number' },
+            maxResponseBytes: { type: 'number' },
         },
     },
     get_snapshot_for_event: {
@@ -200,14 +305,21 @@ const TOOL_DESCRIPTIONS = {
     get_recent_events: 'Read recent events from a session',
     get_navigation_history: 'Read navigation events for a session',
     get_console_events: 'Read console events for a session',
+    get_console_summary: 'Summarize console volume and top repeated messages',
+    get_event_summary: 'Summarize event volume and type distribution',
     get_error_fingerprints: 'List aggregated error fingerprints',
     get_network_failures: 'List network failures and groupings',
+    get_network_calls: 'Query network calls with targeted filters and optional sanitized bodies',
+    wait_for_network_call: 'Wait for the next matching network call and return it deterministically',
+    get_request_trace: 'Get correlated UI/events/network chain by requestId or traceId',
+    get_body_chunk: 'Retrieve a chunk from a stored large body payload',
     get_element_refs: 'Get element references by selector',
     get_dom_subtree: 'Capture a bounded DOM subtree',
     get_dom_document: 'Capture full document as outline or html',
     get_computed_styles: 'Read computed CSS styles for an element',
     get_layout_metrics: 'Read viewport and element layout metrics',
     capture_ui_snapshot: 'Capture redacted UI snapshot (DOM/styles/optional PNG) and persist it',
+    get_live_console_logs: 'Read in-memory live console logs for a connected session',
     explain_last_failure: 'Explain the latest failure timeline',
     get_event_correlation: 'Correlate related events by window',
     list_snapshots: 'List snapshot metadata by session/time/trigger',
@@ -223,9 +335,21 @@ const DEFAULT_REDACTION_SUMMARY = {
 const DEFAULT_LIST_LIMIT = 25;
 const DEFAULT_EVENT_LIMIT = 50;
 const MAX_LIMIT = 200;
+const DEFAULT_MAX_RESPONSE_BYTES = 32 * 1024;
+const MAX_RESPONSE_BYTES = 512 * 1024;
 const DEFAULT_SNAPSHOT_ASSET_CHUNK_BYTES = 64 * 1024;
 const MAX_SNAPSHOT_ASSET_CHUNK_BYTES = 256 * 1024;
+const DEFAULT_BODY_CHUNK_BYTES = 64 * 1024;
+const MAX_BODY_CHUNK_BYTES = 256 * 1024;
+const DEFAULT_NETWORK_POLL_TIMEOUT_MS = 15_000;
+const MAX_NETWORK_POLL_TIMEOUT_MS = 120_000;
+const DEFAULT_NETWORK_POLL_INTERVAL_MS = 250;
 const LIVE_SESSION_DISCONNECTED_CODE = 'LIVE_SESSION_DISCONNECTED';
+const NETWORK_CALL_SELECT_COLUMNS = `
+  request_id, session_id, trace_id, tab_id, ts_start, duration_ms, method, url, origin, status, initiator, error_class, response_size_est,
+  request_content_type, request_body_text, request_body_json, request_body_bytes, request_body_truncated, request_body_chunk_ref,
+  response_content_type, response_body_text, response_body_json, response_body_bytes, response_body_truncated, response_body_chunk_ref
+`;
 const NETWORK_DOMAIN_GROUP_SQL = `
   CASE
     WHEN instr(replace(replace(url, 'https://', ''), 'http://', ''), '/') > 0
@@ -264,6 +388,62 @@ function resolveOffset(value) {
     const floored = Math.floor(value);
     return floored < 0 ? 0 : floored;
 }
+function resolveResponseProfile(value) {
+    return value === 'compact' ? 'compact' : 'legacy';
+}
+function resolveMaxResponseBytes(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return DEFAULT_MAX_RESPONSE_BYTES;
+    }
+    const floored = Math.floor(value);
+    if (floored < 1_024) {
+        return DEFAULT_MAX_RESPONSE_BYTES;
+    }
+    return Math.min(floored, MAX_RESPONSE_BYTES);
+}
+function estimateJsonBytes(value) {
+    return Buffer.byteLength(JSON.stringify(value), 'utf-8');
+}
+function applyByteBudget(items, maxResponseBytes) {
+    if (items.length === 0) {
+        return {
+            items: [],
+            responseBytes: 2, // []
+            truncatedByBytes: false,
+        };
+    }
+    const selected = [];
+    let usedBytes = 2; // []
+    let truncatedByBytes = false;
+    for (const item of items) {
+        const itemBytes = estimateJsonBytes(item);
+        const separatorBytes = selected.length > 0 ? 1 : 0; // comma
+        const nextBytes = usedBytes + separatorBytes + itemBytes;
+        if (nextBytes > maxResponseBytes && selected.length > 0) {
+            truncatedByBytes = true;
+            break;
+        }
+        selected.push(item);
+        usedBytes = nextBytes;
+    }
+    if (!truncatedByBytes && selected.length < items.length) {
+        truncatedByBytes = true;
+    }
+    return {
+        items: selected,
+        responseBytes: usedBytes,
+        truncatedByBytes,
+    };
+}
+function buildOffsetPagination(offset, returned, hasMore, maxResponseBytes) {
+    return {
+        offset,
+        returned,
+        hasMore,
+        nextOffset: hasMore ? offset + returned : null,
+        maxResponseBytes,
+    };
+}
 function readJsonPayload(payloadJson) {
     try {
         const parsed = JSON.parse(payloadJson);
@@ -303,6 +483,65 @@ function parseRequestedTypes(value) {
         .map((entry) => mapRequestedEventType(entry));
     return Array.from(new Set(normalized));
 }
+function normalizeRequestedOrigin(value) {
+    if (value === undefined || value === null || value === '') {
+        return undefined;
+    }
+    if (typeof value !== 'string') {
+        throw new Error('url must be a string');
+    }
+    try {
+        const parsed = new URL(value);
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+            throw new Error('url must use http:// or https://');
+        }
+        return parsed.origin;
+    }
+    catch {
+        throw new Error('url must be a valid absolute http(s) URL');
+    }
+}
+function ensureSessionOrOriginFilter(sessionId, origin) {
+    if (!sessionId && !origin) {
+        throw new Error('sessionId or url is required');
+    }
+}
+function resolveUrlPrefixFromOrigin(origin) {
+    return origin.endsWith('/') ? origin : origin + '/';
+}
+function appendEventOriginFilter(where, params, origin) {
+    if (!origin) {
+        return;
+    }
+    const prefix = resolveUrlPrefixFromOrigin(origin);
+    where.push(`
+    (
+      origin = ?
+      OR (
+        origin IS NULL AND (
+          json_extract(payload_json, '$.origin') = ?
+          OR json_extract(payload_json, '$.url') = ?
+          OR json_extract(payload_json, '$.url') LIKE ?
+          OR json_extract(payload_json, '$.to') = ?
+          OR json_extract(payload_json, '$.to') LIKE ?
+          OR json_extract(payload_json, '$.href') = ?
+          OR json_extract(payload_json, '$.href') LIKE ?
+          OR json_extract(payload_json, '$.location') = ?
+          OR json_extract(payload_json, '$.location') LIKE ?
+        )
+      )
+    )
+  `);
+    params.push(origin, origin, origin, `${prefix}%`, origin, `${prefix}%`, origin, `${prefix}%`, origin, `${prefix}%`);
+}
+function appendNetworkOriginFilter(where, params, origin) {
+    if (!origin) {
+        return;
+    }
+    const prefix = resolveUrlPrefixFromOrigin(origin);
+    where.push('(origin = ? OR (origin IS NULL AND (url = ? OR url LIKE ?)))');
+    params.push(origin, origin, `${prefix}%`);
+}
 function resolveLastUrl(payload) {
     const candidates = [payload.url, payload.to, payload.href, payload.location];
     for (const candidate of candidates) {
@@ -312,13 +551,38 @@ function resolveLastUrl(payload) {
     }
     return undefined;
 }
-function mapEventRecord(row) {
+function mapEventRecord(row, profile = 'legacy', options = {}) {
+    const payload = readJsonPayload(row.payload_json);
+    if (profile === 'compact') {
+        const compact = {
+            eventId: row.event_id,
+            sessionId: row.session_id,
+            timestamp: row.ts,
+            type: row.type,
+            summary: describeEvent(row.type, payload),
+        };
+        if (row.type === 'console') {
+            compact.level = typeof payload.level === 'string' ? payload.level : undefined;
+            compact.message = typeof payload.message === 'string' ? payload.message : undefined;
+        }
+        if (row.type === 'nav') {
+            compact.url = resolveLastUrl(payload);
+        }
+        if (options.includePayload === true) {
+            compact.payload = payload;
+        }
+        return compact;
+    }
     return {
         eventId: row.event_id,
         sessionId: row.session_id,
         timestamp: row.ts,
         type: row.type,
-        payload: readJsonPayload(row.payload_json),
+        tabId: row.tab_id ?? (typeof payload.tabId === 'number' ? payload.tabId : undefined),
+        origin: row.origin
+            ?? (typeof payload.origin === 'string' ? payload.origin : undefined)
+            ?? undefined,
+        payload,
     };
 }
 function classifyNetworkFailure(status, errorClass) {
@@ -376,6 +640,153 @@ function resolveDurationMs(value, fallback, maxValue) {
     }
     return Math.min(floored, maxValue);
 }
+function resolveBodyChunkBytes(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return DEFAULT_BODY_CHUNK_BYTES;
+    }
+    const floored = Math.floor(value);
+    if (floored < 1) {
+        return DEFAULT_BODY_CHUNK_BYTES;
+    }
+    return Math.min(floored, MAX_BODY_CHUNK_BYTES);
+}
+function resolveTimeoutMs(value, fallback, maxValue) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return fallback;
+    }
+    const floored = Math.floor(value);
+    if (floored < 100) {
+        return fallback;
+    }
+    return Math.min(floored, maxValue);
+}
+function normalizeHttpMethod(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toUpperCase();
+    return normalized.length > 0 ? normalized : undefined;
+}
+function normalizeOptionalString(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function normalizeStatusIn(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const statuses = value
+        .filter((entry) => typeof entry === 'number' && Number.isFinite(entry))
+        .map((entry) => Math.floor(entry))
+        .filter((entry) => entry >= 100 && entry <= 599);
+    return Array.from(new Set(statuses));
+}
+function parseJsonOrUndefined(value) {
+    if (!value) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function compileSafeRegex(value) {
+    if (!value) {
+        return undefined;
+    }
+    try {
+        return new RegExp(value);
+    }
+    catch {
+        throw new Error('urlRegex must be a valid regular expression');
+    }
+}
+function mapNetworkCallRecord(row, includeBodies) {
+    const requestBodyJson = parseJsonOrUndefined(row.request_body_json);
+    const responseBodyJson = parseJsonOrUndefined(row.response_body_json);
+    return {
+        requestId: row.request_id,
+        sessionId: row.session_id,
+        traceId: row.trace_id ?? undefined,
+        tabId: row.tab_id ?? undefined,
+        timestamp: row.ts_start,
+        durationMs: row.duration_ms ?? undefined,
+        method: row.method,
+        url: row.url,
+        origin: row.origin ?? undefined,
+        status: row.status ?? undefined,
+        initiator: row.initiator ?? undefined,
+        errorType: classifyNetworkFailure(row.status, row.error_class),
+        responseSizeEst: row.response_size_est ?? undefined,
+        request: {
+            contentType: row.request_content_type ?? undefined,
+            bodyBytes: row.request_body_bytes ?? undefined,
+            truncated: row.request_body_truncated === 1,
+            bodyChunkRef: row.request_body_chunk_ref ?? undefined,
+            bodyJson: includeBodies ? requestBodyJson : undefined,
+            bodyText: includeBodies ? row.request_body_text ?? undefined : undefined,
+        },
+        response: {
+            contentType: row.response_content_type ?? undefined,
+            bodyBytes: row.response_body_bytes ?? undefined,
+            truncated: row.response_body_truncated === 1,
+            bodyChunkRef: row.response_body_chunk_ref ?? undefined,
+            bodyJson: includeBodies ? responseBodyJson : undefined,
+            bodyText: includeBodies ? row.response_body_text ?? undefined : undefined,
+        },
+    };
+}
+function mapBodyChunkRecord(row, offset, limit) {
+    const fullBuffer = Buffer.from(row.body_text, 'utf-8');
+    if (offset >= fullBuffer.byteLength) {
+        return {
+            chunkRef: row.chunk_ref,
+            sessionId: row.session_id,
+            requestId: row.request_id ?? undefined,
+            traceId: row.trace_id ?? undefined,
+            bodyKind: row.body_kind,
+            contentType: row.content_type ?? undefined,
+            totalBytes: fullBuffer.byteLength,
+            offset,
+            returnedBytes: 0,
+            hasMore: false,
+            nextOffset: null,
+            chunkText: '',
+            truncated: row.truncated === 1,
+            createdAt: row.created_at,
+        };
+    }
+    const chunkBuffer = fullBuffer.subarray(offset, Math.min(offset + limit, fullBuffer.byteLength));
+    const returnedBytes = chunkBuffer.byteLength;
+    const nextOffset = offset + returnedBytes;
+    const hasMore = nextOffset < fullBuffer.byteLength;
+    return {
+        chunkRef: row.chunk_ref,
+        sessionId: row.session_id,
+        requestId: row.request_id ?? undefined,
+        traceId: row.trace_id ?? undefined,
+        bodyKind: row.body_kind,
+        contentType: row.content_type ?? undefined,
+        totalBytes: fullBuffer.byteLength,
+        offset,
+        returnedBytes,
+        hasMore,
+        nextOffset: hasMore ? nextOffset : null,
+        chunkText: chunkBuffer.toString('utf-8'),
+        truncated: row.truncated === 1,
+        createdAt: row.created_at,
+    };
+}
+function sleep(ms) {
+    return new Promise((resolvePromise) => {
+        setTimeout(resolvePromise, ms);
+    });
+}
 function normalizeAssetPath(pathValue) {
     return pathValue.replace(/\\/gu, '/').replace(/^\/+|\/+$/gu, '');
 }
@@ -528,6 +939,59 @@ function asStringArray(value, maxItems) {
         .filter((entry) => typeof entry === 'string' && entry.length > 0)
         .slice(0, maxItems);
 }
+const LIVE_CONSOLE_LEVELS = new Set(['log', 'info', 'warn', 'error', 'debug', 'trace']);
+function resolveLiveConsoleLevels(value) {
+    const levels = asStringArray(value, 16)
+        .map((entry) => entry.trim().toLowerCase())
+        .filter((entry) => LIVE_CONSOLE_LEVELS.has(entry));
+    return Array.from(new Set(levels));
+}
+function asRecordArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((entry) => typeof entry === 'object' && entry !== null);
+}
+function mapLiveConsoleLogRecord(log, profile, options = {}) {
+    if (profile === 'compact') {
+        const compact = {
+            timestamp: typeof log.timestamp === 'number'
+                ? log.timestamp
+                : typeof log.ts === 'number'
+                    ? log.ts
+                    : undefined,
+            level: typeof log.level === 'string' ? log.level : undefined,
+            message: typeof log.message === 'string' ? log.message : '',
+        };
+        if (typeof log.count === 'number') {
+            compact.count = log.count;
+        }
+        if (typeof log.firstTimestamp === 'number') {
+            compact.firstTimestamp = log.firstTimestamp;
+        }
+        if (typeof log.lastTimestamp === 'number') {
+            compact.lastTimestamp = log.lastTimestamp;
+        }
+        if (options.includeArgs === true && Array.isArray(log.args)) {
+            compact.args = log.args;
+        }
+        return compact;
+    }
+    return log;
+}
+function resolveOptionalTabId(value) {
+    if (value === undefined || value === null || value === '') {
+        return undefined;
+    }
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        throw new Error('tabId must be an integer');
+    }
+    const tabId = Math.floor(value);
+    if (!Number.isInteger(tabId) || tabId < 0) {
+        throw new Error('tabId must be an integer');
+    }
+    return tabId;
+}
 function isLiveSessionDisconnectedMessage(message) {
     const normalized = message.toLowerCase();
     return normalized.includes('no active extension connection')
@@ -570,6 +1034,7 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
             const sinceMinutes = typeof input.sinceMinutes === 'number' ? input.sinceMinutes : undefined;
             const limit = resolveLimit(input.limit, DEFAULT_LIST_LIMIT);
             const offset = resolveOffset(input.offset);
+            const maxResponseBytes = resolveMaxResponseBytes(input.maxResponseBytes);
             const where = [];
             const params = [];
             if (sinceMinutes !== undefined && Number.isFinite(sinceMinutes) && sinceMinutes > 0) {
@@ -581,6 +1046,7 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
         SELECT
           session_id,
           created_at,
+          paused_at,
           ended_at,
           tab_id,
           window_id,
@@ -598,11 +1064,13 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
         LIMIT ? OFFSET ?
       `;
             const rows = db.prepare(sql).all(...params, limit + 1, offset);
-            const truncated = rows.length > limit;
+            const truncatedByLimit = rows.length > limit;
             const sessions = rows.slice(0, limit).map((row) => ({
                 sessionId: row.session_id,
                 createdAt: row.created_at,
+                pausedAt: row.paused_at ?? undefined,
                 endedAt: row.ended_at ?? undefined,
+                status: row.ended_at ? 'ended' : row.paused_at ? 'paused' : 'active',
                 tabId: row.tab_id ?? undefined,
                 windowId: row.window_id ?? undefined,
                 urlStart: row.url_start ?? undefined,
@@ -635,17 +1103,17 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
                     };
                 })(),
             }));
+            const bytePage = applyByteBudget(sessions, maxResponseBytes);
+            const truncated = truncatedByLimit || bytePage.truncatedByBytes;
             return {
                 ...createBaseResponse(),
                 limitsApplied: {
                     maxResults: limit,
                     truncated,
                 },
-                pagination: {
-                    offset,
-                    returned: sessions.length,
-                },
-                sessions,
+                pagination: buildOffsetPagination(offset, bytePage.items.length, truncated, maxResponseBytes),
+                responseBytes: bytePage.responseBytes,
+                sessions: bytePage.items,
             };
         },
         get_session_summary: async (input) => {
@@ -713,14 +1181,21 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
         get_recent_events: async (input) => {
             const db = getDb();
             const sessionId = getSessionId(input);
-            if (!sessionId) {
-                throw new Error('sessionId is required');
-            }
+            const origin = normalizeRequestedOrigin(input.url);
+            ensureSessionOrOriginFilter(sessionId, origin);
             const limit = resolveLimit(input.limit, DEFAULT_EVENT_LIMIT);
             const offset = resolveOffset(input.offset);
+            const maxResponseBytes = resolveMaxResponseBytes(input.maxResponseBytes);
+            const responseProfile = resolveResponseProfile(input.responseProfile);
+            const includePayload = responseProfile === 'compact' && input.includePayload === true;
             const requestedTypes = parseRequestedTypes(input.types ?? input.eventTypes);
-            const params = [sessionId];
-            const where = ['session_id = ?'];
+            const params = [];
+            const where = [];
+            if (sessionId) {
+                where.push('session_id = ?');
+                params.push(sessionId);
+            }
+            appendEventOriginFilter(where, params, origin);
             if (requestedTypes.length > 0) {
                 const placeholders = requestedTypes.map(() => '?').join(', ');
                 where.push(`type IN (${placeholders})`);
@@ -728,94 +1203,270 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
             }
             const rows = db
                 .prepare(`
-        SELECT event_id, session_id, ts, type, payload_json
+        SELECT event_id, session_id, ts, type, payload_json, tab_id, origin
         FROM events
         WHERE ${where.join(' AND ')}
         ORDER BY ts DESC
         LIMIT ? OFFSET ?
       `)
                 .all(...params, limit + 1, offset);
-            const truncated = rows.length > limit;
+            const truncatedByLimit = rows.length > limit;
+            const events = rows
+                .slice(0, limit)
+                .map((row) => mapEventRecord(row, responseProfile, { includePayload }));
+            const bytePage = applyByteBudget(events, maxResponseBytes);
+            const truncated = truncatedByLimit || bytePage.truncatedByBytes;
             return {
                 ...createBaseResponse(sessionId),
                 limitsApplied: {
                     maxResults: limit,
                     truncated,
                 },
-                pagination: {
-                    offset,
-                    returned: Math.min(rows.length, limit),
-                },
-                events: rows.slice(0, limit).map((row) => mapEventRecord(row)),
+                pagination: buildOffsetPagination(offset, bytePage.items.length, truncated, maxResponseBytes),
+                responseProfile,
+                responseBytes: bytePage.responseBytes,
+                events: bytePage.items,
             };
         },
         get_navigation_history: async (input) => {
             const db = getDb();
             const sessionId = getSessionId(input);
-            if (!sessionId) {
-                throw new Error('sessionId is required');
-            }
+            const origin = normalizeRequestedOrigin(input.url);
+            ensureSessionOrOriginFilter(sessionId, origin);
             const limit = resolveLimit(input.limit, DEFAULT_EVENT_LIMIT);
             const offset = resolveOffset(input.offset);
+            const maxResponseBytes = resolveMaxResponseBytes(input.maxResponseBytes);
+            const responseProfile = resolveResponseProfile(input.responseProfile);
+            const includePayload = responseProfile === 'compact' && input.includePayload === true;
+            const params = [];
+            const where = ["type = 'nav'"];
+            if (sessionId) {
+                where.push('session_id = ?');
+                params.push(sessionId);
+            }
+            appendEventOriginFilter(where, params, origin);
             const rows = db
                 .prepare(`
-        SELECT event_id, session_id, ts, type, payload_json
+        SELECT event_id, session_id, ts, type, payload_json, tab_id, origin
         FROM events
-        WHERE session_id = ? AND type = 'nav'
+        WHERE ${where.join(' AND ')}
         ORDER BY ts DESC
         LIMIT ? OFFSET ?
       `)
-                .all(sessionId, limit + 1, offset);
-            const truncated = rows.length > limit;
+                .all(...params, limit + 1, offset);
+            const truncatedByLimit = rows.length > limit;
+            const events = rows
+                .slice(0, limit)
+                .map((row) => mapEventRecord(row, responseProfile, { includePayload }));
+            const bytePage = applyByteBudget(events, maxResponseBytes);
+            const truncated = truncatedByLimit || bytePage.truncatedByBytes;
             return {
                 ...createBaseResponse(sessionId),
                 limitsApplied: {
                     maxResults: limit,
                     truncated,
                 },
-                pagination: {
-                    offset,
-                    returned: Math.min(rows.length, limit),
-                },
-                events: rows.slice(0, limit).map((row) => mapEventRecord(row)),
+                pagination: buildOffsetPagination(offset, bytePage.items.length, truncated, maxResponseBytes),
+                responseProfile,
+                responseBytes: bytePage.responseBytes,
+                events: bytePage.items,
             };
         },
         get_console_events: async (input) => {
             const db = getDb();
             const sessionId = getSessionId(input);
-            if (!sessionId) {
-                throw new Error('sessionId is required');
-            }
+            const origin = normalizeRequestedOrigin(input.url);
+            ensureSessionOrOriginFilter(sessionId, origin);
             const level = typeof input.level === 'string' ? input.level : undefined;
             const limit = resolveLimit(input.limit, DEFAULT_EVENT_LIMIT);
             const offset = resolveOffset(input.offset);
-            const params = [sessionId];
-            let levelClause = '';
+            const maxResponseBytes = resolveMaxResponseBytes(input.maxResponseBytes);
+            const responseProfile = resolveResponseProfile(input.responseProfile);
+            const includePayload = responseProfile === 'compact' && input.includePayload === true;
+            const params = [];
+            const where = ["type = 'console'"];
+            if (sessionId) {
+                where.push('session_id = ?');
+                params.push(sessionId);
+            }
+            appendEventOriginFilter(where, params, origin);
             if (level) {
-                levelClause = "AND json_extract(payload_json, '$.level') = ?";
+                where.push("json_extract(payload_json, '$.level') = ?");
                 params.push(level);
             }
             const rows = db
                 .prepare(`
-        SELECT event_id, session_id, ts, type, payload_json
+        SELECT event_id, session_id, ts, type, payload_json, tab_id, origin
         FROM events
-        WHERE session_id = ? AND type = 'console' ${levelClause}
+        WHERE ${where.join(' AND ')}
         ORDER BY ts DESC
         LIMIT ? OFFSET ?
       `)
                 .all(...params, limit + 1, offset);
-            const truncated = rows.length > limit;
+            const truncatedByLimit = rows.length > limit;
+            const events = rows
+                .slice(0, limit)
+                .map((row) => mapEventRecord(row, responseProfile, { includePayload }));
+            const bytePage = applyByteBudget(events, maxResponseBytes);
+            const truncated = truncatedByLimit || bytePage.truncatedByBytes;
             return {
                 ...createBaseResponse(sessionId),
                 limitsApplied: {
                     maxResults: limit,
                     truncated,
                 },
-                pagination: {
-                    offset,
-                    returned: Math.min(rows.length, limit),
+                pagination: buildOffsetPagination(offset, bytePage.items.length, truncated, maxResponseBytes),
+                responseProfile,
+                responseBytes: bytePage.responseBytes,
+                events: bytePage.items,
+            };
+        },
+        get_console_summary: async (input) => {
+            const db = getDb();
+            const sessionId = getSessionId(input);
+            const origin = normalizeRequestedOrigin(input.url);
+            ensureSessionOrOriginFilter(sessionId, origin);
+            const level = typeof input.level === 'string' && input.level.length > 0 ? input.level : undefined;
+            const sinceMinutes = typeof input.sinceMinutes === 'number' && Number.isFinite(input.sinceMinutes)
+                ? Math.floor(input.sinceMinutes)
+                : undefined;
+            const limit = resolveLimit(input.limit, 10);
+            const where = ["type = 'console'"];
+            const params = [];
+            if (sessionId) {
+                where.push('session_id = ?');
+                params.push(sessionId);
+            }
+            appendEventOriginFilter(where, params, origin);
+            if (level) {
+                where.push("json_extract(payload_json, '$.level') = ?");
+                params.push(level);
+            }
+            if (sinceMinutes !== undefined && sinceMinutes > 0) {
+                where.push('ts >= ?');
+                params.push(Date.now() - sinceMinutes * 60_000);
+            }
+            const whereClause = `WHERE ${where.join(' AND ')}`;
+            const totals = db
+                .prepare(`
+          SELECT
+            COUNT(*) AS total,
+            SUM(CASE WHEN json_extract(payload_json, '$.level') = 'log' THEN 1 ELSE 0 END) AS log_count,
+            SUM(CASE WHEN json_extract(payload_json, '$.level') = 'info' THEN 1 ELSE 0 END) AS info_count,
+            SUM(CASE WHEN json_extract(payload_json, '$.level') = 'warn' THEN 1 ELSE 0 END) AS warn_count,
+            SUM(CASE WHEN json_extract(payload_json, '$.level') = 'error' THEN 1 ELSE 0 END) AS error_count,
+            SUM(CASE WHEN json_extract(payload_json, '$.level') = 'debug' THEN 1 ELSE 0 END) AS debug_count,
+            SUM(CASE WHEN json_extract(payload_json, '$.level') = 'trace' THEN 1 ELSE 0 END) AS trace_count,
+            MIN(ts) AS first_ts,
+            MAX(ts) AS last_ts
+          FROM events
+          ${whereClause}
+        `)
+                .get(...params);
+            const topMessages = db
+                .prepare(`
+          SELECT
+            COALESCE(json_extract(payload_json, '$.message'), 'console event') AS message,
+            COALESCE(json_extract(payload_json, '$.level'), 'log') AS level,
+            COUNT(*) AS count,
+            MIN(ts) AS first_ts,
+            MAX(ts) AS last_ts
+          FROM events
+          ${whereClause}
+          GROUP BY message, level
+          ORDER BY count DESC, last_ts DESC
+          LIMIT ?
+        `)
+                .all(...params, limit);
+            return {
+                ...createBaseResponse(sessionId),
+                limitsApplied: {
+                    maxResults: limit,
+                    truncated: false,
+                },
+                counts: {
+                    total: totals.total ?? 0,
+                    byLevel: {
+                        log: totals.log_count ?? 0,
+                        info: totals.info_count ?? 0,
+                        warn: totals.warn_count ?? 0,
+                        error: totals.error_count ?? 0,
+                        debug: totals.debug_count ?? 0,
+                        trace: totals.trace_count ?? 0,
+                    },
                 },
-                events: rows.slice(0, limit).map((row) => mapEventRecord(row)),
+                firstSeenAt: totals.first_ts ?? undefined,
+                lastSeenAt: totals.last_ts ?? undefined,
+                topMessages: topMessages.map((entry) => ({
+                    level: entry.level,
+                    message: entry.message,
+                    count: entry.count,
+                    firstSeenAt: entry.first_ts,
+                    lastSeenAt: entry.last_ts,
+                })),
+            };
+        },
+        get_event_summary: async (input) => {
+            const db = getDb();
+            const sessionId = getSessionId(input);
+            const origin = normalizeRequestedOrigin(input.url);
+            ensureSessionOrOriginFilter(sessionId, origin);
+            const requestedTypes = parseRequestedTypes(input.types ?? input.eventTypes);
+            const sinceMinutes = typeof input.sinceMinutes === 'number' && Number.isFinite(input.sinceMinutes)
+                ? Math.floor(input.sinceMinutes)
+                : undefined;
+            const limit = resolveLimit(input.limit, 20);
+            const where = [];
+            const params = [];
+            if (sessionId) {
+                where.push('session_id = ?');
+                params.push(sessionId);
+            }
+            appendEventOriginFilter(where, params, origin);
+            if (requestedTypes.length > 0) {
+                const placeholders = requestedTypes.map(() => '?').join(', ');
+                where.push(`type IN (${placeholders})`);
+                params.push(...requestedTypes);
+            }
+            if (sinceMinutes !== undefined && sinceMinutes > 0) {
+                where.push('ts >= ?');
+                params.push(Date.now() - sinceMinutes * 60_000);
+            }
+            const whereClause = where.length > 0 ? `WHERE ${where.join(' AND ')}` : '';
+            const totals = db
+                .prepare(`
+          SELECT COUNT(*) AS total, MIN(ts) AS first_ts, MAX(ts) AS last_ts
+          FROM events
+          ${whereClause}
+        `)
+                .get(...params);
+            const byType = db
+                .prepare(`
+          SELECT type, COUNT(*) AS count, MIN(ts) AS first_ts, MAX(ts) AS last_ts
+          FROM events
+          ${whereClause}
+          GROUP BY type
+          ORDER BY count DESC, last_ts DESC
+          LIMIT ?
+        `)
+                .all(...params, limit);
+            return {
+                ...createBaseResponse(sessionId),
+                limitsApplied: {
+                    maxResults: limit,
+                    truncated: false,
+                },
+                counts: {
+                    total: totals.total ?? 0,
+                },
+                firstSeenAt: totals.first_ts ?? undefined,
+                lastSeenAt: totals.last_ts ?? undefined,
+                byType: byType.map((entry) => ({
+                    type: entry.type,
+                    count: entry.count,
+                    firstSeenAt: entry.first_ts,
+                    lastSeenAt: entry.last_ts,
+                })),
             };
         },
         get_error_fingerprints: async (input) => {
@@ -826,6 +1477,7 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
                 : undefined;
             const limit = resolveLimit(input.limit, DEFAULT_LIST_LIMIT);
             const offset = resolveOffset(input.offset);
+            const maxResponseBytes = resolveMaxResponseBytes(input.maxResponseBytes);
             const params = [];
             const where = [];
             if (sessionId) {
@@ -846,35 +1498,39 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
           LIMIT ? OFFSET ?
         `)
                 .all(...params, limit + 1, offset);
-            const truncated = rows.length > limit;
+            const truncatedByLimit = rows.length > limit;
+            const fingerprints = rows.slice(0, limit).map((row) => ({
+                fingerprint: row.fingerprint,
+                sessionId: row.session_id,
+                count: row.count,
+                sampleMessage: row.sample_message,
+                sampleStack: row.sample_stack ?? undefined,
+                firstSeenAt: row.first_seen_at,
+                lastSeenAt: row.last_seen_at,
+            }));
+            const bytePage = applyByteBudget(fingerprints, maxResponseBytes);
+            const truncated = truncatedByLimit || bytePage.truncatedByBytes;
             return {
                 ...createBaseResponse(sessionId),
                 limitsApplied: {
                     maxResults: limit,
                     truncated,
                 },
-                pagination: {
-                    offset,
-                    returned: Math.min(rows.length, limit),
-                },
-                fingerprints: rows.slice(0, limit).map((row) => ({
-                    fingerprint: row.fingerprint,
-                    sessionId: row.session_id,
-                    count: row.count,
-                    sampleMessage: row.sample_message,
-                    sampleStack: row.sample_stack ?? undefined,
-                    firstSeenAt: row.first_seen_at,
-                    lastSeenAt: row.last_seen_at,
-                })),
+                pagination: buildOffsetPagination(offset, bytePage.items.length, truncated, maxResponseBytes),
+                responseBytes: bytePage.responseBytes,
+                fingerprints: bytePage.items,
             };
         },
         get_network_failures: async (input) => {
             const db = getDb();
             const sessionId = typeof input.sessionId === 'string' ? input.sessionId : undefined;
+            const origin = normalizeRequestedOrigin(input.url);
+            ensureSessionOrOriginFilter(sessionId, origin);
             const groupBy = typeof input.groupBy === 'string' ? input.groupBy : undefined;
             const errorType = typeof input.errorType === 'string' ? input.errorType : undefined;
             const limit = resolveLimit(input.limit, DEFAULT_LIST_LIMIT);
             const offset = resolveOffset(input.offset);
+            const maxResponseBytes = resolveMaxResponseBytes(input.maxResponseBytes);
             const params = [];
             const where = [];
             const errorFilter = buildNetworkFailureFilter(errorType);
@@ -882,6 +1538,7 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
                 where.push('session_id = ?');
                 params.push(sessionId);
             }
+            appendNetworkOriginFilter(where, params, origin);
             where.push(errorFilter);
             if (errorFilter === 'error_class = ?' && errorType) {
                 params.push(errorType);
@@ -907,57 +1564,327 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
             LIMIT ? OFFSET ?
           `)
                     .all(...params, limit + 1, offset);
-                const truncated = rows.length > limit;
+                const truncatedByLimit = rows.length > limit;
+                const groups = rows.slice(0, limit).map((row) => ({
+                    key: row.group_key,
+                    count: row.count,
+                    firstSeenAt: row.first_ts,
+                    lastSeenAt: row.last_ts,
+                }));
+                const bytePage = applyByteBudget(groups, maxResponseBytes);
+                const truncated = truncatedByLimit || bytePage.truncatedByBytes;
                 return {
                     ...createBaseResponse(sessionId),
                     limitsApplied: {
                         maxResults: limit,
                         truncated,
                     },
-                    pagination: {
-                        offset,
-                        returned: Math.min(rows.length, limit),
-                    },
+                    pagination: buildOffsetPagination(offset, bytePage.items.length, truncated, maxResponseBytes),
+                    responseBytes: bytePage.responseBytes,
                     groupBy,
-                    groups: rows.slice(0, limit).map((row) => ({
-                        key: row.group_key,
-                        count: row.count,
-                        firstSeenAt: row.first_ts,
-                        lastSeenAt: row.last_ts,
-                    })),
+                    groups: bytePage.items,
                 };
             }
             const rows = db
                 .prepare(`
-          SELECT request_id, session_id, ts_start, duration_ms, method, url, status, initiator, error_class
+          SELECT request_id, session_id, trace_id, tab_id, ts_start, duration_ms, method, url, origin, status, initiator, error_class
           FROM network
           ${whereClause}
           ORDER BY ts_start DESC
           LIMIT ? OFFSET ?
         `)
                 .all(...params, limit + 1, offset);
-            const truncated = rows.length > limit;
+            const truncatedByLimit = rows.length > limit;
+            const failures = rows.slice(0, limit).map((row) => ({
+                requestId: row.request_id,
+                sessionId: row.session_id,
+                traceId: row.trace_id ?? undefined,
+                tabId: row.tab_id ?? undefined,
+                timestamp: row.ts_start,
+                durationMs: row.duration_ms ?? undefined,
+                method: row.method,
+                url: row.url,
+                origin: row.origin ?? undefined,
+                status: row.status ?? undefined,
+                initiator: row.initiator ?? undefined,
+                errorType: classifyNetworkFailure(row.status, row.error_class),
+            }));
+            const bytePage = applyByteBudget(failures, maxResponseBytes);
+            const truncated = truncatedByLimit || bytePage.truncatedByBytes;
             return {
                 ...createBaseResponse(sessionId),
                 limitsApplied: {
                     maxResults: limit,
                     truncated,
                 },
-                pagination: {
-                    offset,
-                    returned: Math.min(rows.length, limit),
+                pagination: buildOffsetPagination(offset, bytePage.items.length, truncated, maxResponseBytes),
+                responseBytes: bytePage.responseBytes,
+                failures: bytePage.items,
+            };
+        },
+        get_network_calls: async (input) => {
+            const db = getDb();
+            const sessionId = getSessionId(input);
+            if (!sessionId) {
+                throw new Error('sessionId is required');
+            }
+            const includeBodies = input.includeBodies === true;
+            const urlContains = normalizeOptionalString(input.urlContains);
+            const urlRegex = compileSafeRegex(normalizeOptionalString(input.urlRegex));
+            const method = normalizeHttpMethod(input.method);
+            const statusIn = normalizeStatusIn(input.statusIn);
+            const tabId = resolveOptionalTabId(input.tabId);
+            const timeFrom = resolveOptionalTimestamp(input.timeFrom);
+            const timeTo = resolveOptionalTimestamp(input.timeTo);
+            const limit = resolveLimit(input.limit, DEFAULT_EVENT_LIMIT);
+            const offset = resolveOffset(input.offset);
+            const maxResponseBytes = resolveMaxResponseBytes(input.maxResponseBytes);
+            if (timeFrom !== undefined && timeTo !== undefined && timeFrom > timeTo) {
+                throw new Error('timeFrom must be <= timeTo');
+            }
+            const where = ['session_id = ?'];
+            const params = [sessionId];
+            if (urlContains) {
+                where.push('url LIKE ?');
+                params.push(`%${urlContains}%`);
+            }
+            if (method) {
+                where.push('method = ?');
+                params.push(method);
+            }
+            if (statusIn.length > 0) {
+                where.push(`status IN (${statusIn.map(() => '?').join(', ')})`);
+                params.push(...statusIn);
+            }
+            if (tabId !== undefined) {
+                where.push('tab_id = ?');
+                params.push(tabId);
+            }
+            if (timeFrom !== undefined) {
+                where.push('ts_start >= ?');
+                params.push(timeFrom);
+            }
+            if (timeTo !== undefined) {
+                where.push('ts_start <= ?');
+                params.push(timeTo);
+            }
+            const whereClause = `WHERE ${where.join(' AND ')}`;
+            if (!urlRegex) {
+                const rows = db.prepare(`SELECT ${NETWORK_CALL_SELECT_COLUMNS}
+           FROM network
+           ${whereClause}
+           ORDER BY ts_start DESC
+           LIMIT ? OFFSET ?`).all(...params, limit + 1, offset);
+                const truncatedByLimit = rows.length > limit;
+                const calls = rows
+                    .slice(0, limit)
+                    .map((row) => mapNetworkCallRecord(row, includeBodies));
+                const bytePage = applyByteBudget(calls, maxResponseBytes);
+                const truncated = truncatedByLimit || bytePage.truncatedByBytes;
+                return {
+                    ...createBaseResponse(sessionId),
+                    limitsApplied: {
+                        maxResults: limit,
+                        truncated,
+                    },
+                    filtersApplied: {
+                        sessionId,
+                        urlContains,
+                        method,
+                        statusIn,
+                        tabId,
+                        timeFrom,
+                        timeTo,
+                        includeBodies,
+                    },
+                    pagination: buildOffsetPagination(offset, bytePage.items.length, truncated, maxResponseBytes),
+                    responseBytes: bytePage.responseBytes,
+                    calls: bytePage.items,
+                };
+            }
+            const regexScanLimit = Math.min(Math.max(limit + offset + 200, 500), 5000);
+            const regex = urlRegex;
+            const regexRows = db.prepare(`SELECT ${NETWORK_CALL_SELECT_COLUMNS}
+         FROM network
+         ${whereClause}
+         ORDER BY ts_start DESC
+         LIMIT ?`).all(...params, regexScanLimit);
+            const matched = regexRows.filter((row) => regex.test(row.url));
+            const sliced = matched.slice(offset, offset + limit + 1);
+            const truncatedByLimit = matched.length > offset + limit;
+            const calls = sliced
+                .slice(0, limit)
+                .map((row) => mapNetworkCallRecord(row, includeBodies));
+            const bytePage = applyByteBudget(calls, maxResponseBytes);
+            const truncated = truncatedByLimit || bytePage.truncatedByBytes;
+            return {
+                ...createBaseResponse(sessionId),
+                limitsApplied: {
+                    maxResults: limit,
+                    truncated,
                 },
-                failures: rows.slice(0, limit).map((row) => ({
-                    requestId: row.request_id,
-                    sessionId: row.session_id,
-                    timestamp: row.ts_start,
-                    durationMs: row.duration_ms ?? undefined,
-                    method: row.method,
-                    url: row.url,
-                    status: row.status ?? undefined,
-                    initiator: row.initiator ?? undefined,
-                    errorType: classifyNetworkFailure(row.status, row.error_class),
-                })),
+                filtersApplied: {
+                    sessionId,
+                    urlContains,
+                    urlRegex: urlRegex.source,
+                    method,
+                    statusIn,
+                    tabId,
+                    timeFrom,
+                    timeTo,
+                    includeBodies,
+                    regexScanLimit,
+                },
+                pagination: buildOffsetPagination(offset, bytePage.items.length, truncated, maxResponseBytes),
+                responseBytes: bytePage.responseBytes,
+                calls: bytePage.items,
+            };
+        },
+        wait_for_network_call: async (input) => {
+            const db = getDb();
+            const sessionId = getSessionId(input);
+            if (!sessionId) {
+                throw new Error('sessionId is required');
+            }
+            const urlPattern = normalizeOptionalString(input.urlPattern);
+            if (!urlPattern) {
+                throw new Error('urlPattern is required');
+            }
+            const method = normalizeHttpMethod(input.method);
+            const timeoutMs = resolveTimeoutMs(input.timeoutMs, DEFAULT_NETWORK_POLL_TIMEOUT_MS, MAX_NETWORK_POLL_TIMEOUT_MS);
+            const includeBodies = input.includeBodies === true;
+            const startedAt = Date.now();
+            const deadline = startedAt + timeoutMs;
+            const urlRegex = compileSafeRegex(urlPattern);
+            if (!urlRegex) {
+                throw new Error('urlPattern is required');
+            }
+            while (Date.now() <= deadline) {
+                const where = ['session_id = ?', 'ts_start >= ?'];
+                const params = [sessionId, startedAt];
+                if (method) {
+                    where.push('method = ?');
+                    params.push(method);
+                }
+                const rows = db.prepare(`SELECT ${NETWORK_CALL_SELECT_COLUMNS}
+           FROM network
+           WHERE ${where.join(' AND ')}
+           ORDER BY ts_start ASC
+           LIMIT 200`).all(...params);
+                const matched = rows.find((row) => urlRegex.test(row.url));
+                if (matched) {
+                    return {
+                        ...createBaseResponse(sessionId),
+                        limitsApplied: {
+                            maxResults: 1,
+                            truncated: false,
+                        },
+                        waitedMs: Date.now() - startedAt,
+                        filter: {
+                            urlPattern,
+                            method,
+                            timeoutMs,
+                            includeBodies,
+                        },
+                        call: mapNetworkCallRecord(matched, includeBodies),
+                    };
+                }
+                await sleep(DEFAULT_NETWORK_POLL_INTERVAL_MS);
+            }
+            throw new Error(`No matching network call for pattern "${urlPattern}" within ${timeoutMs}ms.`);
+        },
+        get_request_trace: async (input) => {
+            const db = getDb();
+            const sessionId = getSessionId(input);
+            const includeBodies = input.includeBodies === true;
+            const requestId = normalizeOptionalString(input.requestId);
+            const traceIdInput = normalizeOptionalString(input.traceId);
+            const eventLimit = resolveLimit(input.eventLimit, DEFAULT_EVENT_LIMIT);
+            if (!requestId && !traceIdInput) {
+                throw new Error('requestId or traceId is required');
+            }
+            let anchor;
+            if (requestId) {
+                const params = [requestId];
+                let sql = `SELECT ${NETWORK_CALL_SELECT_COLUMNS} FROM network WHERE request_id = ?`;
+                if (sessionId) {
+                    sql += ' AND session_id = ?';
+                    params.push(sessionId);
+                }
+                sql += ' LIMIT 1';
+                anchor = db.prepare(sql).get(...params);
+                if (!anchor) {
+                    throw new Error(`Request not found: ${requestId}`);
+                }
+            }
+            const traceId = traceIdInput ?? anchor?.trace_id ?? null;
+            const traceSessionId = sessionId ?? anchor?.session_id;
+            const networkWhere = [];
+            const networkParams = [];
+            if (traceId) {
+                networkWhere.push('trace_id = ?');
+                networkParams.push(traceId);
+            }
+            else if (requestId) {
+                networkWhere.push('request_id = ?');
+                networkParams.push(requestId);
+            }
+            if (traceSessionId) {
+                networkWhere.push('session_id = ?');
+                networkParams.push(traceSessionId);
+            }
+            const networkRows = db.prepare(`SELECT ${NETWORK_CALL_SELECT_COLUMNS}
+         FROM network
+         WHERE ${networkWhere.join(' AND ')}
+         ORDER BY ts_start ASC
+         LIMIT 500`).all(...networkParams);
+            const eventRows = traceId
+                ? db.prepare(`SELECT event_id, session_id, ts, type, payload_json, tab_id, origin
+           FROM events
+           WHERE json_extract(payload_json, '$.traceId') = ?
+             ${traceSessionId ? 'AND session_id = ?' : ''}
+           ORDER BY ts ASC
+           LIMIT ?`).all(...(traceSessionId ? [traceId, traceSessionId, eventLimit + 1] : [traceId, eventLimit + 1]))
+                : [];
+            const eventsTruncated = eventRows.length > eventLimit;
+            const correlatedEvents = eventRows.slice(0, eventLimit).map((row) => mapEventRecord(row));
+            return {
+                ...createBaseResponse(traceSessionId),
+                limitsApplied: {
+                    maxResults: eventLimit,
+                    truncated: eventsTruncated,
+                },
+                traceId: traceId ?? undefined,
+                requestId: requestId ?? anchor?.request_id ?? undefined,
+                anchorRequest: anchor ? mapNetworkCallRecord(anchor, includeBodies) : undefined,
+                networkCalls: networkRows.map((row) => mapNetworkCallRecord(row, includeBodies)),
+                correlatedEvents,
+            };
+        },
+        get_body_chunk: async (input) => {
+            const db = getDb();
+            const chunkRef = normalizeOptionalString(input.chunkRef);
+            if (!chunkRef) {
+                throw new Error('chunkRef is required');
+            }
+            const sessionId = getSessionId(input);
+            const offset = resolveOffset(input.offset);
+            const limit = resolveBodyChunkBytes(input.limit);
+            const row = db.prepare(`SELECT chunk_ref, session_id, request_id, trace_id, body_kind, content_type, body_text, body_bytes, truncated, created_at
+         FROM body_chunks
+         WHERE chunk_ref = ?
+           ${sessionId ? 'AND session_id = ?' : ''}
+         LIMIT 1`).get(...(sessionId ? [chunkRef, sessionId] : [chunkRef]));
+            if (!row) {
+                throw new Error(`Body chunk not found: ${chunkRef}`);
+            }
+            return {
+                ...createBaseResponse(row.session_id),
+                limitsApplied: {
+                    maxResults: limit,
+                    truncated: offset + limit < row.body_bytes,
+                },
+                ...mapBodyChunkRecord(row, offset, limit),
             };
         },
         get_element_refs: async (input) => {
@@ -972,9 +1899,10 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
             }
             const limit = resolveLimit(input.limit, DEFAULT_EVENT_LIMIT);
             const offset = resolveOffset(input.offset);
+            const maxResponseBytes = resolveMaxResponseBytes(input.maxResponseBytes);
             const rows = db
                 .prepare(`
-          SELECT event_id, session_id, ts, type, payload_json
+          SELECT event_id, session_id, ts, type, payload_json, tab_id, origin
           FROM events
           WHERE session_id = ?
             AND type IN ('ui', 'element_ref')
@@ -983,19 +1911,20 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
           LIMIT ? OFFSET ?
         `)
                 .all(sessionId, selector, limit + 1, offset);
-            const truncated = rows.length > limit;
+            const truncatedByLimit = rows.length > limit;
+            const refs = rows.slice(0, limit).map((row) => mapEventRecord(row));
+            const bytePage = applyByteBudget(refs, maxResponseBytes);
+            const truncated = truncatedByLimit || bytePage.truncatedByBytes;
             return {
                 ...createBaseResponse(sessionId),
                 limitsApplied: {
                     maxResults: limit,
                     truncated,
                 },
-                pagination: {
-                    offset,
-                    returned: Math.min(rows.length, limit),
-                },
+                pagination: buildOffsetPagination(offset, bytePage.items.length, truncated, maxResponseBytes),
+                responseBytes: bytePage.responseBytes,
                 selector,
-                refs: rows.slice(0, limit).map((row) => mapEventRecord(row)),
+                refs: bytePage.items,
             };
         },
         explain_last_failure: async (input) => {
@@ -1008,7 +1937,7 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
             const windowMs = lookbackSeconds * 1000;
             const latestErrorEvent = db
                 .prepare(`
-          SELECT event_id, session_id, ts, type, payload_json
+          SELECT event_id, session_id, ts, type, payload_json, tab_id, origin
           FROM events
           WHERE session_id = ?
             AND (type = 'error' OR (type = 'console' AND json_extract(payload_json, '$.level') = 'error'))
@@ -1018,7 +1947,7 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
                 .get(sessionId);
             const latestNetworkFailure = db
                 .prepare(`
-          SELECT request_id, session_id, ts_start, duration_ms, method, url, status, initiator, error_class
+          SELECT request_id, session_id, trace_id, tab_id, ts_start, duration_ms, method, url, origin, status, initiator, error_class
           FROM network
           WHERE session_id = ?
             AND (error_class IS NOT NULL OR COALESCE(status, 0) >= 400)
@@ -1046,7 +1975,7 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
             const windowEnd = anchorTs + 1_000;
             const eventRows = db
                 .prepare(`
-          SELECT event_id, session_id, ts, type, payload_json
+          SELECT event_id, session_id, ts, type, payload_json, tab_id, origin
           FROM events
           WHERE session_id = ?
             AND ts BETWEEN ? AND ?
@@ -1055,7 +1984,7 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
                 .all(sessionId, windowStart, windowEnd);
             const networkRows = db
                 .prepare(`
-          SELECT request_id, session_id, ts_start, duration_ms, method, url, status, initiator, error_class
+          SELECT request_id, session_id, trace_id, tab_id, ts_start, duration_ms, method, url, origin, status, initiator, error_class
           FROM network
           WHERE session_id = ?
             AND ts_start BETWEEN ? AND ?
@@ -1138,7 +2067,7 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
             }
             const anchorEvent = db
                 .prepare(`
-          SELECT event_id, session_id, ts, type, payload_json
+          SELECT event_id, session_id, ts, type, payload_json, tab_id, origin
           FROM events
           WHERE session_id = ? AND event_id = ?
           LIMIT 1
@@ -1153,7 +2082,7 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
             const windowEnd = anchorEvent.ts + windowMs;
             const nearbyEvents = db
                 .prepare(`
-          SELECT event_id, session_id, ts, type, payload_json
+          SELECT event_id, session_id, ts, type, payload_json, tab_id, origin
           FROM events
           WHERE session_id = ?
             AND event_id != ?
@@ -1162,7 +2091,7 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
                 .all(sessionId, eventId, windowStart, windowEnd);
             const nearbyNetworkFailures = db
                 .prepare(`
-          SELECT request_id, session_id, ts_start, duration_ms, method, url, status, initiator, error_class
+          SELECT request_id, session_id, trace_id, tab_id, ts_start, duration_ms, method, url, origin, status, initiator, error_class
           FROM network
           WHERE session_id = ?
             AND ts_start BETWEEN ? AND ?
@@ -1234,6 +2163,7 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
             const untilTimestamp = resolveOptionalTimestamp(input.untilTimestamp);
             const limit = resolveLimit(input.limit, DEFAULT_LIST_LIMIT);
             const offset = resolveOffset(input.offset);
+            const maxResponseBytes = resolveMaxResponseBytes(input.maxResponseBytes);
             const where = ['session_id = ?'];
             const params = [sessionId];
             if (trigger) {
@@ -1258,18 +2188,19 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
            ORDER BY ts DESC
            LIMIT ? OFFSET ?`)
                 .all(...params, limit + 1, offset);
-            const truncated = rows.length > limit;
+            const truncatedByLimit = rows.length > limit;
+            const snapshots = rows.slice(0, limit).map((row) => mapSnapshotMetadata(row));
+            const bytePage = applyByteBudget(snapshots, maxResponseBytes);
+            const truncated = truncatedByLimit || bytePage.truncatedByBytes;
             return {
                 ...createBaseResponse(sessionId),
                 limitsApplied: {
                     maxResults: limit,
                     truncated,
                 },
-                pagination: {
-                    offset,
-                    returned: Math.min(rows.length, limit),
-                },
-                snapshots: rows.slice(0, limit).map((row) => mapSnapshotMetadata(row)),
+                pagination: buildOffsetPagination(offset, bytePage.items.length, truncated, maxResponseBytes),
+                responseBytes: bytePage.responseBytes,
+                snapshots: bytePage.items,
             };
         },
         get_snapshot_for_event: async (input) => {
@@ -1351,7 +2282,7 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
                 throw new Error('snapshotId is required');
             }
             const assetType = input.asset === 'png' ? 'png' : 'png';
-            const encoding = input.encoding === 'base64' ? 'base64' : 'raw';
+            const encoding = input.encoding === 'raw' ? 'raw' : 'base64';
             const offset = resolveOffset(input.offset);
             const maxBytes = resolveChunkBytes(input.maxBytes, DEFAULT_SNAPSHOT_ASSET_CHUNK_BYTES);
             const snapshot = db
@@ -1381,6 +2312,7 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
                     },
                     snapshotId,
                     asset: assetType,
+                    assetUri: `snapshot://${encodeURIComponent(sessionId)}/${encodeURIComponent(snapshotId)}/${assetType}`,
                     mime: snapshot.png_mime ?? 'image/png',
                     totalBytes: fullBuffer.byteLength,
                     offset,
@@ -1404,6 +2336,7 @@ export function createV1ToolHandlers(getDb, getSessionConnectionState) {
                 },
                 snapshotId,
                 asset: assetType,
+                assetUri: `snapshot://${encodeURIComponent(sessionId)}/${encodeURIComponent(snapshotId)}/${assetType}`,
                 mime: snapshot.png_mime ?? 'image/png',
                 totalBytes: fullBuffer.byteLength,
                 offset,
@@ -1531,6 +2464,9 @@ export function createV2ToolHandlers(captureClient) {
             const maxDepth = resolveCaptureDepth(input.maxDepth, 3);
             const maxBytes = resolveCaptureBytes(input.maxBytes, 50_000);
             const maxAncestors = resolveCaptureAncestors(input.maxAncestors, 4);
+            const includeDom = typeof input.includeDom === 'boolean' ? input.includeDom : mode !== 'png';
+            const includeStyles = typeof input.includeStyles === 'boolean' ? input.includeStyles : mode !== 'png';
+            const includePngDataUrl = typeof input.includePngDataUrl === 'boolean' ? input.includePngDataUrl : mode !== 'png';
             const capture = await executeLiveCapture(captureClient, sessionId, 'CAPTURE_UI_SNAPSHOT', {
                 selector,
                 trigger,
@@ -1540,15 +2476,105 @@ export function createV2ToolHandlers(captureClient) {
                 maxDepth,
                 maxBytes,
                 maxAncestors,
+                includeDom,
+                includeStyles,
+                includePngDataUrl,
                 llmRequested: true,
             }, 5_000);
+            const payload = ensureCaptureSuccess(capture, sessionId);
+            const snapshotRecord = structuredClone(payload);
+            const snapshotRoot = snapshotRecord.snapshot;
+            if (typeof snapshotRoot === 'object' && snapshotRoot !== null) {
+                const snapshotObject = snapshotRoot;
+                if (!includeDom) {
+                    delete snapshotObject.dom;
+                }
+                if (!includeStyles) {
+                    delete snapshotObject.styles;
+                }
+            }
+            const png = snapshotRecord.png;
+            if (!includePngDataUrl && typeof png === 'object' && png !== null) {
+                delete png.dataUrl;
+            }
             return {
                 ...createBaseResponse(sessionId),
                 limitsApplied: {
                     maxResults: maxBytes,
                     truncated: capture.truncated ?? false,
                 },
-                ...ensureCaptureSuccess(capture, sessionId),
+                includeDom,
+                includeStyles,
+                includePngDataUrl,
+                ...snapshotRecord,
+            };
+        },
+        get_live_console_logs: async (input) => {
+            const sessionId = getSessionId(input);
+            if (!sessionId) {
+                throw new Error('sessionId is required');
+            }
+            const origin = normalizeRequestedOrigin(input.url);
+            const tabId = resolveOptionalTabId(input.tabId);
+            const levels = resolveLiveConsoleLevels(input.levels);
+            const contains = typeof input.contains === 'string' && input.contains.trim().length > 0
+                ? input.contains.trim()
+                : undefined;
+            const sinceTs = resolveOptionalTimestamp(input.sinceTs);
+            const includeRuntimeErrors = input.includeRuntimeErrors !== false;
+            const limit = resolveLimit(input.limit, DEFAULT_EVENT_LIMIT);
+            const responseProfile = resolveResponseProfile(input.responseProfile);
+            const includeArgs = responseProfile === 'compact' && input.includeArgs === true;
+            const maxResponseBytes = resolveMaxResponseBytes(input.maxResponseBytes);
+            const dedupeWindowMs = resolveDurationMs(input.dedupeWindowMs, 0, 60_000);
+            const capture = await executeLiveCapture(captureClient, sessionId, 'CAPTURE_GET_LIVE_CONSOLE_LOGS', {
+                origin,
+                tabId,
+                levels,
+                contains,
+                sinceTs,
+                includeRuntimeErrors,
+                dedupeWindowMs,
+                limit,
+            }, 3_000);
+            const payload = ensureCaptureSuccess(capture, sessionId);
+            const rawLogs = asRecordArray(payload.logs);
+            const logs = rawLogs.map((entry) => mapLiveConsoleLogRecord(entry, responseProfile, { includeArgs }));
+            const bytePage = applyByteBudget(logs, maxResponseBytes);
+            const truncated = (capture.truncated ?? false) || bytePage.truncatedByBytes;
+            const paginationRecord = typeof payload.pagination === 'object' && payload.pagination !== null
+                ? payload.pagination
+                : {};
+            const matched = typeof paginationRecord.matched === 'number'
+                ? Math.max(0, Math.floor(paginationRecord.matched))
+                : rawLogs.length;
+            return {
+                ...createBaseResponse(sessionId),
+                limitsApplied: {
+                    maxResults: limit,
+                    truncated,
+                },
+                responseProfile,
+                responseBytes: bytePage.responseBytes,
+                logs: bytePage.items,
+                pagination: {
+                    returned: bytePage.items.length,
+                    matched,
+                    hasMore: truncated,
+                    maxResponseBytes,
+                },
+                filtersApplied: typeof payload.filtersApplied === 'object' && payload.filtersApplied !== null
+                    ? payload.filtersApplied
+                    : {
+                        tabId,
+                        origin,
+                        levels,
+                        contains,
+                        sinceTs,
+                        includeRuntimeErrors,
+                        dedupeWindowMs,
+                    },
+                bufferStats: payload.bufferStats,
             };
         },
     };
@@ -1578,6 +2604,15 @@ function createDefaultHandler(toolName) {
         };
     };
 }
+function attachResponseBytes(response) {
+    if (typeof response.responseBytes === 'number' && Number.isFinite(response.responseBytes)) {
+        return response;
+    }
+    return {
+        ...response,
+        responseBytes: estimateJsonBytes(response),
+    };
+}
 export function createToolRegistry(overrides = {}) {
     return ALL_TOOLS.map((toolName) => {
         const schema = TOOL_SCHEMAS[toolName] ?? { type: 'object', properties: {} };
@@ -1594,7 +2629,8 @@ export async function routeToolCall(tools, toolName, input) {
     if (!tool) {
         throw new Error(`Unknown tool: ${toolName}`);
     }
-    return tool.handler(isRecord(input) ? input : {});
+    const response = await tool.handler(isRecord(input) ? input : {});
+    return attachResponseBytes(response);
 }
 export function createMCPServer(overrides = {}, options = {}) {
     const logger = options.logger ?? createDefaultMcpLogger();