agent-vision-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kedar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,117 @@
+<div align="center">
+  <h1>Agent Vision</h1>
+  <p align="center">
+  <img src="./docs/banner.png" width="800" />
+  </p>
+  <p>
+    <img alt="TypeScript" src="https://img.shields.io/badge/TypeScript-ES2022-3178C6?style=flat-square" />
+    <img alt="Chrome CDP" src="https://img.shields.io/badge/Chrome-CDP-4285F4?style=flat-square" />
+    <img alt="MCP" src="https://img.shields.io/badge/MCP-stdio-7C3AED?style=flat-square" />
+    <img alt="License" src="https://img.shields.io/badge/License-MIT-22C55E?style=flat-square" />
+  </p>
+</div>
+
+Agent Vision is a browser-first MCP server that gives agents direct visual access to live Chrome or Brave tabs through the Chrome DevTools Protocol. Instead of asking users to manually capture screenshots and upload them into chat, Agent Vision lets a coding agent resolve a tab by title or URL, capture a real screenshot on demand, and pull structured browser context like visible text, page metadata, and viewport details in the same flow.
+
+## Problem
+
+LLM workflows break down when visual browser context is trapped behind manual steps. A user sees an issue in a tab, but the agent cannot see the same thing unless the user pauses, takes a screenshot, uploads it, and adds extra explanation. That friction slows debugging, weakens iteration speed, and loses important structured context that browsers already expose natively. Agent Vision solves this by making browser state directly available as MCP tools.
+
+## Workflow
+
+```mermaid
+flowchart TD
+    A[User asks agent to inspect a browser tab] --> B[Codex calls Agent Vision MCP tool]
+    B --> C[Agent Vision queries Chrome DevTools Protocol]
+    C --> D[Discover live tabs]
+    D --> E[Resolve best matching tab by title or URL]
+    E --> F[Capture screenshot through CDP]
+    E --> G[Evaluate page for visible text and metadata]
+    F --> H[Return MCP image content]
+    G --> I[Return MCP structured text content]
+    H --> J[Agent receives visual + structured browser context]
+    I --> J
+```
+
+## Tools
+
+| Tool | What it does |
+| --- | --- |
+| `getBrowserCdpStatus` | Checks whether Agent Vision can reach the configured Chrome DevTools Protocol endpoint. |
+| `discoverBrowserTabsViaCdp` | Returns the raw live tab list exposed by Chrome DevTools Protocol. |
+| `refreshLiveBrowserTabs` | Refreshes the normalized in-memory live tab model from CDP. |
+| `listLiveBrowserTabs` | Returns the cached normalized live tab model without re-querying the browser. |
+| `pruneStaleLiveBrowserTabs` | Removes cached tabs that have become stale because they have not been refreshed recently. |
+| `resolveLiveBrowserTab` | Resolves the active or best matching tab for a `/see`-style query using title and URL heuristics. |
+| `captureResolvedBrowserTabScreenshot` | Captures a real PNG screenshot from the resolved browser tab via CDP. |
+| `getResolvedBrowserTabContext` | Extracts structured page context such as visible text, page title, page URL, language, content type, and viewport metadata. |
+| `seeBrowserTabViaCdp` | Runs the full high-level browser inspection flow: resolve tab, capture screenshot, and return structured browser context. |
+
+## Setup And Installation
+
+### Prerequisites
+
+- Node.js 22+
+- Brave, Chrome, or another Chromium-based browser
+- Codex configured locally with MCP support
+
+### Install dependencies
+
+```bash
+npm install
+npm run build
+```
+
+### Start a CDP-enabled browser session
+
+```bash
+brave-browser --remote-debugging-port=9222 --user-data-dir=/tmp/agent-vision-cdp
+```
+
+### Register Agent Vision in Codex
+
+Add this to `~/.codex/config.toml`:
+
+```toml
+[mcp_servers.agent-vision]
+command = "/home/kedar/.nvm/versions/node/v22.22.0/bin/node"
+args = ["/home/kedar/Desktop/Projects/llm_vision/dist/mcp-stdio.js"]
+```
+
+Then restart Codex.
+
+### Verify the MCP server is available
+
+```bash
+codex mcp list
+```
+
+## Example Usage
+
+### Manual local verification
+
+```bash
+npm run demo-cdp
+```
+
+### Example Codex prompts
+
+```text
+Use the agent-vision MCP server to list my live browser tabs.
+Use the agent-vision MCP server to inspect the active browser tab.
+Use the agent-vision MCP server to inspect the tab matching "docs".
+```
+
+### Future npm-distributed registration shape
+
+After publishing, the Codex config can switch to:
+
+```toml
+[mcp_servers.agent-vision]
+command = "npx"
+args = ["-y", "agent-vision-mcp"]
+```
+
+## License
+
+MIT. See [LICENSE](./LICENSE).

