browser-debug-mcp-bridge 1.4.0 → 1.6.0

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

@@ -38,9 +38,9 @@ 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' },
@@ -48,18 +48,18 @@ const TOOL_SCHEMAS = {
     },
     get_navigation_history: {
         type: 'object',
-        required: ['sessionId'],
         properties: {
             sessionId: { type: 'string' },
+            url: { type: 'string' },
             limit: { type: 'number' },
             offset: { 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' },
@@ -78,6 +78,7 @@ const TOOL_SCHEMAS = {
         type: 'object',
         properties: {
             sessionId: { type: 'string' },
+            url: { type: 'string' },
             errorType: { type: 'string' },
             groupBy: { type: 'string' },
             limit: { type: 'number' },
@@ -143,6 +144,20 @@ const TOOL_SCHEMAS = {
             maxAncestors: { type: 'number' },
         },
     },
+    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' },
+            limit: { type: 'number' },
+        },
+    },
     explain_last_failure: {
         type: 'object',
         required: ['sessionId'],
@@ -208,6 +223,7 @@ const TOOL_DESCRIPTIONS = {
     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',
@@ -225,6 +241,7 @@ const DEFAULT_EVENT_LIMIT = 50;
 const MAX_LIMIT = 200;
 const DEFAULT_SNAPSHOT_ASSET_CHUNK_BYTES = 64 * 1024;
 const MAX_SNAPSHOT_ASSET_CHUNK_BYTES = 256 * 1024;
+const LIVE_SESSION_DISCONNECTED_CODE = 'LIVE_SESSION_DISCONNECTED';
 const NETWORK_DOMAIN_GROUP_SQL = `
   CASE
     WHEN instr(replace(replace(url, 'https://', ''), 'http://', ''), '/') > 0
@@ -236,6 +253,16 @@ const NETWORK_DOMAIN_GROUP_SQL = `
     ELSE replace(replace(url, 'https://', ''), 'http://', '')
   END
 `;
+class LiveSessionDisconnectedError extends Error {
+    code = LIVE_SESSION_DISCONNECTED_CODE;
+    constructor(sessionId, reason) {
+        const normalizedReason = typeof reason === 'string' && reason.trim().length > 0
+            ? reason.trim()
+            : 'Extension connection is stale or unavailable';
+        super(`${LIVE_SESSION_DISCONNECTED_CODE}: Session ${sessionId} is not connected to a live extension target. ${normalizedReason}. Start a fresh session in the extension and retry with a connected sessionId from list_sessions.`);
+        this.name = 'LiveSessionDisconnectedError';
+    }
+}
 function resolveLimit(value, fallback) {
     if (typeof value !== 'number' || !Number.isFinite(value)) {
         return fallback;
@@ -292,6 +319,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) {
@@ -302,12 +388,17 @@ function resolveLastUrl(payload) {
     return undefined;
 }
 function mapEventRecord(row) {
+    const payload = readJsonPayload(row.payload_json);
     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) {
@@ -517,13 +608,62 @@ function asStringArray(value, maxItems) {
         .filter((entry) => typeof entry === 'string' && entry.length > 0)
         .slice(0, maxItems);
 }
-function ensureCaptureSuccess(result) {
+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 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')
+        || normalized.includes('receiving end does not exist')
+        || normalized.includes('could not establish connection')
+        || normalized.includes('connection closed before capture completed')
+        || normalized.includes('websocket manager closed')
+        || normalized.includes('extension target is unavailable')
+        || normalized.includes('target tab for this session is unavailable');
+}
+function normalizeCaptureError(sessionId, error) {
+    const fallback = error instanceof Error ? error : new Error(String(error));
+    const message = fallback.message ?? '';
+    if (isLiveSessionDisconnectedMessage(message)) {
+        return new LiveSessionDisconnectedError(sessionId, message);
+    }
+    return fallback;
+}
+function isLiveSessionDisconnectedError(error) {
+    return error instanceof LiveSessionDisconnectedError;
+}
+async function executeLiveCapture(captureClient, sessionId, command, payload, timeoutMs) {
+    try {
+        return await captureClient.execute(sessionId, command, payload, timeoutMs);
+    }
+    catch (error) {
+        throw normalizeCaptureError(sessionId, error);
+    }
+}
+function ensureCaptureSuccess(result, sessionId) {
     if (!result.ok) {
-        throw new Error(result.error ?? 'Capture command failed');
+        throw normalizeCaptureError(sessionId, new Error(result.error ?? 'Capture command failed'));
     }
     return result.payload ?? {};
 }
-export function createV1ToolHandlers(getDb) {
+export function createV1ToolHandlers(getDb, getSessionConnectionState) {
     return {
         list_sessions: async (input) => {
             const db = getDb();
@@ -577,6 +717,23 @@ export function createV1ToolHandlers(getDb) {
                 dpr: row.dpr ?? undefined,
                 safeMode: row.safe_mode === 1,
                 pinned: row.pinned === 1,
+                liveConnection: (() => {
+                    const state = getSessionConnectionState?.(row.session_id);
+                    if (!state) {
+                        return {
+                            connected: false,
+                            lastHeartbeatAt: undefined,
+                            disconnectReason: row.ended_at ? 'manual_stop' : undefined,
+                        };
+                    }
+                    return {
+                        connected: state.connected,
+                        connectedAt: state.connectedAt,
+                        lastHeartbeatAt: state.lastHeartbeatAt,
+                        disconnectedAt: state.disconnectedAt,
+                        disconnectReason: state.disconnectReason,
+                    };
+                })(),
             }));
             return {
                 ...createBaseResponse(),
@@ -656,14 +813,18 @@ export function createV1ToolHandlers(getDb) {
         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 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})`);
@@ -671,7 +832,7 @@ export function createV1ToolHandlers(getDb) {
             }
             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
@@ -695,20 +856,26 @@ export function createV1ToolHandlers(getDb) {
         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 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);
+                .all(...params, limit + 1, offset);
             const truncated = rows.length > limit;
             return {
                 ...createBaseResponse(sessionId),
@@ -726,23 +893,27 @@ export function createV1ToolHandlers(getDb) {
         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 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 ?
       `)
@@ -814,6 +985,8 @@ export function createV1ToolHandlers(getDb) {
         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);
@@ -825,6 +998,7 @@ export function createV1ToolHandlers(getDb) {
                 where.push('session_id = ?');
                 params.push(sessionId);
             }
+            appendNetworkOriginFilter(where, params, origin);
             where.push(errorFilter);
             if (errorFilter === 'error_class = ?' && errorType) {
                 params.push(errorType);
@@ -872,7 +1046,7 @@ export function createV1ToolHandlers(getDb) {
             }
             const rows = db
                 .prepare(`
-          SELECT request_id, session_id, ts_start, duration_ms, method, url, status, initiator, error_class
+          SELECT request_id, session_id, ts_start, duration_ms, method, url, origin, status, initiator, error_class
           FROM network
           ${whereClause}
           ORDER BY ts_start DESC
@@ -897,6 +1071,7 @@ export function createV1ToolHandlers(getDb) {
                     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),
@@ -917,7 +1092,7 @@ export function createV1ToolHandlers(getDb) {
             const offset = resolveOffset(input.offset);
             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')
@@ -951,7 +1126,7 @@ export function createV1ToolHandlers(getDb) {
             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'))
@@ -961,7 +1136,7 @@ export function createV1ToolHandlers(getDb) {
                 .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, 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)
@@ -989,7 +1164,7 @@ export function createV1ToolHandlers(getDb) {
             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 ?
@@ -998,7 +1173,7 @@ export function createV1ToolHandlers(getDb) {
                 .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, ts_start, duration_ms, method, url, origin, status, initiator, error_class
           FROM network
           WHERE session_id = ?
             AND ts_start BETWEEN ? AND ?
@@ -1081,7 +1256,7 @@ export function createV1ToolHandlers(getDb) {
             }
             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
@@ -1096,7 +1271,7 @@ export function createV1ToolHandlers(getDb) {
             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 != ?
@@ -1105,7 +1280,7 @@ export function createV1ToolHandlers(getDb) {
                 .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, ts_start, duration_ms, method, url, origin, status, initiator, error_class
           FROM network
           WHERE session_id = ?
             AND ts_start BETWEEN ? AND ?
@@ -1373,14 +1548,14 @@ export function createV2ToolHandlers(captureClient) {
             }
             const maxDepth = resolveCaptureDepth(input.maxDepth, 3);
             const maxBytes = resolveCaptureBytes(input.maxBytes, 50_000);
-            const capture = await captureClient.execute(sessionId, 'CAPTURE_DOM_SUBTREE', { selector, maxDepth, maxBytes }, 4_000);
+            const capture = await executeLiveCapture(captureClient, sessionId, 'CAPTURE_DOM_SUBTREE', { selector, maxDepth, maxBytes }, 4_000);
             return {
                 ...createBaseResponse(sessionId),
                 limitsApplied: {
                     maxResults: maxBytes,
                     truncated: capture.truncated ?? false,
                 },
-                ...ensureCaptureSuccess(capture),
+                ...ensureCaptureSuccess(capture, sessionId),
             };
         },
         get_dom_document: async (input) => {
@@ -1392,21 +1567,22 @@ export function createV2ToolHandlers(captureClient) {
             const maxBytes = resolveCaptureBytes(input.maxBytes, 200_000);
             const maxDepth = resolveCaptureDepth(input.maxDepth, 4);
             try {
-                const capture = await captureClient.execute(sessionId, 'CAPTURE_DOM_DOCUMENT', { mode, maxBytes, maxDepth }, 4_000);
+                const capture = await executeLiveCapture(captureClient, sessionId, 'CAPTURE_DOM_DOCUMENT', { mode, maxBytes, maxDepth }, 4_000);
                 return {
                     ...createBaseResponse(sessionId),
                     limitsApplied: {
                         maxResults: maxBytes,
                         truncated: capture.truncated ?? false,
                     },
-                    ...ensureCaptureSuccess(capture),
+                    ...ensureCaptureSuccess(capture, sessionId),
                 };
             }
             catch (error) {
-                if (mode !== 'html') {
-                    throw error;
+                const normalized = normalizeCaptureError(sessionId, error);
+                if (mode !== 'html' || isLiveSessionDisconnectedError(normalized)) {
+                    throw normalized;
                 }
-                const fallback = await captureClient.execute(sessionId, 'CAPTURE_DOM_DOCUMENT', { mode: 'outline', maxBytes, maxDepth }, 4_000);
+                const fallback = await executeLiveCapture(captureClient, sessionId, 'CAPTURE_DOM_DOCUMENT', { mode: 'outline', maxBytes, maxDepth }, 4_000);
                 return {
                     ...createBaseResponse(sessionId),
                     limitsApplied: {
@@ -1414,7 +1590,7 @@ export function createV2ToolHandlers(captureClient) {
                         truncated: true,
                     },
                     fallbackReason: 'timeout',
-                    ...ensureCaptureSuccess(fallback),
+                    ...ensureCaptureSuccess(fallback, sessionId),
                 };
             }
         },
@@ -1428,14 +1604,14 @@ export function createV2ToolHandlers(captureClient) {
                 throw new Error('selector is required');
             }
             const properties = asStringArray(input.properties, 64);
-            const capture = await captureClient.execute(sessionId, 'CAPTURE_COMPUTED_STYLES', { selector, properties }, 3_000);
+            const capture = await executeLiveCapture(captureClient, sessionId, 'CAPTURE_COMPUTED_STYLES', { selector, properties }, 3_000);
             return {
                 ...createBaseResponse(sessionId),
                 limitsApplied: {
                     maxResults: properties.length || 8,
                     truncated: capture.truncated ?? false,
                 },
-                ...ensureCaptureSuccess(capture),
+                ...ensureCaptureSuccess(capture, sessionId),
             };
         },
         get_layout_metrics: async (input) => {
@@ -1444,14 +1620,14 @@ export function createV2ToolHandlers(captureClient) {
                 throw new Error('sessionId is required');
             }
             const selector = typeof input.selector === 'string' ? input.selector : undefined;
-            const capture = await captureClient.execute(sessionId, 'CAPTURE_LAYOUT_METRICS', { selector }, 3_000);
+            const capture = await executeLiveCapture(captureClient, sessionId, 'CAPTURE_LAYOUT_METRICS', { selector }, 3_000);
             return {
                 ...createBaseResponse(sessionId),
                 limitsApplied: {
                     maxResults: 1,
                     truncated: capture.truncated ?? false,
                 },
-                ...ensureCaptureSuccess(capture),
+                ...ensureCaptureSuccess(capture, sessionId),
             };
         },
         capture_ui_snapshot: async (input) => {
@@ -1473,7 +1649,7 @@ export function createV2ToolHandlers(captureClient) {
             const maxDepth = resolveCaptureDepth(input.maxDepth, 3);
             const maxBytes = resolveCaptureBytes(input.maxBytes, 50_000);
             const maxAncestors = resolveCaptureAncestors(input.maxAncestors, 4);
-            const capture = await captureClient.execute(sessionId, 'CAPTURE_UI_SNAPSHOT', {
+            const capture = await executeLiveCapture(captureClient, sessionId, 'CAPTURE_UI_SNAPSHOT', {
                 selector,
                 trigger,
                 mode,
@@ -1490,7 +1666,39 @@ export function createV2ToolHandlers(captureClient) {
                     maxResults: maxBytes,
                     truncated: capture.truncated ?? false,
                 },
-                ...ensureCaptureSuccess(capture),
+                ...ensureCaptureSuccess(capture, sessionId),
+            };
+        },
+        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 capture = await executeLiveCapture(captureClient, sessionId, 'CAPTURE_GET_LIVE_CONSOLE_LOGS', {
+                origin,
+                tabId,
+                levels,
+                contains,
+                sinceTs,
+                includeRuntimeErrors,
+                limit,
+            }, 3_000);
+            return {
+                ...createBaseResponse(sessionId),
+                limitsApplied: {
+                    maxResults: limit,
+                    truncated: capture.truncated ?? false,
+                },
+                ...ensureCaptureSuccess(capture, sessionId),
             };
         },
     };
@@ -1542,7 +1750,7 @@ export function createMCPServer(overrides = {}, options = {}) {
     const logger = options.logger ?? createDefaultMcpLogger();
     const v2Handlers = options.captureClient ? createV2ToolHandlers(options.captureClient) : {};
     const tools = createToolRegistry({
-        ...createV1ToolHandlers(() => getConnection().db),
+        ...createV1ToolHandlers(() => getConnection().db, options.getSessionConnectionState),
         ...v2Handlers,
         ...overrides,
     });