Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
fix(workflow): cap oversized output_parameter JSON values to protect Estuary (SKY-9779) (#5974)
pedrohsdb014f2f9a2a32
diff --git a/skyvern/forge/sdk/db/repositories/observer.py b/skyvern/forge/sdk/db/repositories/observer.pyindex a90028d8f..af3a34a93 100644--- a/skyvern/forge/sdk/db/repositories/observer.py+++ b/skyvern/forge/sdk/db/repositories/observer.py@@ -25,6 +25,7 @@ from skyvern.forge.sdk.db.utils import (convert_to_task_v2,convert_to_workflow_run_block,serialize_proxy_location,+ truncate_oversized_jsonb_value,)from skyvern.forge.sdk.schemas.task_v2 import TaskV2, TaskV2Status, Thought, ThoughtTypefrom skyvern.forge.sdk.schemas.workflow_runs import WorkflowRunBlock@@ -414,6 +415,11 @@ class ObserverRepository(BaseRepository):current_value: str | None = None,current_index: int | None = None,) -> WorkflowRunBlock:+ if output is not None:+ output = truncate_oversized_jsonb_value(+ output,+ context={"workflow_run_id": workflow_run_id, "label": label, "block_type": block_type},+ )async with self.Session() as session:new_workflow_run_block = WorkflowRunBlockModel(workflow_run_id=workflow_run_id,@@ -494,6 +500,11 @@ class ObserverRepository(BaseRepository):executed_branch_result: bool | None = None,executed_branch_next_block: str | None = None,) -> WorkflowRunBlock:+ if output is not None:+ output = truncate_oversized_jsonb_value(+ output,+ context={"workflow_run_block_id": workflow_run_block_id},+ )async with self.Session() as session:workflow_run_block = (await session.scalars(diff --git a/skyvern/forge/sdk/db/repositories/workflow_runs.py b/skyvern/forge/sdk/db/repositories/workflow_runs.pyindex 6053d6205..b158980e6 100644--- a/skyvern/forge/sdk/db/repositories/workflow_runs.py+++ b/skyvern/forge/sdk/db/repositories/workflow_runs.py@@ -36,6 +36,7 @@ from skyvern.forge.sdk.db.utils import (convert_to_workflow_run_output_parameter,convert_to_workflow_run_parameter,serialize_proxy_location,+ truncate_oversized_jsonb_value,)from skyvern.forge.sdk.log_artifacts import save_workflow_run_logsfrom skyvern.forge.sdk.schemas.tasks import Task@@ -1056,6 +1057,10 @@ class WorkflowRunsRepository(BaseRepository):output_parameter_id: str,value: dict[str, Any] | list | str | None,) -> WorkflowRunOutputParameter:+ value = truncate_oversized_jsonb_value(+ value,+ context={"workflow_run_id": workflow_run_id, "output_parameter_id": output_parameter_id},+ )async with self.Session() as session:# check if the workflow run output parameter already exists# if it does, update the value@@ -1094,6 +1099,10 @@ class WorkflowRunsRepository(BaseRepository):output_parameter_id: str,value: dict[str, Any] | list | str | None,) -> WorkflowRunOutputParameter:+ value = truncate_oversized_jsonb_value(+ value,+ context={"workflow_run_id": workflow_run_id, "output_parameter_id": output_parameter_id},+ )async with self.Session() as session:workflow_run_output_parameter = (await session.scalars(diff --git a/skyvern/forge/sdk/db/utils.py b/skyvern/forge/sdk/db/utils.pyindex 18986b52a..d659b4188 100644--- a/skyvern/forge/sdk/db/utils.py+++ b/skyvern/forge/sdk/db/utils.py@@ -47,6 +47,7 @@ from skyvern.forge.sdk.schemas.tasks import Task, TaskStatusfrom skyvern.forge.sdk.schemas.workflow_copilot import WorkflowCopilotChatMessage as WorkflowCopilotChatMessageSchemafrom skyvern.forge.sdk.schemas.workflow_runs import WorkflowRunBlockfrom skyvern.forge.sdk.schemas.workflow_schedules import WorkflowSchedule+from skyvern.forge.sdk.workflow.constants import OUTPUT_PARAMETER_MAX_VALUE_BYTESfrom skyvern.forge.sdk.workflow.models.parameter import (AWSSecretParameter,BitwardenLoginCredentialParameter,@@ -223,6 +224,43 @@ def _custom_json_serializer(*args, **kwargs) -> str:return json.dumps(*args, default=pydantic.json.pydantic_encoder, **kwargs)+def truncate_oversized_jsonb_value(value: typing.Any, *, context: dict | None = None) -> typing.Any:+ """Fail-open size guard for jsonb-column writes (SKY-9779)."""+ # Fast-path: None and scalars can't approach the cap; skip the full re-serialization+ # that 99.9% of writes would pay for nothing.+ if value is None or isinstance(value, (bool, int, float)):+ return value+ if isinstance(value, str) and len(value) <= OUTPUT_PARAMETER_MAX_VALUE_BYTES:+ return value++ try:+ serialized = _custom_json_serializer(value)+ except Exception:+ LOG.warning(+ "Failed to measure jsonb value size; passing through unchanged",+ exc_info=True,+ context=context or {},+ )+ return value++ size_bytes = len(serialized.encode("utf-8"))+ if size_bytes <= OUTPUT_PARAMETER_MAX_VALUE_BYTES:+ return value++ LOG.warning(+ "Truncating oversized jsonb value",+ original_size_bytes=size_bytes,+ limit_bytes=OUTPUT_PARAMETER_MAX_VALUE_BYTES,+ **(context or {}),+ )+ return {+ "truncated": True,+ "reason": "exceeded_max_jsonb_value_size",+ "original_size_bytes": size_bytes,+ "limit_bytes": OUTPUT_PARAMETER_MAX_VALUE_BYTES,+ }++def convert_to_task(task_obj: TaskModel, debug_enabled: bool = False, workflow_permanent_id: str | None = None) -> Task:if debug_enabled:LOG.debug("Converting TaskModel to Task", task_id=task_obj.task_id)diff --git a/skyvern/forge/sdk/routes/streaming/channels/cdp.py b/skyvern/forge/sdk/routes/streaming/channels/cdp.pyindex 413c95f19..157814dad 100644--- a/skyvern/forge/sdk/routes/streaming/channels/cdp.py+++ b/skyvern/forge/sdk/routes/streaming/channels/cdp.py@@ -60,6 +60,32 @@ class CdpChannel:return base | {"cdp_url": self.url}+ @staticmethod+ def _select_browser_context(contexts: list[BrowserContext]) -> BrowserContext | None:+ if not contexts:+ return None++ populated_contexts = [context for context in contexts if context.pages]+ if not populated_contexts:+ return contexts[0]++ for context in populated_contexts:+ if any(not page.url.startswith("devtools:") for page in context.pages):+ return context++ return populated_contexts[0]++ @staticmethod+ def _select_page(browser_context: BrowserContext | None) -> Page | None:+ if browser_context is None or not browser_context.pages:+ return None++ for page in browser_context.pages:+ if not page.url.startswith("devtools:"):+ return page++ return browser_context.pages[0]+async def connect(self, cdp_url: str | None = None) -> t.Self:"""Idempotent.@@ -106,16 +132,17 @@ class CdpChannel:await self.apply_download_behavior(self.browser)contexts = self.browser.contexts- if contexts:+ selected_context = self._select_browser_context(contexts)+ if selected_context:LOG.info(f"{self.class_name} using existing browser context", **self.identity)- self.browser_context = contexts[0]+ self.browser_context = selected_contextelse:LOG.warning(f"{self.class_name} No existing browser context found, creating new one", **self.identity)self.browser_context = await self.browser.new_context()- pages = self.browser_context.pages- if pages:- self.page = pages[0]+ selected_page = self._select_page(self.browser_context)+ if selected_page:+ self.page = selected_pageLOG.info(f"{self.class_name} connected to page", **self.identity)else:LOG.warning(f"{self.class_name} No pages found in browser context", **self.identity)diff --git a/skyvern/forge/sdk/routes/streaming/channels/exfiltration.py b/skyvern/forge/sdk/routes/streaming/channels/exfiltration.pyindex 233fdc9f7..fe1b4cfff 100644--- a/skyvern/forge/sdk/routes/streaming/channels/exfiltration.py+++ b/skyvern/forge/sdk/routes/streaming/channels/exfiltration.py@@ -46,37 +46,167 @@ class ExfiltratedEvent:OnExfiltrationEvent = t.Callable[[list[ExfiltratedEvent]], None]+class PageConsoleCapture:+ page: Page+ console_listener: t.Callable[[ConsoleMessage], object]+ cdp_session: CDPSession | None = None++class ExfiltrationChannel(CdpChannel):"""ExfiltrationChannel."""+ CONSOLE_DEDUP_TTL_SECONDS: t.ClassVar[float] = 5.0+def __init__(self, *, on_event: OnExfiltrationEvent, vnc_channel: VncChannel) -> None:self.cdp_session: CDPSession | None = Noneself.on_event = on_event+ self._page_console_captures: dict[int, PageConsoleCapture] = {}+ self._recent_console_event_fingerprints: dict[str, float] = {}super().__init__(vnc_channel=vnc_channel)- def _handle_console_event(self, msg: ConsoleMessage) -> None:- """Parse console messages for exfiltrated event data."""- text = msg.text- if text.startswith("[EXFIL]"):+ def _parse_exfil_payload(self, payload: object) -> dict[str, t.Any] | None:+ if isinstance(payload, str):try:- event_data = json.loads(text[7:]) # Strip '[EXFIL]' prefix-- messages = [- ExfiltratedEvent(- kind="exfiltrated-event",- event_name="user_interaction",- params=event_data,- source=ExfiltratedEventSource.CONSOLE,- timestamp=time.time(),- ),- ]-- self.on_event(messages)- except Exception:- LOG.exception(f"{self.class_name} Failed to parse exfiltrated event", text=text)+ payload = json.loads(payload)+ except json.JSONDecodeError:+ return None++ if isinstance(payload, dict):+ return t.cast(dict[str, t.Any], payload)++ return None++ def _parse_exfil_text(self, text: str) -> dict[str, t.Any] | None:+ if not text.startswith("[EXFIL]"):+ return None++ return self._parse_exfil_payload(text[7:].strip())++ def _parse_exfil_args(self, args: list[object]) -> dict[str, t.Any] | None:+ if len(args) < 2 or args[0] != "[EXFIL]":+ return None++ return self._parse_exfil_payload(args[1])++ def _extract_cdp_remote_object_value(self, arg: object) -> object:+ if not isinstance(arg, dict):+ return arg++ if "value" in arg:+ return arg["value"]++ if arg.get("type") == "string" and "description" in arg:+ return arg["description"]++ preview = arg.get("preview")+ if isinstance(preview, dict):+ properties = preview.get("properties")+ if isinstance(properties, list):+ materialized: dict[str, object] = {}+ for prop in properties:+ if not isinstance(prop, dict):+ continue+ name = prop.get("name")+ if not isinstance(name, str):+ continue+ if "value" in prop:+ materialized[name] = prop["value"]+ elif isinstance(prop.get("valuePreview"), dict) and "value" in prop["valuePreview"]:+ materialized[name] = prop["valuePreview"]["value"]+ if materialized:+ return materialized++ return arg++ def _prune_console_dedup_cache(self, now: float) -> None:+ expired = [+ fingerprint+ for fingerprint, emitted_at in self._recent_console_event_fingerprints.items()+ if now - emitted_at > self.CONSOLE_DEDUP_TTL_SECONDS+ ]+ for fingerprint in expired:+ self._recent_console_event_fingerprints.pop(fingerprint, None)++ def _should_emit_console_event(self, event_data: dict[str, t.Any]) -> bool:+ try:+ fingerprint = json.dumps(event_data, sort_keys=True, separators=(",", ":"))+ except TypeError:+ fingerprint = json.dumps(event_data, sort_keys=True, separators=(",", ":"), default=str)++ now = time.monotonic()+ self._prune_console_dedup_cache(now)+ previous = self._recent_console_event_fingerprints.get(fingerprint)+ if previous is not None and now - previous <= self.CONSOLE_DEDUP_TTL_SECONDS:+ return False++ self._recent_console_event_fingerprints[fingerprint] = now+ return True++ def _emit_console_event(self, event_data: dict[str, t.Any]) -> None:+ if not self._should_emit_console_event(event_data):+ return++ LOG.debug(+ f"{self.class_name} emitting console EXFIL event",+ event_name="user_interaction",+ interaction_type=event_data.get("type"),+ )++ self.on_event(+ [+ ExfiltratedEvent(+ kind="exfiltrated-event",+ event_name="user_interaction",+ params=event_data,+ source=ExfiltratedEventSource.CONSOLE,+ timestamp=time.time(),+ )+ ]+ )++ async def _handle_console_event_async(self, msg: ConsoleMessage) -> None:+ """Parse Playwright console messages for exfiltrated event data."""+ event_data: dict[str, t.Any] | None = None+ try:+ args = []+ for arg in msg.args[:2]:+ args.append(await arg.json_value())+ event_data = self._parse_exfil_args(args)+ except Exception:+ LOG.debug(f"{self.class_name} Failed to inspect console args for EXFIL event", exc_info=True)++ text = msg.text+ if event_data is None:+ event_data = self._parse_exfil_text(text)++ if event_data is None:+ return++ self._emit_console_event(event_data)++ async def _handle_runtime_console_event_async(self, params: dict[str, t.Any]) -> None:+ raw_args = params.get("args")+ if not isinstance(raw_args, list):+ return++ event_data = self._parse_exfil_args([self._extract_cdp_remote_object_value(arg) for arg in raw_args[:2]])+ if event_data is None:+ return++ self._emit_console_event(event_data)++ async def _attach_page_console_capture(self, page: Page) -> CDPSession | None:+ cdp_session = await page.context.new_cdp_session(page)+ await cdp_session.send("Runtime.enable")+ cdp_session.on(+ "Runtime.consoleAPICalled",+ lambda params: asyncio.create_task(self._handle_runtime_console_event_async(params)),+ )+ return cdp_sessiondef _handle_cdp_event(self, event_name: str, params: dict) -> None:LOG.debug(f"{self.class_name} cdp event captured: {event_name}", params=params)@@ -136,13 +266,27 @@ class ExfiltrationChannel(CdpChannel):if page.url.startswith("devtools:"):return self+ page_id = id(page)+ if page_id in self._page_console_captures:+ return self+LOG.info(f"{self.class_name} setting up exfiltration on new page.", url=page.url)- page.on("console", self._handle_console_event)+ def console_listener(msg: ConsoleMessage) -> None:+ asyncio.create_task(self._handle_console_event_async(msg))++ page.on("console", console_listener)await page.add_init_script(self.js("exfiltrate"))await page.evaluate(self.js("exfiltrate"))+ capture = PageConsoleCapture(page=page, console_listener=console_listener)+ self._page_console_captures[page_id] = capture+ try:+ capture.cdp_session = await self._attach_page_console_capture(page)+ except Exception:+ LOG.warning(f"{self.class_name} failed to attach page CDP EXFIL listener", page_url=page.url, exc_info=True)+LOG.info(f"{self.class_name} setup complete on page.", url=page.url)return self@@ -272,24 +416,41 @@ class ExfiltrationChannel(CdpChannel):async def stop(self) -> t.Self:LOG.info(f"{self.class_name} stopping.")- if not self.cdp_session:- return self+ if self.cdp_session:+ try:+ await self.cdp_session.detach()+ except Exception:+ pass+ self.cdp_session = None- try:- await self.cdp_session.detach()- except Exception:- pass+ captures = list(self._page_console_captures.values())+ self._page_console_captures.clear()++ pages = [capture.page for capture in captures]+ if self.browser_context:+ for page in self.browser_context.pages:+ if all(existing is not page for existing in pages):+ pages.append(page)- self.cdp_session = None+ for capture in captures:+ try:+ capture.page.remove_listener("console", capture.console_listener)+ except KeyError:+ pass- pages = self.browser_context.pages if self.browser_context else []+ if capture.cdp_session:+ try:+ await capture.cdp_session.detach()+ except Exception:+ passfor page in pages:try:- page.remove_listener("console", self._handle_console_event)- except KeyError:- pass # listener not found- await self.undecorate(page)+ await self.undecorate(page)+ except Exception:+ LOG.debug(f"{self.class_name} failed to undecorate page during shutdown", url=page.url, exc_info=True)++ self._recent_console_event_fingerprints.clear()LOG.info(f"{self.class_name} stopped.")diff --git a/skyvern/forge/sdk/workflow/constants.py b/skyvern/forge/sdk/workflow/constants.pynew file mode 100644index 000000000..ef6ec51ee--- /dev/null+++ b/skyvern/forge/sdk/workflow/constants.py@@ -0,0 +1,8 @@+"""Workflow constants shared between block runtime and DB write paths.++Zero project-internal imports so block.py and db/utils.py can both consume without+creating a cycle.+"""++# Safety-net cap on serialized JSON size for a single jsonb-column value (SKY-9779).+OUTPUT_PARAMETER_MAX_VALUE_BYTES = 100 * 1024 * 1024diff --git a/skyvern/forge/sdk/workflow/models/block.py b/skyvern/forge/sdk/workflow/models/block.pyindex f62a36db1..c1f1328bd 100644--- a/skyvern/forge/sdk/workflow/models/block.py+++ b/skyvern/forge/sdk/workflow/models/block.py@@ -89,6 +89,7 @@ from skyvern.forge.sdk.settings_manager import SettingsManagerfrom skyvern.forge.sdk.trace import tracedfrom skyvern.forge.sdk.utils.pdf_parser import extract_pdf_file, render_pdf_pages_as_images, validate_pdf_filefrom skyvern.forge.sdk.utils.sanitization import sanitize_postgres_text+from skyvern.forge.sdk.workflow.constants import OUTPUT_PARAMETER_MAX_VALUE_BYTESfrom skyvern.forge.sdk.workflow.context_manager import BlockMetadata, WorkflowRunContextfrom skyvern.forge.sdk.workflow.exceptions import (CustomizedCodeException,@@ -261,6 +262,58 @@ DEFAULT_MAX_LOOP_ITERATIONS = 500PERSIST_LOOP_OUTPUT_INTERVAL = 10DEFAULT_MAX_STEPS_PER_ITERATION = 50+# Per-field cap for DecisionBlock debug payload (rendered_expression, llm_response, llm_prompt).+# Same fields exist as branch_metadata debug surface for script-reviewer / UI display; their+# unbounded form has produced multi-hundred-MB output_parameter rows under recursive Jinja.+DECISION_BLOCK_FIELD_MAX_BYTES = 64 * 1024+++def _maybe_truncate_loop_outputs(+ outputs_with_loop_values: list[list[dict[str, Any]]],+ *,+ workflow_run_id: str,+ output_parameter_id: str | None,+) -> None:+ """Fail-open in-memory cap for loop accumulators; preserves per-entry schema (SKY-9779)."""+ try:+ size_bytes = len(json.dumps(outputs_with_loop_values, default=str).encode("utf-8"))+ except Exception:+ LOG.warning(+ "Failed to measure loop output size; skipping truncation",+ workflow_run_id=workflow_run_id,+ output_parameter_id=output_parameter_id,+ exc_info=True,+ )+ return++ if size_bytes <= OUTPUT_PARAMETER_MAX_VALUE_BYTES:+ return++ summarized_through = len(outputs_with_loop_values) - 1+ summary_entry = [+ {+ "loop_value": None,+ "output_parameter": None,+ "output_value": {+ "truncated": True,+ "reason": "loop_output_size_exceeded",+ "iterations_summarized_through": summarized_through,+ },+ }+ ]+ LOG.warning(+ "Truncating loop output accumulator",+ workflow_run_id=workflow_run_id,+ output_parameter_id=output_parameter_id,+ size_bytes=size_bytes,+ limit_bytes=OUTPUT_PARAMETER_MAX_VALUE_BYTES,+ iterations_summarized_through=summarized_through,+ )+ last = outputs_with_loop_values[-1]+ outputs_with_loop_values.clear()+ outputs_with_loop_values.append(summary_entry)+ outputs_with_loop_values.append(last)+class Block(BaseModel, abc.ABC):"""Base class for workflow nodes (see branching spec [[s-4bnl]] for metadata semantics)."""@@ -2112,6 +2165,11 @@ class ForLoopBlock(Block):cancellation) always persist since they are terminal."""if not self.output_parameter:return+ _maybe_truncate_loop_outputs(+ outputs_with_loop_values,+ workflow_run_id=workflow_run_id,+ output_parameter_id=self.output_parameter.output_parameter_id,+ )try:await app.DATABASE.workflow_runs.create_or_update_workflow_run_output_parameter(workflow_run_id=workflow_run_id,@@ -2722,6 +2780,11 @@ class WhileLoopBlock(Block):"""if not self.output_parameter:return+ _maybe_truncate_loop_outputs(+ outputs_with_loop_values,+ workflow_run_id=workflow_run_id,+ output_parameter_id=self.output_parameter.output_parameter_id,+ )try:await app.DATABASE.workflow_runs.create_or_update_workflow_run_output_parameter(workflow_run_id=workflow_run_id,@@ -7182,6 +7245,34 @@ def _make_empty_params_explicit(return "".join(result_parts), True+def _cap_debug_field(value: Any, *, limit_bytes: int = DECISION_BLOCK_FIELD_MAX_BYTES) -> Any:+ """Cap a string at ``limit_bytes`` UTF-8 bytes (suffix included); non-strings pass through (SKY-9779)."""+ if not isinstance(value, str):+ return value+ encoded = value.encode("utf-8")+ if len(encoded) <= limit_bytes:+ return value+ overflow_bytes = len(encoded) - limit_bytes+ suffix = f"…[truncated {overflow_bytes} bytes]"+ suffix_bytes = len(suffix.encode("utf-8"))+ head_budget = max(0, limit_bytes - suffix_bytes)+ return encoded[:head_budget].decode("utf-8", errors="ignore") + suffix+++def _trim_branch_evaluations(branch_evaluations: list[dict] | None) -> list[dict] | None:+ """Drop ``rendered_expression`` on non-matched branches; cap the matched one (SKY-9779)."""+ if not branch_evaluations:+ return branch_evaluations+ trimmed: list[dict] = []+ for ev in branch_evaluations:+ if ev.get("is_matched"):+ ev = {**ev, "rendered_expression": _cap_debug_field(ev.get("rendered_expression"))}+ else:+ ev = {k: v for k, v in ev.items() if k != "rendered_expression"}+ trimmed.append(ev)+ return trimmed++class BranchCondition(BaseModel):"""Represents a single conditional branch edge within a ConditionalBlock."""@@ -7714,16 +7805,16 @@ class ConditionalBlock(Block):if matched_branch and matched_branch.criteriaelse None,"next_block_label": next_block_label,- # Detailed evaluation info for all branches- "evaluations": branch_evaluations_list if branch_evaluations_list else None,- # Raw LLM response for debugging prompt-based evaluations (masked for secrets)- "llm_response": (+ # Detailed evaluation info for all branches (rendered_expression trimmed/capped — SKY-9779)+ "evaluations": _trim_branch_evaluations(branch_evaluations_list) if branch_evaluations_list else None,+ # Raw LLM response for debugging prompt-based evaluations (masked for secrets, capped)+ "llm_response": _cap_debug_field(workflow_run_context.mask_secrets_in_data(prompt_llm_response)if workflow_run_context and prompt_llm_responseelse prompt_llm_response),- # The exact prompt sent to LLM for debugging (masked for secrets)- "llm_prompt": (+ # The exact prompt sent to LLM for debugging (masked for secrets, capped)+ "llm_prompt": _cap_debug_field(workflow_run_context.mask_secrets_in_data(prompt_extraction_goal)if workflow_run_context and prompt_extraction_goalelse prompt_extraction_goaldiff --git a/tests/unit/forge/sdk/routes/streaming/test_exfiltration_channel.py b/tests/unit/forge/sdk/routes/streaming/test_exfiltration_channel.pynew file mode 100644index 000000000..930ec9e33--- /dev/null+++ b/tests/unit/forge/sdk/routes/streaming/test_exfiltration_channel.py@@ -0,0 +1,155 @@+from __future__ import annotations++import json+from unittest.mock import AsyncMock, MagicMock++import pytest++from skyvern.forge.sdk.routes.streaming.channels.exfiltration import ExfiltratedEventSource, ExfiltrationChannel+++def make_channel(on_event: MagicMock | None = None) -> tuple[ExfiltrationChannel, MagicMock]:+ vnc_channel = MagicMock()+ vnc_channel.identity = {"client_id": "client-1"}+ vnc_channel.x_api_key = "api-key"++ event_callback = on_event or MagicMock()+ return ExfiltrationChannel(on_event=event_callback, vnc_channel=vnc_channel), event_callback+++def make_page(url: str = "https://example.com") -> MagicMock:+ page = MagicMock()+ page.url = url+ page.context = MagicMock()+ page.on = MagicMock()+ page.remove_listener = MagicMock()+ page.add_init_script = AsyncMock()+ page.evaluate = AsyncMock()+ return page+++def make_event_data() -> dict[str, object]:+ return {+ "type": "click",+ "timestamp": 1234,+ "url": "https://example.com",+ "target": {+ "tagName": "BUTTON",+ "id": "submit",+ "skyId": "sky-1",+ "text": ["Submit"],+ },+ "mousePosition": {+ "xp": 0.5,+ "yp": 0.25,+ },+ "activeElement": {+ "tagName": "BUTTON",+ },+ "window": {+ "width": 1280,+ "height": 720,+ "scrollX": 0,+ "scrollY": 0,+ },+ }+++class TestExfiltrationChannel:+ @pytest.mark.asyncio+ async def test_runtime_console_api_called_emits_console_event(self) -> None:+ channel, on_event = make_channel()+ event_data = make_event_data()++ await channel._handle_runtime_console_event_async(+ {+ "args": [+ {"type": "string", "value": "[EXFIL]"},+ {"type": "string", "value": json.dumps(event_data)},+ ]+ }+ )++ on_event.assert_called_once()+ emitted = on_event.call_args.args[0]+ assert len(emitted) == 1+ assert emitted[0].source == ExfiltratedEventSource.CONSOLE+ assert emitted[0].event_name == "user_interaction"+ assert emitted[0].params == event_data++ @pytest.mark.asyncio+ async def test_duplicate_playwright_and_runtime_console_events_emit_once(self) -> None:+ channel, on_event = make_channel()+ event_data = make_event_data()++ marker = MagicMock()+ marker.json_value = AsyncMock(return_value="[EXFIL]")+ payload = MagicMock()+ payload.json_value = AsyncMock(return_value=json.dumps(event_data))++ message = MagicMock()+ message.args = [marker, payload]+ message.text = f"[EXFIL] {json.dumps(event_data)}"++ await channel._handle_console_event_async(message)+ await channel._handle_runtime_console_event_async(+ {+ "args": [+ {"type": "string", "value": "[EXFIL]"},+ {"type": "string", "value": json.dumps(event_data)},+ ]+ }+ )++ on_event.assert_called_once()++ @pytest.mark.asyncio+ async def test_exfiltrate_injects_scripts_and_registers_runtime_listener(self) -> None:+ channel, _ = make_channel()+ page = make_page()+ cdp_session = MagicMock()+ cdp_session.send = AsyncMock()+ cdp_session.on = MagicMock()+ page.context.new_cdp_session = AsyncMock(return_value=cdp_session)++ result = await channel.exfiltrate(page)++ assert result is channel+ page.on.assert_called_once()+ page.add_init_script.assert_awaited_once_with(channel.js("exfiltrate"))+ page.evaluate.assert_awaited_once_with(channel.js("exfiltrate"))+ cdp_session.send.assert_awaited_once_with("Runtime.enable")+ event_names = [call.args[0] for call in cdp_session.on.call_args_list]+ assert event_names == ["Runtime.consoleAPICalled"]++ @pytest.mark.asyncio+ async def test_exfiltrate_keeps_playwright_fallback_when_cdp_setup_fails(self) -> None:+ channel, _ = make_channel()+ page = make_page()+ page.context.new_cdp_session = AsyncMock(side_effect=RuntimeError("boom"))++ result = await channel.exfiltrate(page)++ assert result is channel+ page.on.assert_called_once()+ page.add_init_script.assert_awaited_once_with(channel.js("exfiltrate"))+ page.evaluate.assert_awaited_once_with(channel.js("exfiltrate"))+ assert channel._page_console_captures[id(page)].cdp_session is None++ @pytest.mark.asyncio+ async def test_playwright_console_falls_back_to_text_payload(self) -> None:+ channel, on_event = make_channel()+ event_data = make_event_data()++ broken_arg = MagicMock()+ broken_arg.json_value = AsyncMock(side_effect=RuntimeError("cannot serialize"))++ message = MagicMock()+ message.args = [broken_arg]+ message.text = f"[EXFIL] {json.dumps(event_data)}"++ await channel._handle_console_event_async(message)++ on_event.assert_called_once()+ emitted = on_event.call_args.args[0]+ assert emitted[0].params == event_datadiff --git a/tests/unit/forge/sdk/routes/streaming/test_message_reify.py b/tests/unit/forge/sdk/routes/streaming/test_message_reify.pyindex 885c6bfe8..aa10988fc 100644--- a/tests/unit/forge/sdk/routes/streaming/test_message_reify.py+++ b/tests/unit/forge/sdk/routes/streaming/test_message_reify.py@@ -11,6 +11,7 @@ from starlette.websockets import WebSocketStatefrom skyvern.config import settingsfrom skyvern.forge.sdk.routes.streaming.channels import message as message_module+from skyvern.forge.sdk.routes.streaming.channels.cdp import CdpChannelfrom skyvern.forge.sdk.routes.streaming.channels.execution import ExecutionChannel, LocalExecutionChannelfrom skyvern.forge.sdk.routes.streaming.channels.message import (MessageChannel,@@ -177,6 +178,31 @@ class TestExecutionChannelHelpers:page.go_forward.assert_awaited_once_with(**timeout_kwargs)+class TestCdpChannelSelection:+ def test_select_browser_context_prefers_populated_context(self) -> None:+ empty_context = MagicMock()+ empty_context.pages = []++ populated_page = MagicMock()+ populated_page.url = "https://example.com"+ populated_context = MagicMock()+ populated_context.pages = [populated_page]++ assert CdpChannel._select_browser_context([empty_context, populated_context]) is populated_context++ def test_select_page_prefers_non_devtools_page(self) -> None:+ devtools_page = MagicMock()+ devtools_page.url = "devtools://devtools/bundled/inspector.html"++ regular_page = MagicMock()+ regular_page.url = "https://example.com"++ browser_context = MagicMock()+ browser_context.pages = [devtools_page, regular_page]++ assert CdpChannel._select_page(browser_context) is regular_page++class TestLocalExecutionChannel:@pytest.mark.asyncioasync def test_evaluate_js_calls_page_evaluate_directly(self) -> None:diff --git a/tests/unit/test_output_parameter_size_guards.py b/tests/unit/test_output_parameter_size_guards.pynew file mode 100644index 000000000..8e5e5d6b4--- /dev/null+++ b/tests/unit/test_output_parameter_size_guards.py@@ -0,0 +1,207 @@+"""Tests for SKY-9779: three-layer guard against oversized JSON-column block outputs.++Covers the three helpers added by the fix:+ - ``truncate_oversized_jsonb_value`` (Layer 1: DB-write chokepoint)+ - ``_maybe_truncate_loop_outputs`` (Layer 2: loop accumulator OOM guard)+ - ``_trim_branch_evaluations`` / ``_cap_debug_field`` (Layer 3: DecisionBlock filter)+"""++from typing import Any+from unittest.mock import patch++from skyvern.forge.sdk.db.utils import truncate_oversized_jsonb_value+from skyvern.forge.sdk.workflow.models.block import (+ DECISION_BLOCK_FIELD_MAX_BYTES,+ _cap_debug_field,+ _maybe_truncate_loop_outputs,+ _trim_branch_evaluations,+)++# ---------- Layer 1: truncate_oversized_jsonb_value ----------+++def test_truncate_oversized_jsonb_value_passes_small_value_through() -> None:+ value = {"a": 1, "b": [1, 2, 3]}+ assert truncate_oversized_jsonb_value(value, context={"workflow_run_id": "wr_x"}) is value+++def test_truncate_oversized_jsonb_value_returns_marker_above_cap() -> None:+ # Patch the cap to a small value so the test stays cheap.+ cap = 64 * 1024+ big = {"blob": "x" * (cap + 1024)}+ with patch("skyvern.forge.sdk.db.utils.OUTPUT_PARAMETER_MAX_VALUE_BYTES", cap):+ result = truncate_oversized_jsonb_value(big, context={"workflow_run_id": "wr_x"})+ assert isinstance(result, dict)+ assert result["truncated"] is True+ assert result["reason"] == "exceeded_max_jsonb_value_size"+ assert result["limit_bytes"] == cap+ assert result["original_size_bytes"] > cap+++def test_truncate_oversized_jsonb_value_fails_open_on_serialization_error() -> None:+ """Unserializable values must not raise — workflows are more important than warehouse syncs."""++ class _Unencodable:+ pass++ value: Any = {"u": _Unencodable()}+ with patch("skyvern.forge.sdk.db.utils.LOG") as log:+ result = truncate_oversized_jsonb_value(value, context={"workflow_run_id": "wr_x"})+ assert result is value+ log.warning.assert_called_once()+++def test_truncate_oversized_jsonb_value_fast_path_skips_serialization_for_scalars() -> None:+ """Scalars and None should bypass the serializer entirely (claude-bot #3 nit)."""+ with patch("skyvern.forge.sdk.db.utils._custom_json_serializer") as serializer:+ for v in (None, True, False, 0, 42, 3.14, "small"):+ assert truncate_oversized_jsonb_value(v) is v+ serializer.assert_not_called()+++# ---------- Layer 2: _maybe_truncate_loop_outputs ----------+++def test_maybe_truncate_loop_outputs_no_op_below_cap() -> None:+ outputs: list[list[dict[str, Any]]] = [+ [{"loop_value": i, "output_parameter": None, "output_value": {"x": i}}] for i in range(3)+ ]+ snapshot = [list(entry) for entry in outputs]+ _maybe_truncate_loop_outputs(outputs, workflow_run_id="wr_x", output_parameter_id="op_x")+ assert outputs == snapshot+++def test_maybe_truncate_loop_outputs_collapses_old_iterations_above_cap() -> None:+ # Patch cap to a small value so the fixture is cheap. Real cap is much higher.+ blob = "x" * (300 * 1024) # 300 KiB per iteration+ outputs: list[list[dict[str, Any]]] = [+ [{"loop_value": i, "output_parameter": None, "output_value": {"blob": blob}}] for i in range(5)+ ]+ last = outputs[-1]+ with patch("skyvern.forge.sdk.workflow.models.block.OUTPUT_PARAMETER_MAX_VALUE_BYTES", 512 * 1024):+ _maybe_truncate_loop_outputs(outputs, workflow_run_id="wr_x", output_parameter_id="op_x")+ # Shape preserved: still list[list[dict]] with the canonical per-entry schema.+ assert len(outputs) == 2+ summary, tail = outputs+ assert tail is last+ assert isinstance(summary, list) and len(summary) == 1+ summary_entry = summary[0]+ assert set(summary_entry.keys()) == {"loop_value", "output_parameter", "output_value"}+ truncation = summary_entry["output_value"]+ assert truncation["truncated"] is True+ assert truncation["reason"] == "loop_output_size_exceeded"+ assert truncation["iterations_summarized_through"] == 4+++def test_maybe_truncate_loop_outputs_fails_open_on_serialization_error() -> None:+ """If size measurement raises, we must not blow up the loop — fail-open with a warning."""+ outputs: list[list[dict[str, Any]]] = [[{"loop_value": None, "output_parameter": None, "output_value": {"a": 1}}]]+ with (+ patch("skyvern.forge.sdk.workflow.models.block.json.dumps", side_effect=RuntimeError("boom")),+ patch("skyvern.forge.sdk.workflow.models.block.LOG") as log,+ ):+ _maybe_truncate_loop_outputs(outputs, workflow_run_id="wr_x", output_parameter_id="op_x")+ # outputs untouched, structured warning emitted+ assert len(outputs) == 1+ log.warning.assert_called_once()+++# ---------- Layer 3: _cap_debug_field + _trim_branch_evaluations ----------+++def test_cap_debug_field_truncates_oversized_string_with_suffix() -> None:+ value = "y" * (DECISION_BLOCK_FIELD_MAX_BYTES + 500)+ capped = _cap_debug_field(value)+ assert isinstance(capped, str)+ assert capped.startswith("y" * 100)+ assert "[truncated 500 bytes]" in capped+ # Total length is the cap plus the suffix string — never the original.+ assert len(capped.encode("utf-8")) < len(value.encode("utf-8"))+++def test_cap_debug_field_passes_short_string_through() -> None:+ value = "hello world"+ assert _cap_debug_field(value) is value+++def test_cap_debug_field_passes_non_string_through() -> None:+ """LLM responses often come back as dicts; we don't try to cap them here — Layer 1 catches aggregates."""+ payload = {"reasoning": "x", "result": True}+ assert _cap_debug_field(payload) is payload+++def test_trim_branch_evaluations_drops_rendered_expression_on_non_matched() -> None:+ evaluations = [+ {+ "branch_id": "b1",+ "branch_index": 0,+ "criteria_type": "jinja2_template",+ "original_expression": "{{ x }} == 1",+ "rendered_expression": "1 == 1",+ "result": True,+ "is_matched": True,+ "is_default": False,+ "next_block_label": "next",+ "error": None,+ },+ {+ "branch_id": "b2",+ "branch_index": 1,+ "criteria_type": "jinja2_template",+ "original_expression": "{{ x }} == 2",+ "rendered_expression": "1 == 2",+ "result": False,+ "is_matched": False,+ "is_default": False,+ "next_block_label": "other",+ "error": None,+ },+ ]+ trimmed = _trim_branch_evaluations(evaluations)+ assert trimmed is not None+ matched, unmatched = trimmed+ # Matched keeps rendered_expression (small, under cap).+ assert matched["rendered_expression"] == "1 == 1"+ # Non-matched has it dropped, all else preserved.+ assert "rendered_expression" not in unmatched+ for key in (+ "branch_id",+ "branch_index",+ "criteria_type",+ "original_expression",+ "result",+ "is_matched",+ "is_default",+ "next_block_label",+ "error",+ ):+ assert key in unmatched+++def test_trim_branch_evaluations_caps_matched_branch_rendered_expression() -> None:+ big_rendered = "z" * (DECISION_BLOCK_FIELD_MAX_BYTES + 2048)+ evaluations = [+ {+ "branch_id": "b1",+ "branch_index": 0,+ "criteria_type": "jinja2_template",+ "original_expression": "{{ x }}",+ "rendered_expression": big_rendered,+ "result": True,+ "is_matched": True,+ "is_default": False,+ "next_block_label": "next",+ "error": None,+ },+ ]+ trimmed = _trim_branch_evaluations(evaluations)+ assert trimmed is not None+ matched = trimmed[0]+ rendered = matched["rendered_expression"]+ assert "[truncated 2048 bytes]" in rendered+ assert len(rendered.encode("utf-8")) < len(big_rendered.encode("utf-8"))+++def test_trim_branch_evaluations_handles_empty_or_none() -> None:+ assert _trim_branch_evaluations(None) is None+ assert _trim_branch_evaluations([]) == []