Skip to content

Automate browser based workflows with AI

fix(SKY-12272): normalize leaked code-block recorder proxies to JSON-safe output (#7339)

Aaron Perezbfa98fef7ce3
diff --git a/skyvern/forge/sdk/workflow/models/block.py b/skyvern/forge/sdk/workflow/models/block.py
index 2c941d5a0..add311bf7 100644
--- a/skyvern/forge/sdk/workflow/models/block.py
+++ b/skyvern/forge/sdk/workflow/models/block.py
@@ -147,6 +147,7 @@ from skyvern.forge.sdk.workflow.models._jinja import (
from skyvern.forge.sdk.workflow.models.code_block_recorder import (
CODE_BLOCK_FILENAME,
RecordingPage,
+ json_safe_recorder_output,
user_code_line_from_exception,
)
from skyvern.forge.sdk.workflow.models.code_block_recording import CodeBlockActionRecording
@@ -4785,6 +4786,10 @@ async def wrapper({default_args}):
# Safety net for paths the except arms miss (CancelledError, link_block failure).
await recorder.finalize(success=False)
+ # A leaked recorder proxy (RecordingLocator/Page/Keyboard) is not JSON serializable and
+ # would either crash registration or, via the default= fallback, replace the value with a
+ # useless placeholder — normalize the wrapper family to its selector/marker first.
+ result = json_safe_recorder_output(result)
result = json.loads(
json.dumps(result, default=lambda value: f"Object '{type(value)}' is not JSON serializable")
)
diff --git a/skyvern/forge/sdk/workflow/models/code_block_recorder.py b/skyvern/forge/sdk/workflow/models/code_block_recorder.py
index 1330b871d..8cc1f9c11 100644
--- a/skyvern/forge/sdk/workflow/models/code_block_recorder.py
+++ b/skyvern/forge/sdk/workflow/models/code_block_recorder.py
@@ -458,3 +458,23 @@ class RecordingPage:
)
return recorded
+
+
+def json_safe_recorder_output(value: Any) -> Any:
+ """Recursively replace leaked recorder proxies with a JSON-safe marker before a code block's
+ output is registered. A raw RecordingLocator/RecordingKeyboard/RecordingPage reaching JSON
+ serialization raises TypeError at the output-registration boundary, which drops the whole
+ output payload and starves downstream evidence consumers.
+
+ A leaked proxy is a generated-code defect with no meaningful serializable value, so it collapses
+ to a type marker rather than its selector: a selector is only a lossy display fragment and can
+ embed a resolved credential, which mask_secrets_in_data does not scrub out of a dict key."""
+ if isinstance(value, (RecordingLocator, RecordingKeyboard, RecordingPage)):
+ return f"<{type(value).__name__}>"
+ if isinstance(value, dict):
+ # Normalize keys too: json.dumps rejects a non-primitive key outright (it never consults
+ # default=), so a proxy used as a mapping key would crash serialization all the same.
+ return {json_safe_recorder_output(key): json_safe_recorder_output(item) for key, item in value.items()}
+ if isinstance(value, (list, tuple)):
+ return [json_safe_recorder_output(item) for item in value]
+ return value
diff --git a/tests/unit/workflow/test_code_block_recorder.py b/tests/unit/workflow/test_code_block_recorder.py
index 373ee6fe2..631b6115c 100644
--- a/tests/unit/workflow/test_code_block_recorder.py
+++ b/tests/unit/workflow/test_code_block_recorder.py
@@ -26,7 +26,11 @@ from skyvern.forge.sdk.workflow.models.code_block_recorder import (
_PAGE_ACTION_MAP,
CODE_BLOCK_FILENAME,
CODE_LINE_OFFSET,
+ RecordingKeyboard,
+ RecordingLocator,
RecordingPage,
+ _Recorder,
+ json_safe_recorder_output,
user_code_line_from_exception,
)
from skyvern.forge.sdk.workflow.models.parameter import OutputParameter, ParameterType
@@ -858,3 +862,73 @@ async def test_persisted_actions_never_contain_secret_values(monkeypatch: pytest
assert actions
dumped = json.dumps([a.model_dump(mode="json") for a in actions])
assert secret not in dumped
+
+
+def test_json_safe_recorder_output_normalizes_leaked_locator_wrappers() -> None:
+ """SKY-12272: a leaked recorder proxy in a code block's output must collapse to a JSON-safe
+ marker, never a raw proxy that raises TypeError at the registration boundary."""
+ recorder = _Recorder(None)
+ locator = RecordingLocator(FakeLocator(), recorder, "#invoice-link")
+ keyboard = RecordingKeyboard(SimpleNamespace(), recorder)
+
+ result = {
+ "link": locator,
+ "name": "Invoice_2026.pdf",
+ "rows": [locator, {"nested": locator}],
+ "kb": keyboard,
+ }
+
+ safe = json_safe_recorder_output(result)
+
+ # The whole point: serializes with NO default= fallback. A raw wrapper raises TypeError here.
+ json.dumps(safe)
+ assert safe["name"] == "Invoice_2026.pdf" # sibling field never starved
+ assert safe["link"] == "<RecordingLocator>" # leaked locator -> type marker, not its selector
+ assert safe["rows"][0] == "<RecordingLocator>" # nested inside a list
+ assert safe["rows"][1]["nested"] == "<RecordingLocator>" # nested inside a dict
+ assert safe["kb"] == "<RecordingKeyboard>" # non-locator proxy -> its own marker
+
+
+def test_json_safe_recorder_output_normalizes_leaked_locator_used_as_key() -> None:
+ """json.dumps rejects a non-primitive mapping key outright (default= is never consulted for
+ keys), so a leaked proxy key must be normalized too, not just values."""
+ locator = RecordingLocator(FakeLocator(), _Recorder(None), "#doc")
+ safe = json_safe_recorder_output({locator: "delivered"})
+ json.dumps(safe) # a raw locator key raises TypeError: keys must be str/int/float/bool/None
+ assert safe == {"<RecordingLocator>": "delivered"}
+
+
+def test_json_safe_recorder_output_never_leaks_a_secret_bearing_selector() -> None:
+ """A resolved credential can end up in a locator selector; mask_secrets_in_data scrubs dict
+ values, not keys, so the marker must not carry the selector at all — as a value or a key."""
+ secret = "s3cr3t-token"
+ recorder = _Recorder(None)
+ as_value = RecordingLocator(FakeLocator(), recorder, f"text={secret}")
+ as_key = RecordingLocator(FakeLocator(), recorder, f"#{secret}")
+
+ safe = json_safe_recorder_output({"field": as_value, as_key: "delivered"})
+
+ assert secret not in json.dumps(safe)
+
+
+def test_json_safe_recorder_output_passes_through_plain_data() -> None:
+ payload = {"a": 1, "b": ["x", {"c": True, "d": None}], "e": 3.5}
+ assert json_safe_recorder_output(payload) == payload
+
+
+async def test_code_block_output_registers_leaked_locator_as_selector(monkeypatch: pytest.MonkeyPatch) -> None:
+ """SKY-12272 end-to-end: a code block that leaves a locator in a local variable registers a
+ JSON-safe output (selector string), and sibling fields survive rather than dropping the payload."""
+ page = FakePage()
+ context = FakeWorkflowRunContext()
+ _patch_execute_environment(monkeypatch, page, context)
+
+ block = _make_code_block("link = page.locator('#invoice-link')\nname = 'Invoice_2026.pdf'", goal="go")
+ result = await block.execute(workflow_run_id="wr_test", workflow_run_block_id="wrb_test", organization_id="o_test")
+
+ assert result.success is True
+ assert result.output_parameter_value is not None
+ json.dumps(result.output_parameter_value) # registration payload is JSON-safe
+ assert result.output_parameter_value["name"] == "Invoice_2026.pdf" # sibling preserved
+ assert result.output_parameter_value["link"] == "<RecordingLocator>" # locator normalized, not a raw proxy