package/dist/browser/cdp/browser-cdp-discovery-service.d.ts

@@ -0,0 +1,10 @@
+import type { Logger } from "../../logging/logger.js";
+import { ChromeCdpClient } from "./chrome-cdp-client.js";
+import type { CdpConnectionStatus, CdpTabDiscoveryResult } from "./types.js";
+export declare class BrowserCdpDiscoveryService {
+    private readonly client;
+    private readonly logger;
+    constructor(client: ChromeCdpClient, logger: Logger);
+    getConnectionStatus(endpointOverride?: string): Promise<CdpConnectionStatus>;
+    discoverTabs(endpointOverride?: string): Promise<CdpTabDiscoveryResult>;
+}

package/dist/browser/cdp/browser-cdp-discovery-service.js

@@ -0,0 +1,28 @@
+export class BrowserCdpDiscoveryService {
+    client;
+    logger;
+    constructor(client, logger) {
+        this.client = client;
+        this.logger = logger;
+    }
+    async getConnectionStatus(endpointOverride) {
+        const status = await this.client.getConnectionStatus(endpointOverride);
+        if (status.connected) {
+            this.logger.info("CDP connection ready", {
+                endpoint: status.endpoint,
+                browser: status.browser,
+                protocolVersion: status.protocolVersion
+            });
+        }
+        return status;
+    }
+    async discoverTabs(endpointOverride) {
+        const result = await this.client.discoverTabs(endpointOverride);
+        this.logger.info("CDP tab discovery completed", {
+            endpoint: result.endpoint,
+            tabCount: result.tabs.length,
+            browser: result.browser
+        });
+        return result;
+    }
+}

package/dist/browser/cdp/browser-live-tab-service.d.ts

@@ -0,0 +1,16 @@
+import type { Logger } from "../../logging/logger.js";
+import { BrowserCdpDiscoveryService } from "./browser-cdp-discovery-service.js";
+import { LiveBrowserTabRegistry } from "./live-browser-tab-registry.js";
+import { type LiveBrowserTabDiscoveryResult, type LiveBrowserTab } from "./tab-model.js";
+export declare class BrowserLiveTabService {
+    private readonly discovery;
+    private readonly registry;
+    private readonly logger;
+    constructor(discovery: BrowserCdpDiscoveryService, registry: LiveBrowserTabRegistry, logger: Logger);
+    refresh(endpointOverride?: string): Promise<LiveBrowserTabDiscoveryResult>;
+    pruneStale(maxAgeMs?: number): {
+        removed: LiveBrowserTab[];
+        remaining: LiveBrowserTabDiscoveryResult;
+    };
+    list(): LiveBrowserTabDiscoveryResult;
+}

package/dist/browser/cdp/browser-live-tab-service.js

