Skip to content

Automate browser based workflows with AI

Drop never-deployed CDP route env overrides and share one rollout gate (#8017)

Aaron Perez84632e8f303c
diff --git a/skyvern/cli/doctor.py b/skyvern/cli/doctor.py
index 372b50123..30e1d1c7b 100644
--- a/skyvern/cli/doctor.py
+++ b/skyvern/cli/doctor.py
@@ -57,7 +57,6 @@ FRONTEND_BUNDLE_PLACEHOLDERS = {
"__VITE_WSS_BASE_URL_PLACEHOLDER__",
"__VITE_ARTIFACT_API_BASE_URL_PLACEHOLDER__",
"__SKYVERN_API_KEY_PLACEHOLDER__",
- "__VITE_BROWSER_STREAMING_MODE_PLACEHOLDER__",
}
@@ -886,7 +885,6 @@ const placeholders = [
"__VITE_WSS_BASE_URL_PLACEHOLDER__",
"__VITE_ARTIFACT_API_BASE_URL_PLACEHOLDER__",
"__SKYVERN_API_KEY_PLACEHOLDER__",
- "__VITE_BROWSER_STREAMING_MODE_PLACEHOLDER__",
];
const values = {};
diff --git a/skyvern/exceptions.py b/skyvern/exceptions.py
index 6bbc0a5ff..0a15af25f 100644
--- a/skyvern/exceptions.py
+++ b/skyvern/exceptions.py
@@ -237,6 +237,16 @@ class ConditionalBranchEvaluationError(SkyvernException):
"""A conditional block could not resolve which branch to take."""
+class BranchEvaluationContextTooLargeError(ConditionalBranchEvaluationError):
+ """Branch evaluation cannot proceed without silently dropping required context."""
+
+ def __init__(self) -> None:
+ super().__init__(
+ "Workflow branch evaluation context is too large to process safely. "
+ "Reduce the workflow input or prior block output size, then retry."
+ )
+
+
class MalformedBranchEvaluationError(ConditionalBranchEvaluationError):
"""The LLM's branch-evaluation output could not be safely aligned to the branches.
diff --git a/skyvern/forge/agent_functions.py b/skyvern/forge/agent_functions.py
index 542977e89..519e9d226 100644
--- a/skyvern/forge/agent_functions.py
+++ b/skyvern/forge/agent_functions.py
@@ -51,6 +51,7 @@ from skyvern.forge.sdk.schemas.credentials import (
NonEmptyPasswordCredential,
SecretCredential,
)
+from skyvern.forge.sdk.schemas.files import FileInfo
from skyvern.forge.sdk.schemas.organizations import Organization
from skyvern.forge.sdk.schemas.tasks import Task, TaskStatus
from skyvern.forge.sdk.services import (
@@ -908,6 +909,16 @@ class AgentFunction:
"""
return True
+ async def select_browser_session_recordings(
+ self,
+ *,
+ organization_id: str,
+ browser_session_id: str,
+ recordings: list[FileInfo],
+ browser_vendor: str | None = None,
+ ) -> list[FileInfo]:
+ return recordings
+
def get_flex_llm_key(self, llm_key: str | None) -> str | None:
"""Return a flex-tier router key for the given LLM key, or None if no flex twin exists.
diff --git a/skyvern/forge/sdk/artifact/storage/azure.py b/skyvern/forge/sdk/artifact/storage/azure.py
index fc2c4e464..3d2a7cd1c 100644
--- a/skyvern/forge/sdk/artifact/storage/azure.py
+++ b/skyvern/forge/sdk/artifact/storage/azure.py
@@ -770,6 +770,7 @@ class AzureStorage(BaseStorage):
local_file_path: str,
remote_path: str,
date: str | None = None,
+ recording_finalized_at: datetime | None = None,
) -> str:
"""Sync a file from local browser session to Azure."""
uri = self._build_browser_session_uri(organization_id, browser_session_id, artifact_type, remote_path, date)
@@ -779,7 +780,7 @@ class AzureStorage(BaseStorage):
if artifact_type == "videos":
# Anchor per-run clip offsets to browser close, captured before the
# potentially slow prepare+upload below so upload time does not shift clips.
- recording_finalized_at = datetime.now(timezone.utc)
+ recording_finalized_at = recording_finalized_at or datetime.now(timezone.utc)
async with prepare_recording_for_upload(local_file_path) as prepared_upload:
upload_file_path = prepared_upload.path
upload_remote_path = replace_file_extension(remote_path, prepared_upload.file_extension)
diff --git a/skyvern/forge/sdk/artifact/storage/base.py b/skyvern/forge/sdk/artifact/storage/base.py
index 52babd0d3..e8edcc75f 100644
--- a/skyvern/forge/sdk/artifact/storage/base.py
+++ b/skyvern/forge/sdk/artifact/storage/base.py
@@ -1,5 +1,6 @@
from abc import ABC, abstractmethod
from collections.abc import Awaitable, Callable
+from datetime import datetime
from typing import BinaryIO, cast
from skyvern.forge import app
@@ -304,6 +305,7 @@ class BaseStorage(ABC):
local_file_path: str,
remote_path: str,
date: str | None = None,
+ recording_finalized_at: datetime | None = None,
) -> str:
pass
diff --git a/skyvern/forge/sdk/artifact/storage/gcs.py b/skyvern/forge/sdk/artifact/storage/gcs.py
index 90c5223a9..95c59ec76 100644
--- a/skyvern/forge/sdk/artifact/storage/gcs.py
+++ b/skyvern/forge/sdk/artifact/storage/gcs.py
@@ -788,6 +788,7 @@ class GcsStorage(BaseStorage):
local_file_path: str,
remote_path: str,
date: str | None = None,
+ recording_finalized_at: datetime | None = None,
) -> str:
"""Sync a file from local browser session to GCS."""
uri = self._build_browser_session_uri(organization_id, browser_session_id, artifact_type, remote_path, date)
@@ -797,7 +798,7 @@ class GcsStorage(BaseStorage):
if artifact_type == "videos":
# Anchor per-run clip offsets to browser close, captured before the
# potentially slow prepare+upload below so upload time does not shift clips.
- recording_finalized_at = datetime.now(timezone.utc)
+ recording_finalized_at = recording_finalized_at or datetime.now(timezone.utc)
async with prepare_recording_for_upload(local_file_path) as prepared_upload:
upload_file_path = prepared_upload.path
upload_remote_path = replace_file_extension(remote_path, prepared_upload.file_extension)
diff --git a/skyvern/forge/sdk/artifact/storage/local.py b/skyvern/forge/sdk/artifact/storage/local.py
index 06c4f86e4..5214f2f82 100644
--- a/skyvern/forge/sdk/artifact/storage/local.py
+++ b/skyvern/forge/sdk/artifact/storage/local.py
@@ -538,6 +538,7 @@ class LocalStorage(BaseStorage):
local_file_path: str,
remote_path: str,
date: str | None = None,
+ recording_finalized_at: datetime | None = None,
) -> str:
"""Sync a file from local browser session to local storage."""
target_path = self._build_browser_session_path(
diff --git a/skyvern/forge/sdk/artifact/storage/s3.py b/skyvern/forge/sdk/artifact/storage/s3.py
index 873656b85..1b33cde9e 100644
--- a/skyvern/forge/sdk/artifact/storage/s3.py
+++ b/skyvern/forge/sdk/artifact/storage/s3.py
@@ -990,6 +990,7 @@ class S3Storage(BaseStorage):
local_file_path: str,
remote_path: str,
date: str | None = None,
+ recording_finalized_at: datetime | None = None,
) -> str:
"""Sync a file from local browser session to S3."""
uri = self._build_browser_session_uri(organization_id, browser_session_id, artifact_type, remote_path, date)
@@ -998,7 +999,7 @@ class S3Storage(BaseStorage):
if artifact_type == "videos":
# Anchor per-run clip offsets to browser close, captured before the (potentially
# slow) compress+upload below so a long upload doesn't shift every clip window.
- recording_finalized_at = datetime.now(timezone.utc)
+ recording_finalized_at = recording_finalized_at or datetime.now(timezone.utc)
# Compress finalized Playwright recordings before upload. The raw
# local file remains the source of truth if ffmpeg fails; the S3
# object and artifact metadata reflect the prepared upload file.
@@ -1008,7 +1009,9 @@ class S3Storage(BaseStorage):
uri = self._build_browser_session_uri(
organization_id, browser_session_id, artifact_type, upload_remote_path, date
)
- await self.async_client.upload_file_from_path(uri, upload_file_path, storage_class=sc)
+ await self.async_client.upload_file_from_path(
+ uri, upload_file_path, storage_class=sc, raise_exception=True
+ )
# Register the uploaded recording for signed artifact serving.
checksum = calculate_sha256_for_file(upload_file_path)
file_size = _safe_get_file_size(upload_file_path)
diff --git a/skyvern/forge/sdk/workflow/models/block.py b/skyvern/forge/sdk/workflow/models/block.py
index 835dece29..bc7b433b1 100644
--- a/skyvern/forge/sdk/workflow/models/block.py
+++ b/skyvern/forge/sdk/workflow/models/block.py
@@ -59,6 +59,7 @@ from skyvern.constants import (
)
from skyvern.exceptions import (
AzureConfigurationError,
+ BranchEvaluationContextTooLargeError,
CodeBlockRunnerSelectionError,
ConditionalBranchEvaluationError,
ContextParameterValueNotFound,
@@ -202,6 +203,7 @@ from skyvern.schemas.workflows import (
from skyvern.services import otp_service
from skyvern.services.error_detection_service import detect_user_defined_errors_for_task
from skyvern.services.self_heal_cap import check_and_increment_self_heal_cap
+from skyvern.utils.prompt_engine import PROMPT_HARD_CEILING_TOKENS
from skyvern.utils.strings import generate_random_string
from skyvern.utils.templating import get_missing_variables
from skyvern.utils.token_counter import count_tokens
@@ -11496,6 +11498,32 @@ def _parse_single_evaluation(
# recovers most of them while still failing loudly when the model is persistently wrong.
MAX_PROMPT_BRANCH_EVAL_ATTEMPTS = 2
+# Reserve 30k downstream tokens, about 4.7x the measured 6.4k non-goal overhead; this is not a
+# large-page bound, so the generic guard remains. Fail closed because truncation could silently change branch selection.
+BRANCH_EVALUATION_DOWNSTREAM_TOKEN_RESERVE = 30_000
+BRANCH_EVALUATION_GOAL_MAX_TOKENS = PROMPT_HARD_CEILING_TOKENS - BRANCH_EVALUATION_DOWNSTREAM_TOKEN_RESERVE
+BRANCH_CONTEXT_CIRCUIT_BREAKER_EVENT = "conditional_branch_context_circuit_breaker_tripped"
+BRANCH_CONTEXT_CONTRIBUTOR_LIMIT = 5
+
+
+def _largest_branch_context_contributors(context_snapshot: dict[str, Any]) -> list[dict[str, int | str]]:
+ """Return privacy-safe sizes for the largest snapshot values, never their keys or contents."""
+ largest_values: list[tuple[int, str, str]] = []
+ for key, value in context_snapshot.items():
+ serialized_value = json.dumps(value, default=str)
+ largest_values.append((len(serialized_value.encode("utf-8")), key, serialized_value))
+ largest_values.sort(key=lambda item: item[0], reverse=True)
+ del largest_values[BRANCH_CONTEXT_CONTRIBUTOR_LIMIT:]
+
+ return [
+ {
+ "key_fingerprint": diagnostic_fingerprint(key),
+ "serialized_bytes": serialized_bytes,
+ "token_count": count_tokens(serialized_value),
+ }
+ for serialized_bytes, key, serialized_value in largest_values
+ ]
+
def _build_branch_evaluation_schema(num_branches: int) -> dict[str, Any]:
"""Strict JSON schema for the batched branch-evaluation LLM call.
@@ -11847,6 +11875,7 @@ async def _evaluate_prompt_branch_conditions_batch(
rendered_expressions.append(rendered_expression)
+ context_snapshot: dict[str, Any] = {}
if has_any_pure_natlang:
context_snapshot = evaluation_context.build_llm_safe_context_snapshot()
context_json = json.dumps(context_snapshot, default=str)
@@ -11859,6 +11888,27 @@ async def _evaluate_prompt_branch_conditions_batch(
context_json=context_json,
)
+ goal_token_count = count_tokens(extraction_goal)
+ if goal_token_count > BRANCH_EVALUATION_GOAL_MAX_TOKENS:
+ context_token_count = count_tokens(context_json) if context_json is not None else 0
+ context_serialized_bytes = len(context_json.encode("utf-8")) if context_json is not None else 0
+ LOG.warning(
+ BRANCH_CONTEXT_CIRCUIT_BREAKER_EVENT,
+ workflow_run_id=workflow_run_id,
+ workflow_run_block_id=workflow_run_block_id,
+ workflow_id=workflow_id,
+ organization_id=organization_id,
+ block_label=log_label,
+ goal_token_count=goal_token_count,
+ max_goal_tokens=BRANCH_EVALUATION_GOAL_MAX_TOKENS,
+ reserved_tokens=BRANCH_EVALUATION_DOWNSTREAM_TOKEN_RESERVE,
+ context_token_count=context_token_count,
+ context_serialized_bytes=context_serialized_bytes,
+ context_key_count=len(context_snapshot),
+ top_context_contributors=_largest_branch_context_contributors(context_snapshot),
+ )
+ raise BranchEvaluationContextTooLargeError
+
data_schema = _build_branch_evaluation_schema(len(branches))
desc_suffix = extraction_description_suffix or f"{len(branches)} conditions"
@@ -12108,6 +12158,8 @@ class ConditionalBlock(Block):
branch.id: rendered
for branch, rendered in zip(natural_language_branches, prompt_rendered_expressions, strict=False)
}
+ except BranchEvaluationContextTooLargeError as exc:
+ failure_reason = get_user_facing_exception_message(exc)
except Exception as exc:
failure_reason = f"Failed to evaluate natural language branches: {str(exc)}"
LOG.error(
diff --git a/skyvern/forge/sdk/workflow/service.py b/skyvern/forge/sdk/workflow/service.py
index e1bc75413..e9e77bf60 100644
--- a/skyvern/forge/sdk/workflow/service.py
+++ b/skyvern/forge/sdk/workflow/service.py
@@ -11,7 +11,7 @@ import textwrap
import time
import uuid
from collections import deque
-from collections.abc import Sequence
+from collections.abc import Awaitable, Sequence
from dataclasses import dataclass, field
from datetime import UTC, datetime, timedelta
from hashlib import sha256
@@ -243,6 +243,9 @@ POST_RUN_TIMEOUT_EXHAUSTED_THRESHOLD_SECONDS = 0.001
# Bound pre-finalization write-back so a stuck profile upload cannot leave the run in a non-terminal state.
BROWSER_SESSION_WRITE_BACK_TIMEOUT = SAVE_DOWNLOADED_FILES_TIMEOUT
+# Limit burst concurrency for status-path fetches that are typically hit by client polling.
+WORKFLOW_STATUS_RESPONSE_MAX_IN_FLIGHT = 3
+
# Failure reason stamped when execute_workflow's body is interrupted before it captures a terminal
# intent (pre_finally_status stays None)
WORKFLOW_RUN_INTERRUPTED_FAILURE_REASON = (
@@ -732,6 +735,26 @@ class WorkflowService:
self._background_tasks.add(task)
task.add_done_callback(self._background_tasks.discard)
+ async def _gather_with_max_in_flight(
+ self,
+ operations: Sequence[Awaitable[Any]],
+ max_in_flight: int = WORKFLOW_STATUS_RESPONSE_MAX_IN_FLIGHT,
+ ) -> tuple[Any, ...]:
+ """Run async operations with bounded concurrency.
+
+ Status endpoints are often called by polling clients; this prevents a
+ single request from exhausting database sessions through large immediate
+ parallel bursts while preserving gather ordering and error propagation.
+ """
+
+ semaphore = asyncio.Semaphore(max(max_in_flight, 1))
+
+ async def _run(operation: Awaitable[Any]) -> Any:
+ async with semaphore:
+ return await operation
+
+ return tuple(await asyncio.gather(*(_run(operation) for operation in operations)))
+
@staticmethod
async def _apply_initial_run_metadata_tags(
*,
@@ -8567,22 +8590,24 @@ class WorkflowService:
workflow_run_tasks,
workflow_parameter_tuples,
block_errors,
- ) = await asyncio.gather(
- app.DATABASE.workflows.get_workflow_for_workflow_run(
- workflow_run_id,
- organization_id=organization_id,
- filter_deleted=not allow_deleted,
- ),
- self.get_workflow_run(workflow_run_id=workflow_run_id, organization_id=organization_id),
- app.DATABASE.observer.get_task_v2_by_workflow_run_id(
- workflow_run_id=workflow_run_id,
- organization_id=organization_id,
- ),
- app.DATABASE.tasks.get_tasks_by_workflow_run_id(workflow_run_id=workflow_run_id),
- app.DATABASE.workflow_runs.get_workflow_run_parameters(workflow_run_id=workflow_run_id),
- app.DATABASE.workflow_runs.get_workflow_run_block_errors(
- workflow_run_id=workflow_run_id, organization_id=organization_id
- ),
+ ) = await self._gather_with_max_in_flight(
+ (
+ app.DATABASE.workflows.get_workflow_for_workflow_run(
+ workflow_run_id,
+ organization_id=organization_id,
+ filter_deleted=not allow_deleted,
+ ),
+ self.get_workflow_run(workflow_run_id=workflow_run_id, organization_id=organization_id),
+ app.DATABASE.observer.get_task_v2_by_workflow_run_id(
+ workflow_run_id=workflow_run_id,
+ organization_id=organization_id,
+ ),
+ app.DATABASE.tasks.get_tasks_by_workflow_run_id(workflow_run_id=workflow_run_id),
+ app.DATABASE.workflow_runs.get_workflow_run_parameters(workflow_run_id=workflow_run_id),
+ app.DATABASE.workflow_runs.get_workflow_run_block_errors(
+ workflow_run_id=workflow_run_id, organization_id=organization_id
+ ),
+ )
)
if workflow is None:
@@ -8596,21 +8621,23 @@ class WorkflowService:
(recording_urls, recording_archived),
(downloaded_files, downloaded_file_urls),
retried_by_workflow_run_id,
- ) = await asyncio.gather(
- self.get_recent_workflow_screenshot_urls(
- workflow_run_id=workflow_run_id,
- organization_id=organization_id,
- workflow_run_tasks=workflow_run_tasks,
- ),
- self.get_output_parameter_workflow_run_output_parameter_tuples(
- workflow_id=workflow_run.workflow_id, workflow_run_id=workflow_run_id
- ),
- self._fetch_recording_urls(workflow_run, task_v2, organization_id),
- self._fetch_downloaded_files(workflow_run, task_v2),
- app.DATABASE.workflow_runs.get_workflow_run_retried_by(
- workflow_run_id=workflow_run_id,
- organization_id=workflow_run.organization_id,
- ),
+ ) = await self._gather_with_max_in_flight(
+ (
+ self.get_recent_workflow_screenshot_urls(
+ workflow_run_id=workflow_run_id,
+ organization_id=organization_id,
+ workflow_run_tasks=workflow_run_tasks,
+ ),
+ self.get_output_parameter_workflow_run_output_parameter_tuples(
+ workflow_id=workflow_run.workflow_id, workflow_run_id=workflow_run_id
+ ),
+ self._fetch_recording_urls(workflow_run, task_v2, organization_id),
+ self._fetch_downloaded_files(workflow_run, task_v2),
+ app.DATABASE.workflow_runs.get_workflow_run_retried_by(
+ workflow_run_id=workflow_run_id,
+ organization_id=workflow_run.organization_id,
+ ),
+ )
)
screenshot_urls: list[str] | None = screenshot_urls_raw or None
# Preserve legacy singular contract: last element is the newest.
diff --git a/skyvern/webeye/schemas.py b/skyvern/webeye/schemas.py
index 3a5ff420e..b88cb6094 100644
--- a/skyvern/webeye/schemas.py
+++ b/skyvern/webeye/schemas.py
@@ -138,10 +138,18 @@ class BrowserSessionResponse(BaseModel):
organization_id=browser_session.organization_id,
browser_session_id=browser_session.persistent_browser_session_id,
)
+ if recordings:
+ recordings = await app.AGENT_FUNCTION.select_browser_session_recordings(
+ organization_id=browser_session.organization_id,
+ browser_session_id=browser_session.persistent_browser_session_id,
+ recordings=recordings,
+ browser_vendor=browser_session.browser_vendor,
+ )
except asyncio.TimeoutError:
LOG.warning(
"Timeout getting recordings", browser_session_id=browser_session.persistent_browser_session_id
)
+ recordings = []
# Sort downloaded files by modified_at in descending order (newest first)
# Treat None as "oldest".
diff --git a/skyvern/webeye/video_utils.py b/skyvern/webeye/video_utils.py
index 5cd0cfc5e..717c9336b 100644
--- a/skyvern/webeye/video_utils.py
+++ b/skyvern/webeye/video_utils.py
@@ -194,8 +194,8 @@ async def prepare_recording_for_upload(src_path: str) -> AsyncIterator[PreparedR
if not os.path.exists(src_path):
raise FileNotFoundError(src_path)
- prepared = await _prepare_recording_upload(src_path)
source_extension = os.path.splitext(src_path)[1].lstrip(".").lower() or "webm"
+ prepared = None if source_extension == "mp4" else await _prepare_recording_upload(src_path)
upload = prepared or PreparedRecordingUpload(path=src_path, file_extension=source_extension)
try:
yield upload
@@ -364,12 +364,10 @@ def plan_run_segment(
if video_duration_seconds <= 0:
return None
start = _as_utc(run_started_at)
+ anchor = _as_utc(video_start)
end = (
- _as_utc(run_finished_at)
- if run_finished_at is not None
- else video_start + timedelta(seconds=video_duration_seconds)
+ _as_utc(run_finished_at) if run_finished_at is not None else anchor + timedelta(seconds=video_duration_seconds)
)
- anchor = _as_utc(video_start)
start_offset = min(max((start - anchor).total_seconds(), 0.0), video_duration_seconds)
end_offset = min(max((end - anchor).total_seconds(), 0.0), video_duration_seconds)
if end_offset - start_offset < min_segment_seconds:
diff --git a/tests/unit/test_browser_session_download_artifacts.py b/tests/unit/test_browser_session_download_artifacts.py
index e7ef3f28b..809fc1e19 100644
--- a/tests/unit/test_browser_session_download_artifacts.py
+++ b/tests/unit/test_browser_session_download_artifacts.py
@@ -632,11 +632,14 @@ async def test_browser_session_response_preserves_empty_downloads_on_timeout_by_
storage.get_shared_downloaded_files_in_browser_session = AsyncMock(side_effect=TimeoutError)
storage.get_shared_recordings_in_browser_session = AsyncMock(return_value=[])
+ selector = AsyncMock(return_value=[])
with patch("skyvern.webeye.schemas.app") as app_mock:
+ app_mock.AGENT_FUNCTION.select_browser_session_recordings = selector
app_mock.AGENT_FUNCTION.resolve_browser_session_connect_url = AsyncMock(return_value=None)
response = await BrowserSessionResponse.from_browser_session(browser_session, storage)
assert response.downloaded_files == []
+ selector.assert_not_awaited()
def test_get_browser_session_openapi_documents_download_unavailable_response():
diff --git a/tests/unit/test_browser_session_recording_artifacts.py b/tests/unit/test_browser_session_recording_artifacts.py
index 06bf5466d..48e812343 100644
--- a/tests/unit/test_browser_session_recording_artifacts.py
+++ b/tests/unit/test_browser_session_recording_artifacts.py
@@ -13,6 +13,7 @@ Mirrors the SKY-8861 download artifact pipeline in
from __future__ import annotations
from contextlib import asynccontextmanager
+from datetime import UTC, datetime
from unittest.mock import AsyncMock, MagicMock, patch
from urllib.parse import urlparse
@@ -248,6 +249,8 @@ async def test_sync_browser_session_file_registers_recording_artifact(tmp_path):
mock_create = AsyncMock(return_value="a_new")
mock_artifact_manager = MagicMock()
mock_artifact_manager.create_browser_session_recording_artifact = mock_create
+ sync_clips = AsyncMock()
+ recording_finalized_at = datetime(2026, 4, 26, tzinfo=UTC)
@asynccontextmanager
async def fake_prepare_recording_for_upload(path: str):
@@ -258,6 +261,7 @@ async def test_sync_browser_session_file_registers_recording_artifact(tmp_path):
patch("skyvern.forge.sdk.artifact.storage.s3.prepare_recording_for_upload", fake_prepare_recording_for_upload),
patch.object(storage, "_get_storage_class_for_org", new=AsyncMock(return_value=MagicMock())),
patch("skyvern.forge.sdk.artifact.storage.s3.calculate_sha256_for_file", return_value="sha-r"),
+ patch("skyvern.forge.sdk.artifact.storage.s3.sync_run_recording_clips", sync_clips),
patch("skyvern.forge.sdk.artifact.storage.s3.app") as app_module,
):
app_module.ARTIFACT_MANAGER = mock_artifact_manager
@@ -268,9 +272,11 @@ async def test_sync_browser_session_file_registers_recording_artifact(tmp_path):
local_file_path=str(recording_file),
remote_path="recording.webm",
date="2026-04-26",
+ recording_finalized_at=recording_finalized_at,
)
storage.async_client.upload_file_from_path.assert_awaited_once()
+ assert storage.async_client.upload_file_from_path.await_args.kwargs["raise_exception"] is True
assert storage.async_client.upload_file_from_path.call_args.args[0].endswith("/recording.mp4")
assert storage.async_client.upload_file_from_path.call_args.args[1] == str(compressed_file)
mock_create.assert_awaited_once()
@@ -282,6 +288,7 @@ async def test_sync_browser_session_file_registers_recording_artifact(tmp_path):
assert kwargs["file_size"] == compressed_file.stat().st_size
assert kwargs["uri"].startswith("s3://") and "/browser_sessions/pbs_1/videos/" in kwargs["uri"]
assert kwargs["uri"].endswith("/recording.mp4")
+ assert sync_clips.await_args.kwargs["now"] == recording_finalized_at
@pytest.mark.asyncio
diff --git a/tests/unit/test_video_utils.py b/tests/unit/test_video_utils.py
index 52661347e..7a3e13ff3 100644
--- a/tests/unit/test_video_utils.py
+++ b/tests/unit/test_video_utils.py
@@ -124,6 +124,19 @@ async def test_prepare_recording_for_upload_invokes_ffmpeg_with_h264_mp4_compres
assert src in captured_args
+async def test_prepare_recording_for_upload_keeps_finalized_mp4_without_ffmpeg(tmp_path) -> None:
+ src = tmp_path / "vendor.mp4"
+ src.write_bytes(b"finalized-vendor-video")
+
+ with patch.object(video_utils, "_prepare_recording_upload", AsyncMock()) as prepare:
+ async with prepare_recording_for_upload(str(src)) as prepared:
+ assert prepared.path == str(src)
+ assert prepared.file_extension == "mp4"
+
+ prepare.assert_not_awaited()
+
+
@pytest.mark.asyncio
async def test_prepare_recording_for_upload_can_disable_compression_and_stream_copy_remux(tmp_path) -> None:
src = str(tmp_path / "src.webm")
@@ -345,6 +358,12 @@ def test_plan_run_segment_unfinished_run_extends_to_video_end() -> None:
assert segment == (1800.0, 1800.0)
+def test_plan_run_segment_unfinished_run_treats_naive_video_start_as_utc() -> None:
+ video_start = datetime(2026, 1, 1, 10, 0)
+ segment = plan_run_segment(datetime(2026, 1, 1, 10, 30, tzinfo=UTC), None, video_start, 3600)
+ assert segment == (1800.0, 1800.0)
+
+
def test_plan_run_segment_too_short_returns_none() -> None:
video_start = datetime(2026, 1, 1, 10, 0, tzinfo=UTC)
segment = plan_run_segment(
diff --git a/tests/unit/test_workflow_service_status_concurrency.py b/tests/unit/test_workflow_service_status_concurrency.py
new file mode 100644
index 000000000..99197c4cc
--- /dev/null
+++ b/tests/unit/test_workflow_service_status_concurrency.py
@@ -0,0 +1,40 @@
+import asyncio
+
+import pytest
+
+from skyvern.forge.sdk.workflow.service import WorkflowService
+
+
+async def test_gather_with_max_in_flight_limits_parallelism() -> None:
+ service = WorkflowService()
+ state = {"active": 0, "max_active": 0}
+ lock = asyncio.Lock()
+
+ async def _task(_: int) -> int:
+ async with lock:
+ state["active"] += 1
+ state["max_active"] = max(state["max_active"], state["active"])
+
+ await asyncio.sleep(0.01)
+
+ async with lock:
+ state["active"] -= 1
+
+ return _
+
+ results = await service._gather_with_max_in_flight(
+ tuple(_task(i) for i in range(6)),
+ max_in_flight=2,
+ )
+
+ assert results == (0, 1, 2, 3, 4, 5)
+ assert state["max_active"] <= 2
+
+ state = {"active": 0, "max_active": 0}
+ results = await service._gather_with_max_in_flight(
+ tuple(_task(i) for i in range(4)),
+ max_in_flight=1,
+ )
+ assert results == (0, 1, 2, 3)
+ assert state["max_active"] <= 1
diff --git a/tests/unit/webeye/test_browser_session_response.py b/tests/unit/webeye/test_browser_session_response.py
index 04c647706..dfec9f625 100644
--- a/tests/unit/webeye/test_browser_session_response.py
+++ b/tests/unit/webeye/test_browser_session_response.py
@@ -1,11 +1,14 @@
+import asyncio
from datetime import datetime, timezone
-from unittest.mock import AsyncMock, patch
+from unittest.mock import AsyncMock, MagicMock, patch
import pytest
from skyvern.forge import app
from skyvern.forge.agent_functions import AgentFunction
+from skyvern.forge.sdk.schemas.files import FileInfo
from skyvern.forge.sdk.schemas.persistent_browser_sessions import PersistentBrowserSession
+from skyvern.webeye import schemas as browser_session_schemas
from skyvern.webeye.schemas import BrowserSessionResponse
# Every field a client is allowed to read off a browser session. Adding a field to
@@ -79,6 +82,71 @@ def test_browser_session_response_exposes_exactly_the_pinned_client_field_set()
assert set(BrowserSessionResponse.model_fields) == PINNED_CLIENT_FIELDS
+async def test_browser_session_response_uses_infrastructure_aware_recording_selection() -> None:
+ now = datetime.now(timezone.utc)
+ session = PersistentBrowserSession(
+ persistent_browser_session_id="pbs_123",
+ organization_id="org_123",
+ status="completed",
+ created_at=now,
+ modified_at=now,
+ )
+ pod_recording = FileInfo(url="https://recordings.example/pod", filename="playwright-video.webm")
+ vendor_recording = FileInfo(url="https://recordings.example/vendor", filename="pbs_123.mp4")
+ storage = MagicMock()
+ storage.get_shared_downloaded_files_in_browser_session = AsyncMock(return_value=[])
+ storage.get_shared_recordings_in_browser_session = AsyncMock(return_value=[pod_recording, vendor_recording])
+ selector = AsyncMock(return_value=[vendor_recording])
+
+ with (
+ patch.object(app.AGENT_FUNCTION, "select_browser_session_recordings", selector),
+ patch.object(app.AGENT_FUNCTION, "resolve_browser_session_connect_url", AsyncMock(return_value=None)),
+ ):
+ response = await asyncio.wait_for(BrowserSessionResponse.from_browser_session(session, storage), timeout=0.1)
+
+ assert response.recordings == [vendor_recording]
+ selector.assert_awaited_once_with(
+ organization_id="org_123",
+ browser_session_id="pbs_123",
+ recordings=[pod_recording, vendor_recording],
+ browser_vendor=None,
+ )
+
+
+async def test_browser_session_response_bounds_infrastructure_recording_selection(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ now = datetime.now(timezone.utc)
+ session = PersistentBrowserSession(
+ persistent_browser_session_id="pbs_123",
+ organization_id="org_123",
+ status="completed",
+ created_at=now,
+ modified_at=now,
+ )
+ pod_recording = FileInfo(url="https://recordings.example/pod", filename="playwright-video.webm")
+ storage = MagicMock()
+ storage.get_shared_downloaded_files_in_browser_session = AsyncMock(return_value=[])
+ storage.get_shared_recordings_in_browser_session = AsyncMock(return_value=[pod_recording])
+
+ async def stalled_selection(**_kwargs: object) -> list[FileInfo]:
+ await asyncio.sleep(1)
+ return []
+
+ selector = AsyncMock(side_effect=stalled_selection)
+ monkeypatch.setattr(browser_session_schemas, "GET_DOWNLOADED_FILES_TIMEOUT", 0.01)
+ with (
+ patch.object(app.AGENT_FUNCTION, "select_browser_session_recordings", selector),
+ patch.object(app.AGENT_FUNCTION, "resolve_browser_session_connect_url", AsyncMock(return_value=None)),
+ ):
+ response = await asyncio.wait_for(BrowserSessionResponse.from_browser_session(session, storage), timeout=0.1)
+
+ selector.assert_awaited_once()
+ assert response.recordings == []
+
+
def test_no_server_side_row_field_becomes_a_response_field() -> None:
leaked = server_side_row_fields() & set(BrowserSessionResponse.model_fields)
assert leaked == set()
diff --git a/tests/unit/workflow/test_conditional_branch_evaluation.py b/tests/unit/workflow/test_conditional_branch_evaluation.py
index d9abe2107..127f9a763 100644
--- a/tests/unit/workflow/test_conditional_branch_evaluation.py
+++ b/tests/unit/workflow/test_conditional_branch_evaluation.py
@@ -6,7 +6,7 @@ from unittest.mock import AsyncMock, MagicMock, patch
import pytest
import skyvern.forge.sdk.workflow.models.block as block_module
-from skyvern.exceptions import ConditionalBranchEvaluationError
+from skyvern.exceptions import BranchEvaluationContextTooLargeError, ConditionalBranchEvaluationError
from skyvern.forge.prompts import prompt_engine
from skyvern.forge.sdk.workflow.models.block import (
BranchCondition,
@@ -20,6 +20,11 @@ from skyvern.forge.sdk.workflow.models.block import (
from skyvern.forge.sdk.workflow.models.parameter import OutputParameter
from skyvern.schemas.workflows import BlockResult
+BRANCH_CONTEXT_TOO_LARGE_FAILURE_REASON = (
+ "Workflow branch evaluation context is too large to process safely. "
+ "Reduce the workflow input or prior block output size, then retry."
+)
+
def _output_parameter(key: str) -> OutputParameter:
now = datetime.now(UTC)
@@ -197,6 +202,144 @@ async def test_mixed_prompt_conditions_keep_browser_session() -> None:
evaluation_context.build_llm_safe_context_snapshot.assert_called_once() # type: ignore[attr-defined]
+async def test_oversized_branch_context_trips_before_extraction_and_returns_stable_failure() -> None:
+ block = _conditional_block()
+ oversized_context_value = "oversized-context-value " * 200_000
+
+ with (
+ patch.object(
+ BranchEvaluationContext,
+ "build_llm_safe_context_snapshot",
+ return_value={"sensitive_customer_key": oversized_context_value},
+ ),
+ patch("skyvern.forge.sdk.workflow.models.block.ExtractionBlock") as mock_extraction_cls,
+ patch("skyvern.forge.sdk.workflow.models.block.diagnostic_fingerprint", return_value="key-fingerprint"),
+ patch.object(block_module.LOG, "warning") as mock_warning,
+ patch.object(
+ block_module.app.WORKFLOW_CONTEXT_MANAGER,
+ "get_workflow_run_context",
+ new=MagicMock(return_value=None),
+ ),
+ patch.object(ConditionalBlock, "build_block_result", new_callable=AsyncMock) as mock_build_result,
+ ):
+ mock_extraction = MagicMock()
+ mock_extraction.execute = AsyncMock(
+ return_value=_failed_extraction_result(block.output_parameter, "downstream prompt failed")
+ )
+ mock_extraction_cls.return_value = mock_extraction
+ mock_build_result.return_value = BlockResult(
+ success=False,
+ output_parameter=block.output_parameter,
+ output_parameter_value=None,
+ failure_reason=BRANCH_CONTEXT_TOO_LARGE_FAILURE_REASON,
+ )
+
+ result = await block.execute(
+ workflow_run_id="wr_test",
+ workflow_run_block_id="wrb_test",
+ organization_id="org_test",
+ )
+
+ assert result.failure_reason == BRANCH_CONTEXT_TOO_LARGE_FAILURE_REASON
+ assert mock_build_result.await_args.kwargs["failure_reason"] == BRANCH_CONTEXT_TOO_LARGE_FAILURE_REASON
+ mock_extraction_cls.assert_not_called()
+
+ circuit_logs = [
+ call
+ for call in mock_warning.call_args_list
+ if call.args[0] == "conditional_branch_context_circuit_breaker_tripped"
+ ]
+ assert len(circuit_logs) == 1
+ circuit_log = circuit_logs[0]
+ assert circuit_log.kwargs["goal_token_count"] > 180_000
+ assert circuit_log.kwargs["max_goal_tokens"] == 150_000
+ assert circuit_log.kwargs["reserved_tokens"] == 30_000
+ assert circuit_log.kwargs["context_key_count"] == 1
+ assert circuit_log.kwargs["top_context_contributors"] == [
+ {
+ "key_fingerprint": "key-fingerprint",
+ "serialized_bytes": len(f'"{oversized_context_value}"'.encode()),
+ "token_count": circuit_log.kwargs["top_context_contributors"][0]["token_count"],
+ }
+ ]
+ assert "sensitive_customer_key" not in str(circuit_log)
+ assert oversized_context_value not in str(circuit_log)
+
+
+async def test_branch_goal_at_reserved_budget_boundary_still_executes_unchanged() -> None:
+ block = _conditional_block()
+ branch = block.branch_conditions[0]
+ evaluation_context = BranchEvaluationContext(workflow_run_context=None, template_renderer=lambda expr: expr)
+ evaluation_context.build_llm_safe_context_snapshot = MagicMock(return_value={"plan": "premium"}) # type: ignore[method-assign]
+
+ def _token_count(value: str) -> int:
+ return 150_000 if value == "goal-at-boundary" else 2
+
+ with (
+ patch(
+ "skyvern.forge.sdk.workflow.models.block.prompt_engine.load_prompt",
+ return_value="goal-at-boundary",
+ ) as mock_prompt,
+ patch("skyvern.forge.sdk.workflow.models.block.count_tokens", side_effect=_token_count) as mock_count_tokens,
+ patch("skyvern.forge.sdk.workflow.models.block.ExtractionBlock") as mock_extraction_cls,
+ ):
+ mock_extraction = MagicMock()
+ mock_extraction.execute = AsyncMock(
+ return_value=_extraction_result(
+ block.output_parameter,
+ [{"condition_index": 1, "reasoning": "ok", "result": True}],
+ )
+ )
+ mock_extraction_cls.return_value = mock_extraction
+
+ results, _, extraction_goal, _ = await block._evaluate_prompt_branches(
+ branches=[branch],
+ evaluation_context=evaluation_context,
+ workflow_run_id="wr_test",
+ workflow_run_block_id="wrb_test",
+ organization_id="org_test",
+ )
+
+ assert results == [True]
+ assert extraction_goal == "goal-at-boundary"
+ assert mock_extraction_cls.call_args.kwargs["data_extraction_goal"] == "goal-at-boundary"
+ assert mock_prompt.call_args.kwargs["context_json"] == '{"plan": "premium"}'
+ assert any(call.args == ("goal-at-boundary",) for call in mock_count_tokens.call_args_list)
+
+
+async def test_branch_goal_above_reserved_budget_trips_before_extraction() -> None:
+ block = _conditional_block()
+ branch = block.branch_conditions[0]
+ evaluation_context = BranchEvaluationContext(workflow_run_context=None, template_renderer=lambda expr: expr)
+ evaluation_context.build_llm_safe_context_snapshot = MagicMock(return_value={"plan": "premium"}) # type: ignore[method-assign]
+
+ def _token_count(value: str) -> int:
+ return 150_001 if value == "goal-above-boundary" else 2
+
+ with (
+ patch(
+ "skyvern.forge.sdk.workflow.models.block.prompt_engine.load_prompt",
+ return_value="goal-above-boundary",
+ ),
+ patch("skyvern.forge.sdk.workflow.models.block.count_tokens", side_effect=_token_count),
+ patch("skyvern.forge.sdk.workflow.models.block.ExtractionBlock") as mock_extraction_cls,
+ patch("skyvern.forge.sdk.workflow.models.block.diagnostic_fingerprint", return_value="key-fingerprint"),
+ ):
+ with pytest.raises(BranchEvaluationContextTooLargeError):
+ await block._evaluate_prompt_branches(
+ branches=[branch],
+ evaluation_context=evaluation_context,
+ workflow_run_id="wr_test",
+ workflow_run_block_id="wrb_test",
+ organization_id="org_test",
+ )
+
+ mock_extraction_cls.assert_not_called()
+
+
@pytest.mark.asyncio
async def test_jinja_render_failure_falls_back_to_extraction_block() -> None:
block = _conditional_block()