Skip to content

Automate browser based workflows with AI

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.py
index 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, ThoughtType
from 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.py
index 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_logs
from 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.py
index 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, TaskStatus
from skyvern.forge.sdk.schemas.workflow_copilot import WorkflowCopilotChatMessage as WorkflowCopilotChatMessageSchema
from skyvern.forge.sdk.schemas.workflow_runs import WorkflowRunBlock
from skyvern.forge.sdk.schemas.workflow_schedules import WorkflowSchedule
+from skyvern.forge.sdk.workflow.constants import OUTPUT_PARAMETER_MAX_VALUE_BYTES
from 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.py
index 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_context
else:
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_page
LOG.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.py
index 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 = None
self.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_session
def _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:
+ pass
for 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.py
new file mode 100644
index 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 * 1024
diff --git a/skyvern/forge/sdk/workflow/models/block.py b/skyvern/forge/sdk/workflow/models/block.py
index 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 SettingsManager
from skyvern.forge.sdk.trace import traced
from skyvern.forge.sdk.utils.pdf_parser import extract_pdf_file, render_pdf_pages_as_images, validate_pdf_file
from skyvern.forge.sdk.utils.sanitization import sanitize_postgres_text
+from skyvern.forge.sdk.workflow.constants import OUTPUT_PARAMETER_MAX_VALUE_BYTES
from skyvern.forge.sdk.workflow.context_manager import BlockMetadata, WorkflowRunContext
from skyvern.forge.sdk.workflow.exceptions import (
CustomizedCodeException,
@@ -261,6 +262,58 @@ DEFAULT_MAX_LOOP_ITERATIONS = 500
PERSIST_LOOP_OUTPUT_INTERVAL = 10
DEFAULT_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.criteria
else 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_response
else 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_goal
else prompt_extraction_goal
diff --git a/tests/unit/forge/sdk/routes/streaming/test_exfiltration_channel.py b/tests/unit/forge/sdk/routes/streaming/test_exfiltration_channel.py
new file mode 100644
index 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_data
diff --git a/tests/unit/forge/sdk/routes/streaming/test_message_reify.py b/tests/unit/forge/sdk/routes/streaming/test_message_reify.py
index 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 WebSocketState
from skyvern.config import settings
from skyvern.forge.sdk.routes.streaming.channels import message as message_module
+from skyvern.forge.sdk.routes.streaming.channels.cdp import CdpChannel
from skyvern.forge.sdk.routes.streaming.channels.execution import ExecutionChannel, LocalExecutionChannel
from 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.asyncio
async 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.py
new file mode 100644
index 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([]) == []