@@ -0,0 +1,42 @@
+import { toDiscoveryResult } from "./tab-model.js";
+export class BrowserLiveTabService {
+    discovery;
+    registry;
+    logger;
+    constructor(discovery, registry, logger) {
+        this.discovery = discovery;
+        this.registry = registry;
+        this.logger = logger;
+    }
+    async refresh(endpointOverride) {
+        const discoveryResult = await this.discovery.discoverTabs(endpointOverride);
+        const tabs = this.registry.upsertDiscovery({
+            endpoint: discoveryResult.endpoint,
+            discoveredAt: discoveryResult.discoveredAt,
+            tabs: discoveryResult.tabs
+        });
+        this.logger.info("Refreshed live browser tab model", {
+            endpoint: discoveryResult.endpoint,
+            tabCount: tabs.length,
+            browser: discoveryResult.browser
+        });
+        return toDiscoveryResult(discoveryResult, tabs);
+    }
+    pruneStale(maxAgeMs) {
+        const removed = this.registry.pruneStale(maxAgeMs);
+        return {
+            removed,
+            remaining: this.list()
+        };
+    }
+    list() {
+        const tabs = this.registry.list();
+        const discoveredAt = tabs[0]?.lastSeenAt ?? new Date().toISOString();
+        const endpoint = tabs[0]?.lastDiscoveryEndpoint ?? "unknown";
+        return {
+            endpoint,
+            discoveredAt,
+            tabs
+        };
+    }
+}

package/dist/browser/cdp/browser-see-service.d.ts

@@ -0,0 +1,33 @@
+import type { Logger } from "../../logging/logger.js";
+import { BrowserLiveTabService } from "./browser-live-tab-service.js";
+import { BrowserTabContextService } from "./browser-tab-context-service.js";
+import { BrowserTabScreenshotService } from "./browser-tab-screenshot-service.js";
+import type { BrowserTabScreenshot, BrowserTabStructuredContext } from "./types.js";
+import type { LiveBrowserTabCandidate } from "./tab-resolution.js";
+export type BrowserSeeResult = {
+    status: "completed";
+    query?: string;
+    stage: "completed";
+    matchedCandidate: LiveBrowserTabCandidate;
+    candidateCount: number;
+    screenshot: BrowserTabScreenshot;
+    context: BrowserTabStructuredContext;
+    message: string;
+    recoveredAfterRefresh?: boolean;
+} | {
+    status: "ambiguous" | "not_found";
+    query?: string;
+    stage: "needs_disambiguation" | "not_found";
+    candidates: LiveBrowserTabCandidate[];
+    message: string;
+    recoveredAfterRefresh?: boolean;
+};
+export declare class BrowserSeeService {
+    private readonly liveTabs;
+    private readonly screenshots;
+    private readonly contexts;
+    private readonly logger;
+    constructor(liveTabs: BrowserLiveTabService, screenshots: BrowserTabScreenshotService, contexts: BrowserTabContextService, logger: Logger);
+    see(query?: string): Promise<BrowserSeeResult>;
+    private seeOnce;
+}

package/dist/browser/cdp/browser-see-service.js

@@ -0,0 +1,76 @@
+export class BrowserSeeService {
+    liveTabs;
+    screenshots;
+    contexts;
+    logger;
+    constructor(liveTabs, screenshots, contexts, logger) {
+        this.liveTabs = liveTabs;
+        this.screenshots = screenshots;
+        this.contexts = contexts;
+        this.logger = logger;
+    }
+    async see(query) {
+        try {
+            const firstAttempt = await this.seeOnce(query, false);
+            if (firstAttempt.status !== "not_found") {
+                return firstAttempt;
+            }
+            this.logger.warn("Browser-first /see returned not_found, retrying after refresh", {
+                query,
+                candidateCount: firstAttempt.candidates.length
+            });
+            await this.liveTabs.refresh();
+            return await this.seeOnce(query, true);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.warn("Browser-first /see failed before completion, retrying after refresh", {
+                query,
+                errorMessage: message
+            });
+            await this.liveTabs.refresh();
+            return await this.seeOnce(query, true);
+        }
+    }
+    async seeOnce(query, recoveredAfterRefresh) {
+        const screenshotResult = await this.screenshots.captureResolved(query);
+        if (screenshotResult.status !== "completed") {
+            this.logger.info("Browser-first /see did not complete immediately", {
+                query,
+                status: screenshotResult.status,
+                candidateCount: screenshotResult.candidates.length,
+                recoveredAfterRefresh
+            });
+            return {
+                status: screenshotResult.status,
+                query: screenshotResult.query,
+                stage: screenshotResult.status === "ambiguous" ? "needs_disambiguation" : "not_found",
+                candidates: screenshotResult.candidates,
+                message: screenshotResult.message,
+                ...(recoveredAfterRefresh ? { recoveredAfterRefresh: true } : {})
+            };
+        }
+        const context = await this.contexts.getForResolvedTab(screenshotResult.resolution, query);
+        const mapped = {
+            status: "completed",
+            query: screenshotResult.query,
+            stage: "completed",
+            matchedCandidate: screenshotResult.resolution.matchedCandidate,
+            candidateCount: screenshotResult.resolution.candidateCount,
+            screenshot: screenshotResult.screenshot,
+            context,
+            message: `Captured browser tab \"${screenshotResult.screenshot.title}\" through CDP with structured page context.`,
+            ...(recoveredAfterRefresh ? { recoveredAfterRefresh: true } : {})
+        };
+        this.logger.info("Completed browser-first /see flow", {
+            query,
+            title: mapped.screenshot.title,
+            targetId: mapped.screenshot.targetId,
+            width: mapped.screenshot.width,
+            height: mapped.screenshot.height,
+            visibleTextLength: mapped.context.visibleTextLength,
+            recoveredAfterRefresh
+        });
+        return mapped;
+    }
+}

