Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
SKY-10320: Keep local CDP debugger on live browser (#6297)
Andrew Neilson75799a06b173
diff --git a/skyvern-frontend/src/routes/browserSessions/BrowserSessionStream.test.ts b/skyvern-frontend/src/routes/browserSessions/BrowserSessionStream.test.tsnew file mode 100644index 000000000..6b420856a--- /dev/null+++ b/skyvern-frontend/src/routes/browserSessions/BrowserSessionStream.test.ts@@ -0,0 +1,61 @@+import { describe, expect, it } from "vitest";++import {+ isTerminalStreamStatus,+ shouldReconnectStream,+} from "./BrowserSessionStream.utils";++describe("isTerminalStreamStatus", () => {+ it("treats missing sessions as terminal stream statuses", () => {+ expect(isTerminalStreamStatus("not_found")).toBe(true);+ expect(isTerminalStreamStatus("running")).toBe(false);+ });+});++describe("shouldReconnectStream", () => {+ it("reconnects non-terminal stream closes below the attempt limit", () => {+ expect(+ shouldReconnectStream({+ closeCode: 1006,+ closeReason: "",+ terminalStatusSeen: false,+ reconnectAttempts: 0,+ }),+ ).toBe(true);+ });++ it("does not reconnect terminal, VNC fallback, normal, or exhausted stream closes", () => {+ expect(+ shouldReconnectStream({+ closeCode: 1000,+ closeReason: "",+ terminalStatusSeen: true,+ reconnectAttempts: 0,+ }),+ ).toBe(false);+ expect(+ shouldReconnectStream({+ closeCode: 1000,+ closeReason: "",+ terminalStatusSeen: false,+ reconnectAttempts: 0,+ }),+ ).toBe(false);+ expect(+ shouldReconnectStream({+ closeCode: 4001,+ closeReason: "use-vnc-streaming",+ terminalStatusSeen: false,+ reconnectAttempts: 0,+ }),+ ).toBe(false);+ expect(+ shouldReconnectStream({+ closeCode: 1006,+ closeReason: "",+ terminalStatusSeen: false,+ reconnectAttempts: 20,+ }),+ ).toBe(false);+ });+});diff --git a/skyvern-frontend/src/routes/browserSessions/BrowserSessionStream.tsx b/skyvern-frontend/src/routes/browserSessions/BrowserSessionStream.tsxindex bfbb84b1c..58bb9e5b6 100644--- a/skyvern-frontend/src/routes/browserSessions/BrowserSessionStream.tsx+++ b/skyvern-frontend/src/routes/browserSessions/BrowserSessionStream.tsx@@ -7,6 +7,12 @@ import {StreamStatusPanel,type StreamDiagnostic,} from "@/routes/streaming/StreamDiagnostics";+import {+ STREAM_MAX_RECONNECT_ATTEMPTS,+ STREAM_RECONNECT_DELAY_MS,+ isTerminalStreamStatus,+ shouldReconnectStream,+} from "./BrowserSessionStream.utils";type StreamMessage = {browser_session_id?: string;@@ -24,6 +30,14 @@ const STARTING_DIAGNOSTIC: StreamDiagnostic = {"Opening the stream WebSocket and waiting for the first browser frame.",};+function diagnosticForReconnectExhausted(): StreamDiagnostic {+ return {+ title: "Stream connection dropped",+ detail: "The browser stream disconnected and could not reconnect.",+ hint: "Refresh the editor or create a new browser session.",+ };+}+function diagnosticForStatus(status: string): StreamDiagnostic {switch (status) {case "not_found":@@ -100,6 +114,9 @@ function BrowserSessionStream({const socketRef = useRef<WebSocket | null>(null);const hasFrameRef = useRef(false);+ const reconnectAttemptsRef = useRef(0);+ const terminalStatusSeenRef = useRef(false);+ const reconnectTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);const inputWsUrl = interactive? `${newWssBaseUrl}/stream/cdp_input/browser_session/${browserSessionId}`@@ -127,8 +144,17 @@ function BrowserSessionStream({setCurrentUrl("");setDiagnostic(STARTING_DIAGNOSTIC);hasFrameRef.current = false;+ reconnectAttemptsRef.current = 0;+ terminalStatusSeenRef.current = false;- async function run() {+ const clearReconnectTimer = () => {+ if (reconnectTimerRef.current) {+ clearTimeout(reconnectTimerRef.current);+ reconnectTimerRef.current = null;+ }+ };++ async function connect() {const credentialParam = await getCredentialParam(credentialGetter);if (cancelled) {return;@@ -153,6 +179,7 @@ function BrowserSessionStream({const message: StreamMessage = JSON.parse(event.data);if (message.screenshot) {hasFrameRef.current = true;+ reconnectAttemptsRef.current = 0;setStreamImgSrc(message.screenshot);}if (message.format) {@@ -170,11 +197,8 @@ function BrowserSessionStream({if (!message.screenshot && message.status) {setDiagnostic(diagnosticForStatus(message.status));}- if (- message.status === "completed" ||- message.status === "failed" ||- message.status === "timeout"- ) {+ if (isTerminalStreamStatus(message.status)) {+ terminalStatusSeenRef.current = true;socketRef.current?.close();}} catch (e) {@@ -195,16 +219,54 @@ function BrowserSessionStream({});socketRef.current.addEventListener("close", (event) => {- if (!cancelled && !hasFrameRef.current) {+ if (+ !cancelled &&+ !hasFrameRef.current &&+ !terminalStatusSeenRef.current+ ) {setDiagnostic(diagnosticForClose(event));}socketRef.current = null;++ const canReconnect =+ !cancelled &&+ shouldReconnectStream({+ closeCode: event.code,+ closeReason: event.reason,+ terminalStatusSeen: terminalStatusSeenRef.current,+ reconnectAttempts: reconnectAttemptsRef.current,+ });++ if (canReconnect) {+ reconnectAttemptsRef.current += 1;+ if (!hasFrameRef.current) {+ setDiagnostic({+ ...diagnosticForClose(event),+ hint: `Reconnecting in ${STREAM_RECONNECT_DELAY_MS / 1000}s (${reconnectAttemptsRef.current}/${STREAM_MAX_RECONNECT_ATTEMPTS}).`,+ });+ }+ clearReconnectTimer();+ reconnectTimerRef.current = setTimeout(() => {+ reconnectTimerRef.current = null;+ void connect();+ }, STREAM_RECONNECT_DELAY_MS);+ } else if (+ !cancelled &&+ !terminalStatusSeenRef.current &&+ hasFrameRef.current &&+ reconnectAttemptsRef.current >= STREAM_MAX_RECONNECT_ATTEMPTS+ ) {+ hasFrameRef.current = false;+ setStreamImgSrc("");+ setDiagnostic(diagnosticForReconnectExhausted());+ }});}- run();+ void connect();return () => {cancelled = true;+ clearReconnectTimer();if (socketRef.current) {socketRef.current.close();socketRef.current = null;diff --git a/skyvern-frontend/src/routes/browserSessions/BrowserSessionStream.utils.ts b/skyvern-frontend/src/routes/browserSessions/BrowserSessionStream.utils.tsnew file mode 100644index 000000000..78ba6d815--- /dev/null+++ b/skyvern-frontend/src/routes/browserSessions/BrowserSessionStream.utils.ts@@ -0,0 +1,49 @@+const TERMINAL_STREAM_STATUSES = new Set([+ "completed",+ "failed",+ "timeout",+ "not_found",+]);++const STREAM_RECONNECT_DELAY_MS = 1000;+const STREAM_MAX_RECONNECT_ATTEMPTS = 20;+const STREAM_ABNORMAL_CLOSE_CODE = 1006;+const STREAM_VNC_FALLBACK_CLOSE_CODE = 4001;+const STREAM_VNC_FALLBACK_CLOSE_REASON = "use-vnc-streaming";++function isTerminalStreamStatus(status: string) {+ return TERMINAL_STREAM_STATUSES.has(status);+}++function shouldReconnectStream({+ closeCode,+ closeReason,+ terminalStatusSeen,+ reconnectAttempts,+}: {+ closeCode: number;+ closeReason: string;+ terminalStatusSeen: boolean;+ reconnectAttempts: number;+}) {+ if (terminalStatusSeen) {+ return false;+ }+ if (+ closeCode === STREAM_VNC_FALLBACK_CLOSE_CODE ||+ closeReason === STREAM_VNC_FALLBACK_CLOSE_REASON+ ) {+ return false;+ }+ if (closeCode !== STREAM_ABNORMAL_CLOSE_CODE) {+ return false;+ }+ return reconnectAttempts < STREAM_MAX_RECONNECT_ATTEMPTS;+}++export {+ STREAM_MAX_RECONNECT_ATTEMPTS,+ STREAM_RECONNECT_DELAY_MS,+ isTerminalStreamStatus,+ shouldReconnectStream,+};diff --git a/skyvern/forge/sdk/copilot/agent.py b/skyvern/forge/sdk/copilot/agent.pyindex 0b145dfac..e5669816e 100644--- a/skyvern/forge/sdk/copilot/agent.py+++ b/skyvern/forge/sdk/copilot/agent.py@@ -83,6 +83,7 @@ from skyvern.forge.sdk.copilot.request_policy import (build_request_policy,redact_raw_secrets_for_prompt,)+from skyvern.forge.sdk.copilot.runtime import _browser_context_is_attachablefrom skyvern.forge.sdk.copilot.streaming_adapter import (emit_turn_start,emit_workflow_draft,@@ -198,6 +199,21 @@ class CopilotRequestPolicyMissingError(Exception):"""Raised when the request-policy guardrail fails before producing a policy."""+def _manager_can_probe_registered_browser_state() -> bool:+ return app.PERSISTENT_SESSIONS_MANAGER.can_probe_registered_browser_state()+++async def _registered_browser_state_is_usable(session_id: str, organization_id: str) -> bool:+ if not _manager_can_probe_registered_browser_state():+ return False++ state = await app.PERSISTENT_SESSIONS_MANAGER.get_browser_state(+ session_id=session_id,+ organization_id=organization_id,+ )+ return bool(state and _browser_context_is_attachable(state.browser_context))++async def _resolve_live_browser_session_id(chat_request: WorkflowCopilotChatRequest,organization_id: str,@@ -230,17 +246,24 @@ async def _resolve_live_browser_session_id()return None- # Trust the DB row over a CDP probe here — get_browser_state opens a- # fresh Playwright connection. ensure_browser_session does the- # attachability probe right before use so stale rows still recover.persistent = await app.PERSISTENT_SESSIONS_MANAGER.get_session(requested, organization_id)- if persistent is None or is_final_status(persistent.status) or not persistent.browser_address:+ has_browser_address = bool(persistent.browser_address) if persistent else False+ has_registered_browser_state = False+ if persistent is not None and not is_final_status(persistent.status) and not has_browser_address:+ has_registered_browser_state = await _registered_browser_state_is_usable(requested, organization_id)++ if (+ persistent is None+ or is_final_status(persistent.status)+ or (not has_browser_address and not has_registered_browser_state)+ ):LOG.warning("Copilot live browser session is not yet usable; falling back to auto-create",organization_id=organization_id,requested_session_id=requested,status=persistent.status if persistent else None,- has_browser_address=bool(persistent.browser_address) if persistent else False,+ has_browser_address=has_browser_address,+ has_registered_browser_state=has_registered_browser_state,)return Nonediff --git a/skyvern/forge/sdk/routes/streaming/cdp_input.py b/skyvern/forge/sdk/routes/streaming/cdp_input.pyindex 772967d6e..7a685c764 100644--- a/skyvern/forge/sdk/routes/streaming/cdp_input.py+++ b/skyvern/forge/sdk/routes/streaming/cdp_input.py@@ -25,6 +25,7 @@ from skyvern.forge.sdk.routes.streaming.registries import (from skyvern.forge.sdk.routes.streaming.screencast import wait_for_browser_statefrom skyvern.forge.sdk.schemas.persistent_browser_sessions import is_final_statusfrom skyvern.forge.sdk.workflow.models.workflow import WorkflowRunStatus+from skyvern.webeye.browser_state import BrowserStateLOG = structlog.get_logger()@@ -37,6 +38,7 @@ _MAX_KEY_LEN = 32_MAX_CODE_LEN = 32_MODIFIER_MASK = 0xF_MAX_VK_CODE = 0xFE+ACTIVE_PAGE_INPUT_REFRESH_INTERVAL = 0.5@dataclasses.dataclass@@ -53,6 +55,63 @@ class CdpInputChannel:del_cdp_input_channel(self.client_id)+class ActivePageCdpInputSession:+ def __init__(+ self,+ browser_state: BrowserState,+ log_id_key: str,+ log_id_value: str,+ refresh_interval: float = ACTIVE_PAGE_INPUT_REFRESH_INTERVAL,+ ) -> None:+ self.browser_state = browser_state+ self.log_id_key = log_id_key+ self.log_id_value = log_id_value+ self.refresh_interval = refresh_interval+ self.cdp_session: CDPSession | None = None+ self.page: object | None = None+ self.next_refresh_at = 0.0+ self.page_resolution_failed = False++ async def get_session(self, *, force_refresh: bool = False) -> CDPSession | None:+ now = time.monotonic()+ if not force_refresh and now < self.next_refresh_at:+ return None if self.page_resolution_failed else self.cdp_session++ page = await self.browser_state.get_working_page()+ if page is None:+ self.page_resolution_failed = True+ self.next_refresh_at = now + self.refresh_interval+ return None++ self.page_resolution_failed = False+ self.next_refresh_at = now + self.refresh_interval+ if self.cdp_session is not None and page is self.page:+ return self.cdp_session++ await self.close()+ session = await page.context.new_cdp_session(page) # type: ignore[attr-defined]+ self.cdp_session = session+ self.page = page+ LOG.info(+ "CDP input rebound to active page",+ **{self.log_id_key: self.log_id_value},+ url=getattr(page, "url", ""),+ )+ return session++ async def close(self) -> None:+ if self.cdp_session is None:+ self.page = None+ return+ session = self.cdp_session+ self.cdp_session = None+ self.page = None+ try:+ await session.detach()+ except Exception:+ pass++def _validated_modifiers(msg: dict) -> int:modifiers = msg.get("modifiers", 0)if not isinstance(modifiers, int):@@ -199,11 +258,12 @@ async def _dispatch_event(async def _run_input_loop(websocket: WebSocket,channel: CdpInputChannel,- cdp_session: CDPSession,+ input_session: ActivePageCdpInputSession,log_id_key: str,log_id_value: str,) -> None:dropped_log_count = 0+ no_active_page_log_count = 0while True:try:raw = await websocket.receive_text()@@ -238,6 +298,24 @@ async def _run_input_loop(dropped_log_count += 1continue+ try:+ cdp_session = await input_session.get_session()+ except Exception:+ LOG.warning(+ "CDP input: failed to resolve active page; closing input channel",+ **{log_id_key: log_id_value},+ kind=kind,+ exc_info=True,+ )+ await websocket.close(code=4411, reason="active_page_resolution_failed")+ break++ if cdp_session is None:+ if no_active_page_log_count < 5:+ LOG.info("CDP input: no active page; event skipped", **{log_id_key: log_id_value}, kind=kind)+ no_active_page_log_count += 1+ continue+try:await _dispatch_event(cdp_session, kind, msg, log_id_key, log_id_value)except Exception:@@ -275,6 +353,7 @@ async def cdp_input_stream()cdp_session: CDPSession | None = None+ input_session: ActivePageCdpInputSession | None = Nonetry:deadline = time.monotonic() + 120while True:@@ -308,13 +387,18 @@ async def cdp_input_stream(await websocket.close(code=4410, reason="no_working_page")return- cdp_session = await page.context.new_cdp_session(page)+ input_session = ActivePageCdpInputSession(browser_state, "workflow_run_id", workflow_run_id)+ cdp_session = await input_session.get_session(force_refresh=True)+ if cdp_session is None:+ LOG.warning("CDP input: no working page", workflow_run_id=workflow_run_id)+ await websocket.close(code=4410, reason="no_working_page")+ returnstream_ref_inc(workflow_run_id)LOG.info("CDP input channel ready", workflow_run_id=workflow_run_id, client_id=client_id)await websocket.send_json({"kind": "ready"})- await _run_input_loop(websocket, channel, cdp_session, "workflow_run_id", workflow_run_id)+ await _run_input_loop(websocket, channel, input_session, "workflow_run_id", workflow_run_id)except ConnectionClosedOK:LOG.info("CDP input: WS closed cleanly", workflow_run_id=workflow_run_id)@@ -327,10 +411,8 @@ async def cdp_input_stream(finally:if cdp_session is not None:await stream_ref_dec(workflow_run_id)- try:- await cdp_session.detach()- except Exception:- pass+ if input_session is not None:+ await input_session.close()await channel.close()LOG.info("CDP input channel closed", workflow_run_id=workflow_run_id, client_id=client_id)@@ -358,7 +440,7 @@ async def cdp_input_browser_session_stream(websocket=websocket,)- cdp_session: CDPSession | None = None+ input_session: ActivePageCdpInputSession | None = Nonetry:session = await app.PERSISTENT_SESSIONS_MANAGER.get_session(session_id=browser_session_id,@@ -385,12 +467,16 @@ async def cdp_input_browser_session_stream(await websocket.close(code=4410, reason="no_working_page")return- cdp_session = await page.context.new_cdp_session(page)+ input_session = ActivePageCdpInputSession(browser_state, "browser_session_id", browser_session_id)+ if await input_session.get_session(force_refresh=True) is None:+ LOG.warning("CDP input: no working page", browser_session_id=browser_session_id)+ await websocket.close(code=4410, reason="no_working_page")+ returnLOG.info("CDP input channel ready", browser_session_id=browser_session_id, client_id=client_id)await websocket.send_json({"kind": "ready"})- await _run_input_loop(websocket, channel, cdp_session, "browser_session_id", browser_session_id)+ await _run_input_loop(websocket, channel, input_session, "browser_session_id", browser_session_id)except ConnectionClosedOK:LOG.info("CDP input: WS closed cleanly", browser_session_id=browser_session_id)@@ -401,10 +487,7 @@ async def cdp_input_browser_session_stream(except Exception:LOG.warning("CDP input: unexpected error", browser_session_id=browser_session_id, exc_info=True)finally:- if cdp_session is not None:- try:- await cdp_session.detach()- except Exception:- pass+ if input_session is not None:+ await input_session.close()await channel.close()LOG.info("CDP input channel closed", browser_session_id=browser_session_id, client_id=client_id)diff --git a/skyvern/forge/sdk/routes/streaming/screencast.py b/skyvern/forge/sdk/routes/streaming/screencast.pyindex b99135b51..9e0fe5dc1 100644--- a/skyvern/forge/sdk/routes/streaming/screencast.py+++ b/skyvern/forge/sdk/routes/streaming/screencast.py@@ -19,6 +19,7 @@ LOG = structlog.get_logger()DEFAULT_WIDTH = 1280DEFAULT_HEIGHT = 720+ACTIVE_PAGE_POLL_INTERVAL = 0.5async def wait_for_browser_state(@@ -66,17 +67,27 @@ async def start_screencast_loop() -> None:id_key = f"{entity_type}_id"cdp_session: CDPSession | None = None+ attached_page: object | None = Noneframe_queue: asyncio.Queue[str] = asyncio.Queue(maxsize=2)viewport_info: dict[str, int] = {"width": DEFAULT_WIDTH, "height": DEFAULT_HEIGHT}- async def _ack_frame(session_id: int) -> None:- if cdp_session is None:- return+ async def _ack_frame(session: CDPSession, session_id: int) -> None:try:- await cdp_session.send("Page.screencastFrameAck", {"sessionId": session_id})+ await session.send("Page.screencastFrameAck", {"sessionId": session_id})except Exception:pass+ def _update_viewport_from_page(page: object) -> None:+ viewport_size = getattr(page, "viewport_size", None)+ if not isinstance(viewport_size, dict):+ return+ width = viewport_size.get("width")+ height = viewport_size.get("height")+ if isinstance(width, (int, float)) and width > 0:+ viewport_info["width"] = int(width)+ if isinstance(height, (int, float)) and height > 0:+ viewport_info["height"] = int(height)+def _update_viewport_from_metadata(metadata: dict) -> None:device_width = metadata.get("deviceWidth")device_height = metadata.get("deviceHeight")@@ -85,16 +96,9 @@ async def start_screencast_loop(if isinstance(device_height, (int, float)) and device_height > 0:viewport_info["height"] = int(device_height)- async def _on_frame(params: dict) -> None:- data = params.get("data", "")- session_id = params.get("sessionId", 0)- metadata = params.get("metadata", {})- if metadata:- _update_viewport_from_metadata(metadata)- asyncio.create_task(_ack_frame(session_id))+ def _queue_frame(data: str) -> None:if not data:return- # Drop oldest frame if queue is full to keep latency lowif frame_queue.full():try:frame_queue.get_nowait()@@ -105,6 +109,94 @@ async def start_screencast_loop(except asyncio.QueueFull:pass+ def _drain_frame_queue() -> None:+ while True:+ try:+ frame_queue.get_nowait()+ except asyncio.QueueEmpty:+ break++ async def _on_frame(session: CDPSession, params: dict) -> None:+ if session is not cdp_session:+ return+ data = params.get("data", "")+ session_id = params.get("sessionId", 0)+ metadata = params.get("metadata", {})+ if metadata:+ _update_viewport_from_metadata(metadata)+ asyncio.create_task(_ack_frame(session, session_id))+ _queue_frame(data)++ async def _stop_current_screencast() -> None:+ nonlocal cdp_session, attached_page+ if cdp_session is None:+ attached_page = None+ return+ session = cdp_session+ cdp_session = None+ attached_page = None+ try:+ await session.send("Page.stopScreencast", {})+ except Exception:+ pass+ try:+ await session.detach()+ except Exception:+ pass++ async def _prime_current_frame(session: CDPSession, page: object) -> None:+ try:+ result = await session.send(+ "Page.captureScreenshot",+ {+ "format": "jpeg",+ "quality": 60,+ "captureBeyondViewport": False,+ },+ )+ data = result.get("data", "") if isinstance(result, dict) else ""+ _update_viewport_from_page(page)+ _queue_frame(data)+ except Exception:+ LOG.debug(+ "Could not prime CDP screencast frame",+ entity_id=entity_id,+ entity_type=entity_type,+ exc_info=True,+ )++ async def _attach_to_page(page: object) -> None:+ nonlocal cdp_session, attached_page+ if page is attached_page and cdp_session is not None:+ return++ await _stop_current_screencast()+ _drain_frame_queue()+ next_session = await page.context.new_cdp_session(page) # type: ignore[attr-defined]+ cdp_session = next_session+ next_session.on("Page.screencastFrame", lambda params: asyncio.create_task(_on_frame(next_session, params)))+ try:+ await next_session.send(+ "Page.startScreencast",+ {+ "format": "jpeg",+ "quality": 60,+ "maxWidth": DEFAULT_WIDTH,+ "maxHeight": DEFAULT_HEIGHT,+ },+ )+ except (asyncio.CancelledError, Exception):+ await _stop_current_screencast()+ raise+ attached_page = page+ await _prime_current_frame(next_session, page)+ LOG.info(+ "CDP screencast started",+ entity_id=entity_id,+ entity_type=entity_type,+ url=getattr(page, "url", ""),+ )+async def _frame_forwarding_loop() -> None:while True:data = await frame_queue.get()@@ -144,29 +236,34 @@ async def start_screencast_loop(exc_info=True,)+ async def _active_page_monitor_loop() -> None:+ while True:+ await asyncio.sleep(ACTIVE_PAGE_POLL_INTERVAL)+ try:+ page = await browser_state.get_working_page()+ if page is not None and page is not attached_page:+ await _attach_to_page(page)+ except Exception:+ LOG.debug(+ "Could not refresh CDP screencast active page",+ entity_id=entity_id,+ entity_type=entity_type,+ exc_info=True,+ )+try:page = await browser_state.get_working_page()if page is None:raise RuntimeError("No working page available for screencast")- cdp_session = await page.context.new_cdp_session(page)- cdp_session.on("Page.screencastFrame", _on_frame)- await cdp_session.send(- "Page.startScreencast",- {- "format": "jpeg",- "quality": 60,- "maxWidth": DEFAULT_WIDTH,- "maxHeight": DEFAULT_HEIGHT,- },- )- LOG.info("CDP screencast started", entity_id=entity_id, entity_type=entity_type)+ await _attach_to_page(page)forward_task = asyncio.create_task(_frame_forwarding_loop())poll_task = asyncio.create_task(_completion_polling_loop())+ page_monitor_task = asyncio.create_task(_active_page_monitor_loop())done, pending = await asyncio.wait(- [forward_task, poll_task],+ [forward_task, poll_task, page_monitor_task],return_when=asyncio.FIRST_COMPLETED,)for task in pending:@@ -176,10 +273,9 @@ async def start_screencast_loop(except (asyncio.CancelledError, Exception):pass- # Re-raise forwarding errors (e.g. WebSocket disconnect)for task in done:exc = task.exception()- if task is forward_task and exc is not None:+ if task is not poll_task and exc is not None:raise excexcept Exception:@@ -190,13 +286,5 @@ async def start_screencast_loop(exc_info=True,)finally:- if cdp_session is not None:- try:- await cdp_session.send("Page.stopScreencast", {})- except Exception:- pass- try:- await cdp_session.detach()- except Exception:- pass+ await _stop_current_screencast()LOG.info("CDP screencast cleaned up", entity_id=entity_id, entity_type=entity_type)diff --git a/skyvern/webeye/default_persistent_sessions_manager.py b/skyvern/webeye/default_persistent_sessions_manager.pyindex f318d584b..8427741c9 100644--- a/skyvern/webeye/default_persistent_sessions_manager.py+++ b/skyvern/webeye/default_persistent_sessions_manager.py@@ -198,6 +198,9 @@ class DefaultPersistentSessionsManager(PersistentSessionsManager):def watch_session_pool(self) -> None:"""No-op in OSS: browsers run in-process, no external pool to monitor."""+ def can_probe_registered_browser_state(self) -> bool:+ return True+async def begin_session(self,*,diff --git a/skyvern/webeye/persistent_sessions_manager.py b/skyvern/webeye/persistent_sessions_manager.pyindex 05da670bd..cd0b7d4e0 100644--- a/skyvern/webeye/persistent_sessions_manager.py+++ b/skyvern/webeye/persistent_sessions_manager.py@@ -20,6 +20,8 @@ class PersistentSessionsManager(Protocol):"""Initialize monitoring of the session pool."""...+ def can_probe_registered_browser_state(self) -> bool: ...+async def begin_session(self,*,diff --git a/tests/unit/test_copilot_live_session_helper.py b/tests/unit/test_copilot_live_session_helper.pyindex c8657bfbe..9d417ded9 100644--- a/tests/unit/test_copilot_live_session_helper.py+++ b/tests/unit/test_copilot_live_session_helper.py@@ -98,7 +98,10 @@ async def test_persistent_row_missing_falls_back(monkeypatch: pytest.MonkeyPatchmonkeypatch.setattr(app,"PERSISTENT_SESSIONS_MANAGER",- SimpleNamespace(get_session=AsyncMock(return_value=None)),+ SimpleNamespace(+ get_session=AsyncMock(return_value=None),+ can_probe_registered_browser_state=lambda: False,+ ),)result = await _resolve_live_browser_session_id(@@ -127,6 +130,7 @@ async def test_status_in_final_state_falls_back(monkeypatch: pytest.MonkeyPatch)get_session=AsyncMock(return_value=SimpleNamespace(status="completed", browser_address="wss://example/cdp"),),+ can_probe_registered_browser_state=lambda: False,),)@@ -156,6 +160,7 @@ async def test_browser_address_unset_falls_back(monkeypatch: pytest.MonkeyPatch)get_session=AsyncMock(return_value=SimpleNamespace(status="running", browser_address=None),),+ can_probe_registered_browser_state=lambda: False,),)@@ -167,6 +172,66 @@ async def test_browser_address_unset_falls_back(monkeypatch: pytest.MonkeyPatch)assert result is None+async def test_default_manager_registered_browser_state_allows_missing_browser_address(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ monkeypatch.setattr(+ app.DATABASE,+ "debug",+ SimpleNamespace(+ get_debug_session_by_browser_session_id=AsyncMock(+ return_value=SimpleNamespace(workflow_permanent_id="wpid-1"),+ ),+ ),+ )+ get_browser_state = AsyncMock(return_value=SimpleNamespace(browser_context=_FakeBrowserContext()))+ manager = SimpleNamespace(+ get_session=AsyncMock(return_value=SimpleNamespace(status="running", browser_address=None)),+ get_browser_state=get_browser_state,+ can_probe_registered_browser_state=lambda: True,+ )+ monkeypatch.setattr(app, "PERSISTENT_SESSIONS_MANAGER", manager)++ result = await _resolve_live_browser_session_id(+ _request(browser_session_id="pbs_booted_local", wpid="wpid-1"),+ organization_id="org-1",+ )++ assert result == "pbs_booted_local"+ get_browser_state.assert_awaited_once_with(session_id="pbs_booted_local", organization_id="org-1")+++async def test_default_manager_unattachable_registered_browser_state_falls_back(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ monkeypatch.setattr(+ app.DATABASE,+ "debug",+ SimpleNamespace(+ get_debug_session_by_browser_session_id=AsyncMock(+ return_value=SimpleNamespace(workflow_permanent_id="wpid-1"),+ ),+ ),+ )+ get_browser_state = AsyncMock(return_value=SimpleNamespace(browser_context=None))+ manager = SimpleNamespace(+ get_session=AsyncMock(return_value=SimpleNamespace(status="running", browser_address=None)),+ get_browser_state=get_browser_state,+ can_probe_registered_browser_state=lambda: True,+ )+ monkeypatch.setattr(app, "PERSISTENT_SESSIONS_MANAGER", manager)++ result = await _resolve_live_browser_session_id(+ _request(browser_session_id="pbs_not_ready", wpid="wpid-1"),+ organization_id="org-1",+ )++ assert result is None+ get_browser_state.assert_awaited_once_with(session_id="pbs_not_ready", organization_id="org-1")++@pytest.mark.asyncioasync def test_owned_and_running_returns_id(monkeypatch: pytest.MonkeyPatch) -> None:monkeypatch.setattr(@@ -181,7 +246,10 @@ async def test_owned_and_running_returns_id(monkeypatch: pytest.MonkeyPatch) ->monkeypatch.setattr(app,"PERSISTENT_SESSIONS_MANAGER",- SimpleNamespace(get_session=AsyncMock(return_value=_running_session())),+ SimpleNamespace(+ get_session=AsyncMock(return_value=_running_session()),+ can_probe_registered_browser_state=lambda: False,+ ),)result = await _resolve_live_browser_session_id(