Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
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.pyindex 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.pyindex 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.pyindex 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 FileInfofrom skyvern.forge.sdk.schemas.organizations import Organizationfrom skyvern.forge.sdk.schemas.tasks import Task, TaskStatusfrom 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.pyindex 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.pathupload_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.pyindex 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, abstractmethodfrom collections.abc import Awaitable, Callable+from datetime import datetimefrom typing import BinaryIO, castfrom 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:passdiff --git a/skyvern/forge/sdk/artifact/storage/gcs.py b/skyvern/forge/sdk/artifact/storage/gcs.pyindex 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.pathupload_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.pyindex 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.pyindex 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.pyindex 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_servicefrom skyvern.services.error_detection_service import detect_user_defined_errors_for_taskfrom skyvern.services.self_heal_cap import check_and_increment_self_heal_cap+from skyvern.utils.prompt_engine import PROMPT_HARD_CEILING_TOKENSfrom skyvern.utils.strings import generate_random_stringfrom skyvern.utils.templating import get_missing_variablesfrom 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: renderedfor 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.pyindex e1bc75413..e9e77bf60 100644--- a/skyvern/forge/sdk/workflow/service.py+++ b/skyvern/forge/sdk/workflow/service.py@@ -11,7 +11,7 @@ import textwrapimport timeimport uuidfrom collections import deque-from collections.abc import Sequence+from collections.abc import Awaitable, Sequencefrom dataclasses import dataclass, fieldfrom datetime import UTC, datetime, timedeltafrom 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)))+@staticmethodasync 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.pyindex 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.pyindex 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[PreparedRif 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 Nonestart = _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.pyindex 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 = selectorapp_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.pyindex 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 infrom __future__ import annotationsfrom contextlib import asynccontextmanager+from datetime import UTC, datetimefrom unittest.mock import AsyncMock, MagicMock, patchfrom 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)@asynccontextmanagerasync 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 Trueassert 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_sizeassert 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.asynciodiff --git a/tests/unit/test_video_utils.py b/tests/unit/test_video_utils.pyindex 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_compresassert 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.asyncioasync 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.pynew file mode 100644index 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"] <= 1diff --git a/tests/unit/webeye/test_browser_session_response.py b/tests/unit/webeye/test_browser_session_response.pyindex 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 asynciofrom datetime import datetime, timezone-from unittest.mock import AsyncMock, patch+from unittest.mock import AsyncMock, MagicMock, patchimport pytestfrom skyvern.forge import appfrom skyvern.forge.agent_functions import AgentFunction+from skyvern.forge.sdk.schemas.files import FileInfofrom skyvern.forge.sdk.schemas.persistent_browser_sessions import PersistentBrowserSession+from skyvern.webeye import schemas as browser_session_schemasfrom 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.pyindex 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, patchimport pytestimport skyvern.forge.sdk.workflow.models.block as block_module-from skyvern.exceptions import ConditionalBranchEvaluationError+from skyvern.exceptions import BranchEvaluationContextTooLargeError, ConditionalBranchEvaluationErrorfrom skyvern.forge.prompts import prompt_enginefrom 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 OutputParameterfrom 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.asyncioasync def test_jinja_render_failure_falls_back_to_extraction_block() -> None:block = _conditional_block()