package/dist/browser/cdp/browser-tab-context-service.d.ts

@@ -0,0 +1,23 @@
+import type { Logger } from "../../logging/logger.js";
+import { BrowserTabResolutionService } from "./browser-tab-resolution-service.js";
+import type { LiveBrowserTabResolution } from "./tab-resolution.js";
+import type { BrowserTabStructuredContext } from "./types.js";
+export type GetResolvedBrowserTabContextResult = {
+    status: "completed";
+    query?: string;
+    resolution: Extract<LiveBrowserTabResolution, {
+        status: "resolved";
+    }>;
+    context: BrowserTabStructuredContext;
+} | Extract<LiveBrowserTabResolution, {
+    status: "ambiguous" | "not_found";
+}>;
+export declare class BrowserTabContextService {
+    private readonly resolver;
+    private readonly logger;
+    constructor(resolver: BrowserTabResolutionService, logger: Logger);
+    getForResolvedTab(resolution: Extract<LiveBrowserTabResolution, {
+        status: "resolved";
+    }>, query?: string): Promise<BrowserTabStructuredContext>;
+    getResolvedContext(query?: string): Promise<GetResolvedBrowserTabContextResult>;
+}

package/dist/browser/cdp/browser-tab-context-service.js

@@ -0,0 +1,90 @@
+import { withCdpTabSession } from "./cdp-websocket-session.js";
+const nowIso = () => new Date().toISOString();
+const CONTEXT_EVALUATION_EXPRESSION = `(() => {
+  const bodyText = document.body?.innerText ?? "";
+  return {
+    pageTitle: document.title ?? "",
+    pageUrl: window.location.href ?? "",
+    documentLanguage: document.documentElement?.lang ?? "",
+    contentType: document.contentType ?? "",
+    visibleText: bodyText,
+    viewport: {
+      width: window.innerWidth,
+      height: window.innerHeight,
+      devicePixelRatio: window.devicePixelRatio
+    }
+  };
+})()`;
+const asOptionalString = (value) => typeof value === "string" && value.trim() !== "" ? value : undefined;
+const asVisibleText = (value) => (typeof value === "string" ? value : "");
+const asViewport = (value) => {
+    if (!value || typeof value !== "object") {
+        return undefined;
+    }
+    const candidate = value;
+    return {
+        width: typeof candidate.width === "number" ? candidate.width : undefined,
+        height: typeof candidate.height === "number" ? candidate.height : undefined,
+        devicePixelRatio: typeof candidate.devicePixelRatio === "number" ? candidate.devicePixelRatio : undefined
+    };
+};
+const collectTabContext = async (resolution) => await withCdpTabSession(resolution.tab, async (session) => {
+    await session.sendCommand("Page.enable");
+    await session.sendCommand("Runtime.enable");
+    const evaluation = await session.sendCommand("Runtime.evaluate", {
+        expression: CONTEXT_EVALUATION_EXPRESSION,
+        returnByValue: true
+    });
+    const result = evaluation.result;
+    const value = result && typeof result === "object" && "value" in result
+        ? result.value
+        : undefined;
+    const payload = value && typeof value === "object" ? value : {};
+    const visibleText = asVisibleText(payload.visibleText);
+    return {
+        targetId: resolution.tab.targetId,
+        title: resolution.tab.title,
+        url: resolution.tab.url,
+        browserName: resolution.tab.browserName,
+        pageTitle: asOptionalString(payload.pageTitle),
+        pageUrl: asOptionalString(payload.pageUrl),
+        documentLanguage: asOptionalString(payload.documentLanguage),
+        contentType: asOptionalString(payload.contentType),
+        visibleText,
+        visibleTextLength: visibleText.length,
+        viewport: asViewport(payload.viewport),
+        collectedAt: nowIso(),
+        backend: "cdp-runtime-evaluate"
+    };
+});
+export class BrowserTabContextService {
+    resolver;
+    logger;
+    constructor(resolver, logger) {
+        this.resolver = resolver;
+        this.logger = logger;
+    }
+    async getForResolvedTab(resolution, query) {
+        const context = await collectTabContext(resolution);
+        this.logger.info("Collected structured browser tab context via CDP", {
+            query,
+            targetId: resolution.tab.targetId,
+            title: resolution.tab.title,
+            visibleTextLength: context.visibleTextLength
+        });
+        return context;
+    }
+    async getResolvedContext(query) {
+        const resolution = this.resolver.resolve(query);
+        if (resolution.status !== "resolved") {
+            return resolution;
+        }
+        const context = await this.getForResolvedTab(resolution, query);
+        return {
+            status: "completed",
+            query,
+            resolution,
+            context
+        };
+    }
+}

package/dist/browser/cdp/browser-tab-resolution-service.d.ts

@@ -0,0 +1,9 @@
+import type { Logger } from "../../logging/logger.js";
+import { BrowserLiveTabService } from "./browser-live-tab-service.js";
+import { type LiveBrowserTabResolution } from "./tab-resolution.js";
+export declare class BrowserTabResolutionService {
+    private readonly liveTabs;
+    private readonly logger;
+    constructor(liveTabs: BrowserLiveTabService, logger: Logger);
+    resolve(query?: string): LiveBrowserTabResolution;
+}

package/dist/browser/cdp/browser-tab-resolution-service.js

@@ -0,0 +1,65 @@
+import { scoreLiveTab, sortCandidates } from "./tab-resolution.js";
+export class BrowserTabResolutionService {
+    liveTabs;
+    logger;
+    constructor(liveTabs, logger) {
+        this.liveTabs = liveTabs;
+        this.logger = logger;
+    }
+    resolve(query) {
+        const live = this.liveTabs.list();
+        const tabs = live.tabs;
+        if (tabs.length === 0) {
+            return {
+                status: "not_found",
+                query,
+                candidates: [],
+                message: "No live browser tabs are available. Refresh CDP discovery first."
+            };
+        }
+        const candidates = tabs
+            .map((tab) => scoreLiveTab(tab, query))
+            .filter((candidate) => candidate !== undefined)
+            .sort(sortCandidates);
+        if (candidates.length === 0) {
+            return {
+                status: "not_found",
+                query,
+                candidates: tabs.slice(0, 5).map((tab) => scoreLiveTab(tab)).sort(sortCandidates),
+                message: "No live browser tab matched the query."
+            };
+        }
+        if (candidates.length > 1 && candidates[0].matchScore === candidates[1].matchScore) {
+            return {
+                status: "ambiguous",
+                query,
+                candidates: candidates.slice(0, 5),
+                message: "Multiple live browser tabs matched the query. Provide a more specific title or URL."
+            };
+        }
+        const matched = tabs.find((tab) => tab.targetId === candidates[0].targetId);
+        if (!matched) {
+            return {
+                status: "not_found",
+                query,
+                candidates: candidates.slice(0, 5),
+                message: "The best matching browser tab disappeared before it could be resolved."
+            };
+        }
+        this.logger.info("Resolved live browser tab", {
+            query,
+            targetId: matched.targetId,
+            title: matched.title,
+            url: matched.url,
+            matchReason: candidates[0].matchReason,
+            matchScore: candidates[0].matchScore
+        });
+        return {
+            status: "resolved",
+            query,
+            tab: matched,
+            matchedCandidate: candidates[0],
+            candidateCount: candidates.length
+        };
+    }
+}

package/dist/browser/cdp/browser-tab-screenshot-service.d.ts

@@ -0,0 +1,20 @@
+import type { Logger } from "../../logging/logger.js";
+import { BrowserTabResolutionService } from "./browser-tab-resolution-service.js";
+import type { LiveBrowserTabResolution } from "./tab-resolution.js";
+import type { BrowserTabScreenshot } from "./types.js";
+export type CaptureResolvedLiveBrowserTabScreenshotResult = {
+    status: "completed";
+    query?: string;
+    resolution: Extract<LiveBrowserTabResolution, {
+        status: "resolved";
+    }>;
+    screenshot: BrowserTabScreenshot;
+} | Extract<LiveBrowserTabResolution, {
+    status: "ambiguous" | "not_found";
+}>;
+export declare class BrowserTabScreenshotService {
+    private readonly resolver;
+    private readonly logger;
+    constructor(resolver: BrowserTabResolutionService, logger: Logger);
+    captureResolved(query?: string): Promise<CaptureResolvedLiveBrowserTabScreenshotResult>;
+}

package/dist/browser/cdp/browser-tab-screenshot-service.js

@@ -0,0 +1,59 @@
+import { withCdpTabSession } from "./cdp-websocket-session.js";
+import { readPngDimensions } from "./png-metadata.js";
+const nowIso = () => new Date().toISOString();
+const captureTabScreenshot = async (resolution) => await withCdpTabSession(resolution.tab, async (session) => {
+    await session.sendCommand("Page.enable");
+    const captureResult = await session.sendCommand("Page.captureScreenshot", {
+        format: "png",
+        fromSurface: true,
+        captureBeyondViewport: true
+    });
+    const data = captureResult.data;
+    if (typeof data !== "string" || data.trim() === "") {
+        throw new Error("CDP screenshot response did not include PNG data");
+    }
+    const buffer = Buffer.from(data, "base64");
+    const dimensions = readPngDimensions(buffer);
+    return {
+        targetId: resolution.tab.targetId,
+        title: resolution.tab.title,
+        url: resolution.tab.url,
+        browserName: resolution.tab.browserName,
+        mimeType: "image/png",
+        bytesBase64: data,
+        width: dimensions.width,
+        height: dimensions.height,
+        byteLength: buffer.byteLength,
+        capturedAt: nowIso(),
+        backend: "cdp-page-capture"
+    };
+});
+export class BrowserTabScreenshotService {
+    resolver;
+    logger;
+    constructor(resolver, logger) {
+        this.resolver = resolver;
+        this.logger = logger;
+    }
+    async captureResolved(query) {
+        const resolution = this.resolver.resolve(query);
+        if (resolution.status !== "resolved") {
+            return resolution;
+        }
+        const screenshot = await captureTabScreenshot(resolution);
+        this.logger.info("Captured browser tab screenshot via CDP", {
+            query,
+            targetId: resolution.tab.targetId,
+            title: resolution.tab.title,
+            width: screenshot.width,
+            height: screenshot.height,
+            byteLength: screenshot.byteLength
+        });
+        return {
+            status: "completed",
+            query,
+            resolution,
+            screenshot
+        };
+    }
+}

package/dist/browser/cdp/cdp-websocket-session.d.ts

@@ -0,0 +1,9 @@
+import WebSocket from "ws";
+import type { LiveBrowserTab } from "./tab-model.js";
+export declare class CdpWebSocketSession {
+    private readonly socket;
+    private nextCommandId;
+    constructor(socket: WebSocket);
+    sendCommand(method: string, params?: Record<string, unknown>, timeoutMs?: number): Promise<Record<string, unknown>>;
+}
+export declare const withCdpTabSession: <T>(tab: LiveBrowserTab, run: (session: CdpWebSocketSession) => Promise<T>) => Promise<T>;